MNE-CPP  beta 1.0
datapackage.cpp
Go to the documentation of this file.
1 //=============================================================================================================
37 //*************************************************************************************************************
38 //=============================================================================================================
39 // INCLUDES
40 //=============================================================================================================
41 
42 #include "datapackage.h"
43 
44 
45 //*************************************************************************************************************
46 //=============================================================================================================
47 // USED NAMESPACES
48 //=============================================================================================================
49 
50 using namespace MNEBrowseRawQt;
51 
52 
53 //*************************************************************************************************************
54 //=============================================================================================================
55 // DEFINE MEMBER METHODS
56 //=============================================================================================================
57 
58 DataPackage::DataPackage(const MatrixXdR &originalRawData, const MatrixXdR &originalRawTime, int cutFront, int cutBack)
59 : m_iCutFrontRaw(cutFront)
60 , m_iCutBackRaw(cutBack)
61 , m_iCutFrontProc(cutFront)
62 , m_iCutBackProc(cutBack)
63 {
64  if(originalRawData.rows() != 0 && originalRawData.cols() != 0) {
65  setOrigRawData(originalRawData, m_iCutFrontRaw, m_iCutBackRaw);
66 
67  m_timeRawOriginal = originalRawTime;
68  m_timeRawMapped = cutData(m_timeRawOriginal, m_iCutFrontRaw, m_iCutBackRaw);
69  }
70 
71  //Init processed data with zero and double the multiple integer of 2 (because of zero padding)
72  int exp = ceil(MNEMath::log2(originalRawTime.cols()));
73  int length = pow(2, exp+1);
74 
75  m_dataProcOriginal = MatrixXdR::Zero(m_dataRawOriginal.rows(), length);
76  m_dataProcMapped = MatrixXdR::Zero(m_dataRawMapped.rows(), m_dataRawMapped.cols());
77 
78  //Init mean data
79  m_dataRawMean = calculateMatMean(m_dataRawMapped);
80  m_dataProcMean = calculateMatMean(m_dataProcMapped);
81 }
82 
83 
84 //*************************************************************************************************************
85 
86 void DataPackage::setOrigRawData(const MatrixXdR &originalRawData, int cutFront, int cutBack)
87 {
88  //set orignal data
89  m_dataRawOriginal = originalRawData;
90 
91  //Cut data
92  m_dataRawMapped = cutData(m_dataRawOriginal, cutFront, cutBack);
93 
94  if(cutFront != m_iCutFrontRaw)
95  m_iCutFrontRaw = cutFront;
96 
97  if(cutBack != m_iCutBackRaw)
98  m_iCutBackRaw = cutBack;
99 
100  //Calculate mean
101  m_dataRawMean = calculateMatMean(m_dataRawMapped);
102 }
103 
104 
105 //*************************************************************************************************************
106 
107 void DataPackage::setOrigRawData(const RowVectorXd &originalRawData, int row, int cutFront, int cutBack)
108 {
109  if(originalRawData.cols() != m_dataRawOriginal.cols() || row >= m_dataRawOriginal.rows()){
110  qDebug()<<"DataPackage::setOrigRawData - cannot set row data to m_dataRawOriginal";
111  return;
112  }
113 
114  //set orignal data at row row
115  m_dataRawOriginal.row(row) = originalRawData;
116 
117  //Cut data
118  m_dataRawMapped.row(row) = cutData(m_dataRawOriginal, cutFront, cutBack);
119 
120  if(cutFront != m_iCutFrontRaw)
121  m_iCutFrontRaw = cutFront;
122 
123  if(cutBack != m_iCutBackRaw)
124  m_iCutBackRaw = cutBack;
125 
126  //Calculate mean
127  m_dataRawMean(row) = calculateRowMean(m_dataRawMapped.row(row));
128 }
129 
130 
131 //*************************************************************************************************************
132 
133 void DataPackage::setOrigProcData(const MatrixXdR &originalProcData, int cutFront, int cutBack)
134 {
135  //set orignal processed data
136  m_dataProcOriginal = originalProcData;
137 
138  //Cut data
139  m_dataProcMapped = cutData(m_dataProcOriginal, cutFront, cutBack);
140 
141  if(cutFront != m_iCutFrontProc)
142  m_iCutFrontProc = cutFront;
143 
144  if(cutBack != m_iCutBackProc)
145  m_iCutBackProc = cutBack;
146 
147  //Calculate mean
148  m_dataProcMean = calculateMatMean(m_dataProcMapped);
149 }
150 
151 
152 //*************************************************************************************************************
153 
154 void DataPackage::setMappedProcData(const MatrixXdR &originalProcData, int cutFront, int cutBack)
155 {
156  //Cut data
157  m_dataProcMapped = cutData(originalProcData, cutFront, cutBack);
158 
159  if(cutFront != m_iCutFrontProc)
160  m_iCutFrontProc = cutFront;
161 
162  if(cutBack != m_iCutBackProc)
163  m_iCutBackProc = cutBack;
164 
165  //Calculate mean
166  m_dataProcMean = calculateMatMean(m_dataProcMapped);
167 }
168 
169 
170 //*************************************************************************************************************
171 
172 void DataPackage::setOrigProcData(const RowVectorXd &originalProcData, int row, int cutFront, int cutBack)
173 {
174  if(originalProcData.cols() != m_dataProcOriginal.cols() || row >= m_dataProcOriginal.rows()){
175  qDebug()<<"DataPackage::setOrigProcData - cannot set row data to m_dataProcOriginal";
176  return;
177  }
178 
179  //set orignal data at row row
180  m_dataProcOriginal.row(row) = originalProcData;
181 
182  //Cut data
183  m_dataProcMapped.row(row) = cutData(originalProcData, cutFront, cutBack);
184 
185  if(cutFront != m_iCutFrontProc)
186  m_iCutFrontProc = cutFront;
187 
188  if(cutBack != m_iCutBackProc)
189  m_iCutBackProc = cutBack;
190 
191  //Calculate mean
192  m_dataProcMean(row) = calculateRowMean(m_dataProcMapped.row(row));
193 }
194 
195 
196 //*************************************************************************************************************
197 
198 void DataPackage::setMappedProcData(const RowVectorXd &originalProcData, int row, int cutFront, int cutBack)
199 {
200  if(originalProcData.cols()-cutFront-cutBack != m_dataProcMapped.cols() || row >= m_dataProcMapped.rows()){
201  qDebug()<<"DataPackage::setMappedProcData - cannot set row data to m_dataProcOriginal";
202  return;
203  }
204 
205  //Cut data
206  m_dataProcMapped.row(row) = cutData(originalProcData, cutFront, cutBack);
207 
208  if(cutFront != m_iCutFrontProc)
209  m_iCutFrontProc = cutFront;
210 
211  if(cutBack != m_iCutBackProc)
212  m_iCutBackProc = cutBack;
213 
214  //Calculate mean
215  m_dataProcMean(row) = calculateRowMean(m_dataProcMapped.row(row));
216 }
217 
218 //*************************************************************************************************************
219 
220 const MatrixXdR & DataPackage::dataRawOrig()
221 {
222  return m_dataRawOriginal;
223 }
224 
225 
226 //*************************************************************************************************************
227 
228 const MatrixXdR & DataPackage::dataProcOrig()
229 {
230  return m_dataProcOriginal;
231 }
232 
233 
234 //*************************************************************************************************************
235 
236 const MatrixXdR & DataPackage::dataRaw()
237 {
238  return m_dataRawMapped;
239 }
240 
241 
242 //*************************************************************************************************************
243 
244 const MatrixXdR & DataPackage::dataProc()
245 {
246  return m_dataProcMapped;
247 }
248 
249 
250 //*************************************************************************************************************
251 
253 {
254  if(row>=m_dataProcMean.rows())
255  return 0;
256 
257  return m_dataProcMean(row);
258 }
259 
260 
261 //*************************************************************************************************************
262 
264 {
265  if(row>=m_dataRawMean.rows())
266  return 0;
267 
268  return m_dataRawMean(row);
269 }
270 
271 
272 //*************************************************************************************************************
273 
274 void DataPackage::applyFFTFilter(int channelNumber, QSharedPointer<FilterOperator> filter, bool useRawData)
275 {
276  if(channelNumber >= m_dataRawOriginal.rows()){
277  qDebug()<<"DataPackage::applyFFTFilter - channel number out of range.";
278  return;
279  }
280 
281  if(useRawData)
282  m_dataProcOriginal.row(channelNumber) = filter->applyFFTFilter(m_dataRawOriginal.row(channelNumber)).eval();
283  else
284  m_dataProcOriginal.row(channelNumber) = filter->applyFFTFilter(m_dataProcOriginal.row(channelNumber)).eval();
285 
286  //Cut filtered m_dataProcOriginal
287  m_dataProcMapped = cutData(m_dataProcOriginal, m_iCutFrontProc, m_iCutBackProc);
288 
289  //Calculate mean
290  m_dataProcMean(channelNumber) = calculateRowMean(m_dataProcMapped);
291 }
292 
293 
294 //*************************************************************************************************************
295 
296 MatrixXdR DataPackage::cutData(const MatrixXdR &originalData, int cutFront, int cutBack)
297 {
298  if(originalData.cols()-cutFront-cutBack < 0 || cutFront>originalData.cols()) {
299  qDebug()<<"DataPackage::cutData - cutFront or cutBack do not fit. Aborting mapping and returning original data.";
300  MatrixXdR returnMat = originalData;
301  return returnMat;
302  }
303 
304  //Cut original data using block
305  return (MatrixXdR)originalData.block(0, cutFront, originalData.rows(), originalData.cols()-cutFront-cutBack);
306 }
307 
308 
309 //*************************************************************************************************************
310 
311 RowVectorXd DataPackage::cutData(const RowVectorXd &originalData, int cutFront, int cutBack)
312 {
313  if(originalData.cols()-cutFront-cutBack < 0 || cutFront>originalData.cols()) {
314  qDebug()<<"DataPackage::cutData - cutFront or cutBack do not fit. Aborting mapping and returning original data.";
315  RowVectorXd returnVec = originalData;
316  return returnVec;
317  }
318 
319  //Cut original data using segment
320  return (RowVectorXd)originalData.segment(cutFront, originalData.cols()-cutFront-cutBack);
321 }
322 
323 
324 //*************************************************************************************************************
325 
326 VectorXd DataPackage::calculateMatMean(const MatrixXd &dataMat)
327 {
328  VectorXd channelMeans(dataMat.rows());
329 
330  for(int i = 0; i<channelMeans.rows(); i++)
331  channelMeans[i] = dataMat.row(i).mean();
332 
333  return channelMeans;
334 }
335 
336 
337 //*************************************************************************************************************
338 
339 double DataPackage::calculateRowMean(const VectorXd &dataRow)
340 {
341  return dataRow.mean();
342 }
343 
344 
345 
346 
347 
void setMappedProcData(const MatrixXdR &originalProcData, int cutFront, int cutBack)
const MatrixXdR & dataProc()
Contains the declaration of the DataPackage class.
const MatrixXdR & dataRaw()
void setOrigRawData(const MatrixXdR &originalRawData, int cutFront=0, int cutBack=0)
Definition: datapackage.cpp:86
const MatrixXdR & dataRawOrig()
const MatrixXdR & dataProcOrig()
double dataProcMean(int row)
void applyFFTFilter(int channelNumber, QSharedPointer< FilterOperator > filter, bool useRawData=true)
DataPackage(const MatrixXdR &originalRawData=MatrixXdR(0, 0), const MatrixXdR &originalRawTime=MatrixXdR(0, 0), int cutFront=0, int cutBack=0)
Definition: datapackage.cpp:58
void setOrigProcData(const MatrixXdR &originalProcData, int cutFront=0, int cutBack=0)