MNE-CPP  beta 1.0
rtave.cpp
Go to the documentation of this file.
1 //=============================================================================================================
38 //*************************************************************************************************************
39 //=============================================================================================================
40 // INCLUDES
41 //=============================================================================================================
42 
43 #include "rtave.h"
44 
45 #include <utils/ioutils.h>
46 
47 #include <iostream>
48 
49 
50 //*************************************************************************************************************
51 //=============================================================================================================
52 // QT INCLUDES
53 //=============================================================================================================
54 
55 #include <QMutexLocker>
56 #include <QDebug>
57 
58 
59 //*************************************************************************************************************
60 //=============================================================================================================
61 // USED NAMESPACES
62 //=============================================================================================================
63 
64 using namespace RTINVLIB;
65 using namespace FIFFLIB;
66 using namespace UTILSLIB;
67 
68 
69 //*************************************************************************************************************
70 //=============================================================================================================
71 // DEFINE MEMBER METHODS
72 //=============================================================================================================
73 
74 RtAve::RtAve(quint32 numAverages, quint32 p_iPreStimSamples, quint32 p_iPostStimSamples, FiffInfo::SPtr p_pFiffInfo, QObject *parent)
75 : QThread(parent)
76 , m_iNumAverages(numAverages)
77 , m_iPreStimSamples(p_iPreStimSamples)
78 , m_iPostStimSamples(p_iPostStimSamples)
79 , m_pFiffInfo(p_pFiffInfo)
80 , m_bIsRunning(false)
81 , m_bAutoAspect(true)
82 {
83  qRegisterMetaType<FiffEvoked::SPtr>("FiffEvoked::SPtr");
84 }
85 
86 
87 //*************************************************************************************************************
88 
90 {
91  if(this->isRunning())
92  stop();
93 }
94 
95 
96 //*************************************************************************************************************
97 
98 void RtAve::append(const MatrixXd &p_DataSegment)
99 {
100  QMutexLocker locker(&m_qMutex);
101  // ToDo handle change buffersize
102  if(!m_pRawMatrixBuffer)
103  m_pRawMatrixBuffer = CircularMatrixBuffer<double>::SPtr(new CircularMatrixBuffer<double>(128, p_DataSegment.rows(), p_DataSegment.cols()));
104 
105  m_pRawMatrixBuffer->push(&p_DataSegment);
106 }
107 
108 
109 //*************************************************************************************************************
110 
111 void RtAve::setAverages(qint32 numAve)
112 {
113  m_qMutex.lock();
114  m_iNumAverages = numAve;
115  m_qMutex.unlock();
116  emit numAveragesChanged();
117 }
118 
119 
120 //*************************************************************************************************************
121 
122 void RtAve::setPreStim(qint32 samples)
123 {
124  QMutexLocker locker(&m_qMutex);
125  m_iNewPreStimSamples = samples;
126 }
127 
128 
129 //*************************************************************************************************************
130 
131 void RtAve::setPostStim(qint32 samples)
132 {
133  QMutexLocker locker(&m_qMutex);
134  m_iNewPostStimSamples = samples;
135 }
136 
137 
138 //*************************************************************************************************************
139 
140 void RtAve::assemblePostStimulus(const QList<QPair<QList<qint32>, MatrixXd> > &p_qListRawMatBuf, qint32 p_iStimIdx)
141 {
142  QMutexLocker locker(&m_qMutex);
143  if(m_iPostStimSamples > 0)
144  {
145  // middle of the assembled buffers
146  float ratio = (float)m_iPreStimSamples/((float)(m_iPreStimSamples+m_iPostStimSamples));
147  qint32 t_iBuffWithStim = floor((p_qListRawMatBuf.size()-1)*ratio) + 1;
148 
149  qint32 nrows = p_qListRawMatBuf[t_iBuffWithStim].second.rows();
150  qint32 ncols = p_qListRawMatBuf[t_iBuffWithStim].second.cols();
151 
152  //Stimulus channel row
153  qint32 t_iRowIdx = m_qListStimChannelIdcs[p_iStimIdx];
154 
155  qint32 nSampleCount = 0;
156 
157  MatrixXd t_matPostStim(nrows, m_iPostStimSamples);
158  qint32 t_curBufIdx = t_iBuffWithStim;
159 
160  qint32 t_iSize = 0;
161 
162  qint32 pos = 0;
163  p_qListRawMatBuf[t_iBuffWithStim].second.row(t_iRowIdx).maxCoeff(&pos);
164 
165  //
166  // assemble poststimulus
167  //
168 
169  // start from the stimulus itself
170  if(pos >= 0)
171  {
172  t_iSize = ncols - pos;
173  if(t_iSize <= m_iPostStimSamples)
174  {
175  t_matPostStim.block(0, 0, nrows, t_iSize) = p_qListRawMatBuf[t_iBuffWithStim].second.block(0, pos, nrows, t_iSize);
176  nSampleCount += t_iSize;
177  }
178  else
179  {
180  t_matPostStim.block(0, 0, nrows, m_iPostStimSamples) = p_qListRawMatBuf[t_iBuffWithStim].second.block(0, pos, nrows, m_iPostStimSamples);
181  nSampleCount = m_iPostStimSamples;
182  }
183  }
184 
185  ++t_curBufIdx;
186 
187  // remaining samples
188  while(nSampleCount < m_iPostStimSamples)
189  {
190  t_iSize = m_iPostStimSamples-nSampleCount;
191 
192  if(ncols <= t_iSize)
193  {
194  t_matPostStim.block(0, nSampleCount, nrows, ncols) = p_qListRawMatBuf[t_curBufIdx].second.block(0, 0, nrows, ncols);
195  nSampleCount += ncols;
196  }
197  else
198  {
199  t_matPostStim.block(0, nSampleCount, nrows, t_iSize) = p_qListRawMatBuf[t_curBufIdx].second.block(0, 0, nrows, t_iSize);
200  nSampleCount = m_iPostStimSamples;
201  }
202 
203  ++t_curBufIdx;
204  }
205 
206  //
207  //Store in right post stimulus buffer vector
208  //
209  m_qListQListPostStimBuf[p_iStimIdx].append(t_matPostStim);
210  }
211 }
212 
213 
214 //*************************************************************************************************************
215 
216 void RtAve::assemblePreStimulus(const QList<QPair<QList<qint32>, MatrixXd> > &p_qListRawMatBuf, qint32 p_iStimIdx)
217 {
218  QMutexLocker locker(&m_qMutex);
219  if(m_iPreStimSamples > 0)
220  {
221  // stimulus containing buffer of the assembled buffers
222  float ratio = (float)m_iPreStimSamples/((float)(m_iPreStimSamples+m_iPostStimSamples));
223  qint32 t_iBuffWithStim = floor((p_qListRawMatBuf.size()-1)*ratio) + 1;
224  qint32 nrows = p_qListRawMatBuf[t_iBuffWithStim].second.rows();
225  qint32 ncols = p_qListRawMatBuf[t_iBuffWithStim].second.cols();
226 
227  //Stimulus channel row
228  qint32 t_iRowIdx = m_qListStimChannelIdcs[p_iStimIdx];
229 
230  qint32 nSampleCount = m_iPreStimSamples;
231 
232  MatrixXd t_matPreStim(nrows, m_iPreStimSamples);
233  qint32 t_curBufIdx = t_iBuffWithStim;
234 
235  qint32 t_iStart = 0;
236 
237  qint32 pos = 0;
238  p_qListRawMatBuf[t_iBuffWithStim].second.row(t_iRowIdx).maxCoeff(&pos);
239 
240  //
241  // assemble prestimulus
242  //
243 
244  // start from the stimulus itself
245  if(pos > 0)
246  {
247  t_iStart = m_iPreStimSamples - pos;
248  if(t_iStart >= 0)
249  {
250  t_matPreStim.block(0, t_iStart, nrows, pos) = p_qListRawMatBuf[t_iBuffWithStim].second.block(0, 0, nrows, pos);
251  nSampleCount -= pos;
252  }
253  else
254  {
255  t_matPreStim.block(0, 0, nrows, m_iPreStimSamples) = p_qListRawMatBuf[t_iBuffWithStim].second.block(0, -t_iStart, nrows, m_iPreStimSamples);
256  nSampleCount = 0;
257  }
258  }
259  --t_curBufIdx;
260 
261  // remaining samples
262  while(nSampleCount > 0)
263  {
264  t_iStart = nSampleCount - ncols;
265 
266  if(t_iStart >= 0)
267  {
268  t_matPreStim.block(0, t_iStart, nrows, ncols) = p_qListRawMatBuf[t_curBufIdx].second.block(0, 0, nrows, ncols);
269  nSampleCount -= ncols;
270  }
271  else
272  {
273  t_matPreStim.block(0, 0, nrows, nSampleCount) = p_qListRawMatBuf[t_curBufIdx].second.block(0, -t_iStart, nrows, nSampleCount);
274  nSampleCount = 0;
275  }
276 
277  --t_curBufIdx;
278  }
279 
280  //
281  //Store in right pre stimulus buffer vector
282  //
283  m_qListQListPreStimBuf[p_iStimIdx].append(t_matPreStim);
284  }
285 }
286 
287 
288 //*************************************************************************************************************
289 
291 {
292  //Check if the thread is already or still running. This can happen if the start button is pressed immediately after the stop button was pressed. In this case the stopping process is not finished yet but the start process is initiated.
293  if(this->isRunning())
294  QThread::wait();
295 
296  m_qMutex.lock();
297  m_bIsRunning = true;
298  m_qMutex.unlock();
299 
300  QThread::start();
301 
302  return true;
303 }
304 
305 
306 //*************************************************************************************************************
307 
309 {
310  m_qMutex.lock();
311  m_bIsRunning = false;
312  m_qMutex.unlock();
313 
314  m_pRawMatrixBuffer->releaseFromPop();
315 
316  m_pRawMatrixBuffer->clear();
317 
318  return true;
319 }
320 
321 
322 //*************************************************************************************************************
323 
325 {
326  //
327  // Inits & Clears
328  //
329  m_qMutex.lock();
330  quint32 t_nSamplesPerBuf = 0;
331  QList<QPair<QList<qint32>, MatrixXd> > t_qListRawMatBuf;
332 
333  FiffEvoked::SPtr evoked(new FiffEvoked());
334  VectorXd mu;
335  qint32 i = 0;
336  qint32 j = 0;
337 
338  m_qListQListPreStimBuf.clear();
339  m_qListQListPostStimBuf.clear();
340  m_qListPreStimAve.clear();
341  m_qListPostStimAve.clear();
342  m_qListStimAve.clear();
343 
344  //
345  // get num stim channels
346  //
347  m_qListStimChannelIdcs.clear();
348  MatrixXd t_mat;
349  QList<MatrixXd> t_qListMat;
350  for(i = 0; i < m_pFiffInfo->nchan; ++i)
351  {
352  if(m_pFiffInfo->chs[i].kind == FIFFV_STIM_CH && (m_pFiffInfo->chs[i].ch_name != QString("STI 014")))
353  {
354  m_qListStimChannelIdcs.append(i);
355 
356  m_qListQListPreStimBuf.push_back(t_qListMat);
357  m_qListQListPostStimBuf.push_back(t_qListMat);
358  m_qListPreStimAve.push_back(t_mat);
359  m_qListPostStimAve.push_back(t_mat);
360  m_qListStimAve.push_back(t_mat);
361  }
362  }
363 
364 
365  float T = 1.0/m_pFiffInfo->sfreq;
366 
367  // pre real-time evoked response
368  FiffEvoked t_preStimEvoked;
369  t_preStimEvoked.setInfo(*m_pFiffInfo.data());
370  t_preStimEvoked.nave = m_iNumAverages;
371  t_preStimEvoked.aspect_kind = FIFFV_ASPECT_AVERAGE;
372  t_preStimEvoked.times.resize(m_iPreStimSamples);
373  t_preStimEvoked.times[0] = -T*m_iPreStimSamples;
374  for(i = 1; i < t_preStimEvoked.times.size(); ++i)
375  t_preStimEvoked.times[i] = t_preStimEvoked.times[i-1] + T;
376  t_preStimEvoked.first = t_preStimEvoked.times[0];
377  t_preStimEvoked.last = t_preStimEvoked.times[t_preStimEvoked.times.size()-1];
378 
379  // post real-time evoked full response
380  FiffEvoked t_postStimEvoked;
381  t_postStimEvoked.setInfo(*m_pFiffInfo.data());
382  t_postStimEvoked.nave = m_iNumAverages;
383  t_postStimEvoked.aspect_kind = FIFFV_ASPECT_AVERAGE;
384  t_postStimEvoked.times.resize(m_iPostStimSamples);
385  t_postStimEvoked.times[0] = 0;
386  for(i = 1; i < t_postStimEvoked.times.size(); ++i)
387  t_postStimEvoked.times[i] = t_postStimEvoked.times[i-1] + T;
388  t_postStimEvoked.first = t_postStimEvoked.times[0];
389  t_postStimEvoked.last = t_postStimEvoked.times[t_postStimEvoked.times.size()-1];
390 
391  // Full real-time evoked response
392  FiffEvoked t_stimEvoked;
393  t_stimEvoked.setInfo(*m_pFiffInfo.data());
394  t_stimEvoked.nave = m_iNumAverages;
395  t_stimEvoked.aspect_kind = FIFFV_ASPECT_AVERAGE;
396  t_stimEvoked.times.resize(m_iPreStimSamples+m_iPostStimSamples);
397  t_stimEvoked.times[0] = -T*m_iPreStimSamples;
398  for(i = 1; i < t_stimEvoked.times.size(); ++i)
399  t_stimEvoked.times[i] = t_stimEvoked.times[i-1] + T;
400  t_stimEvoked.first = t_stimEvoked.times[0];
401  t_stimEvoked.last = t_stimEvoked.times[t_stimEvoked.times.size()-1];
402 
403 
404  qint32 count = 0;
405 
406  m_iNewPreStimSamples = m_iPreStimSamples;
407  m_iNewPostStimSamples = m_iPostStimSamples;
408 
409  m_qMutex.unlock();
410 
411  //Enter the main loop
412  while(true)
413  {
414  {
415  QMutexLocker locker(&m_qMutex);
416  if(!m_bIsRunning)
417  break;
418  }
419 
420  bool doProcessing = false;
421  {
422  QMutexLocker locker(&m_qMutex);
423  if(m_pRawMatrixBuffer)
424  doProcessing = true;
425  }
426 
427  if(doProcessing)
428  {
429  //
430  // Reset when stim size changed
431  //
432  m_qMutex.lock();
433  if(m_iNewPreStimSamples != m_iPreStimSamples || m_iNewPostStimSamples != m_iPostStimSamples)
434  {
435  m_iPreStimSamples = m_iNewPreStimSamples;
436  m_iPostStimSamples = m_iNewPostStimSamples;
437 
438  // pre real-time evoked response
439  t_preStimEvoked.times.resize(m_iPreStimSamples);
440  t_preStimEvoked.times[0] = -T*m_iPreStimSamples;
441  for(i = 1; i < t_preStimEvoked.times.size(); ++i)
442  t_preStimEvoked.times[i] = t_preStimEvoked.times[i-1] + T;
443  t_preStimEvoked.first = t_preStimEvoked.times[0];
444  t_preStimEvoked.last = t_preStimEvoked.times[t_preStimEvoked.times.size()-1];
445 
446  // post real-time evoked full response
447  t_postStimEvoked.times.resize(m_iPostStimSamples);
448  t_postStimEvoked.times[0] = 0;
449  for(i = 1; i < t_postStimEvoked.times.size(); ++i)
450  t_postStimEvoked.times[i] = t_postStimEvoked.times[i-1] + T;
451  t_postStimEvoked.first = t_postStimEvoked.times[0];
452  t_postStimEvoked.last = t_postStimEvoked.times[t_postStimEvoked.times.size()-1];
453 
454  // Full real-time evoked response
455  t_stimEvoked.times.resize(m_iPreStimSamples+m_iPostStimSamples);
456  t_stimEvoked.times[0] = -T*m_iPreStimSamples;
457  for(i = 1; i < t_stimEvoked.times.size(); ++i)
458  t_stimEvoked.times[i] = t_stimEvoked.times[i-1] + T;
459  t_stimEvoked.first = t_stimEvoked.times[0];
460  t_stimEvoked.last = t_stimEvoked.times[t_stimEvoked.times.size()-1];
461 
462 
463  MatrixXd t_resetMat;
464  t_qListRawMatBuf.clear();
465  m_qListPreStimAve.clear();
466  m_qListPostStimAve.clear();
467  m_qListStimAve.clear();
468 
469  for(qint32 i = 0; i < m_qListQListPreStimBuf.size(); ++i)
470  {
471  m_qListQListPreStimBuf[i].clear();
472  m_qListQListPostStimBuf[i].clear();
473  m_qListPreStimAve.push_back(t_resetMat);
474  m_qListPostStimAve.push_back(t_resetMat);
475  m_qListStimAve.push_back(t_resetMat);
476  }
477  }
478  m_qMutex.unlock();
479 
480  //
481  // Acquire Data
482  //
483  MatrixXd rawSegment = m_pRawMatrixBuffer->pop();
484  if(t_nSamplesPerBuf == 0)
485  t_nSamplesPerBuf = rawSegment.cols();
486 
487  ++count;
488 
489  //
490  // Detect Stimuli
491  //
492  QList<qint32> t_qListStimuli;
493  for(i = 0; i < m_qListStimChannelIdcs.size(); ++i)
494  {
495  qint32 idx = m_qListStimChannelIdcs[i];
496  RowVectorXi stimSegment = rawSegment.row(idx).cast<int>();
497  int iMax = stimSegment.maxCoeff();
498 
499  if(iMax > 0)
500  t_qListStimuli.append(i);
501  }
502 
503  //
504  // Store
505  //
506  t_qListRawMatBuf.push_back(qMakePair(t_qListStimuli, rawSegment));
507 
508  m_qMutex.lock();
509  qint32 minSize = (m_iPreStimSamples+m_iPostStimSamples) + (2 * t_nSamplesPerBuf);
510  m_qMutex.unlock();
511 
512  if(t_nSamplesPerBuf*t_qListRawMatBuf.size() > minSize)
513  {
514  //
515  // Average
516  //
517  float ratio = (float)m_iPreStimSamples/((float)(m_iPreStimSamples+m_iPostStimSamples));
518  qint32 t_iBuffWithStim = floor((t_qListRawMatBuf.size()-1)*ratio) + 1;
519 
520  if(t_iBuffWithStim > 0 && t_qListRawMatBuf[t_iBuffWithStim].first.size() != 0)
521  {
522  for(i = 0; i < t_qListRawMatBuf[t_iBuffWithStim].first.size(); ++i)
523  {
524  //make sure that previous buffer does not conatin this stim - prevent multiple detection
525  if(!t_qListRawMatBuf[t_iBuffWithStim-1].first.contains(t_qListRawMatBuf[t_iBuffWithStim].first[i]))
526  {
527  qint32 t_iStimIndex = t_qListRawMatBuf[t_iBuffWithStim].first[i];
528 
529  //
530  // assemble prestimulus
531  //
532  this->assemblePreStimulus(t_qListRawMatBuf, t_iStimIndex);
533 
534  //
535  // assemble poststimulus
536  //
537  this->assemblePostStimulus(t_qListRawMatBuf, t_iStimIndex);
538 
539  qDebug() << m_pFiffInfo->ch_names[m_qListStimChannelIdcs[t_iStimIndex]] << ": Buffer Size" << m_qListQListPreStimBuf[t_iStimIndex].size();
540  //
541  // Prestimulus average
542  //
543  m_qMutex.lock();
544  if(m_qListQListPreStimBuf[t_iStimIndex].size() >= m_iNumAverages)
545  {
546  while(m_qListQListPreStimBuf[t_iStimIndex].size() >= (m_iNumAverages+1))//if meanwhile number of averages was reduced
547  m_qListQListPreStimBuf[t_iStimIndex].pop_front();
548 
549  m_qListPreStimAve[t_iStimIndex] = m_qListQListPreStimBuf[t_iStimIndex][0];
550  for(j = 1; j < m_qListQListPreStimBuf[t_iStimIndex].size(); ++j)
551  m_qListPreStimAve[t_iStimIndex] += m_qListQListPreStimBuf[t_iStimIndex][j];
552 
553  m_qListPreStimAve[t_iStimIndex].array() /= (double)m_iNumAverages;
554 
555  m_qListQListPreStimBuf[t_iStimIndex].pop_front();
556  }
557  m_qMutex.unlock();
558 
559  //
560  // Poststimulus average
561  //
562  m_qMutex.lock();
563  if(m_qListQListPostStimBuf[t_iStimIndex].size() >= m_iNumAverages)
564  {
565  while(m_qListQListPostStimBuf[t_iStimIndex].size() >= (m_iNumAverages+1))//if meanwhile number of averages was reduced
566  m_qListQListPostStimBuf[t_iStimIndex].pop_front();
567 
568  m_qListPostStimAve[t_iStimIndex] = m_qListQListPostStimBuf[t_iStimIndex][0];
569  for(j = 1; j < m_qListQListPostStimBuf[t_iStimIndex].size(); ++j)
570  m_qListPostStimAve[t_iStimIndex] += m_qListQListPostStimBuf[t_iStimIndex][j];
571 
572  m_qListPostStimAve[t_iStimIndex].array() /= (double)m_iNumAverages;
573 
574  m_qListQListPostStimBuf[t_iStimIndex].pop_front();
575  }
576  m_qMutex.unlock();
577 
578  //if averages are available -> buffers are filled and first average is stored
579  m_qMutex.lock();
580  if(m_qListPreStimAve[t_iStimIndex].size() > 0)
581  {
582  //
583  // concatenate pre + post stimulus to full stimulus
584  //
585  m_qListStimAve[t_iStimIndex].resize(m_qListPreStimAve[t_iStimIndex].rows(), m_qListPreStimAve[t_iStimIndex].cols() + m_qListPostStimAve[t_iStimIndex].cols());
586  // Pre
587  m_qListStimAve[t_iStimIndex].block(0,0,m_qListPreStimAve[t_iStimIndex].rows(),m_qListPreStimAve[t_iStimIndex].cols()) = m_qListPreStimAve[t_iStimIndex];
588  // Post
589  m_qListStimAve[t_iStimIndex].block(0,m_qListPreStimAve[t_iStimIndex].cols(),m_qListPostStimAve[t_iStimIndex].rows(),m_qListPostStimAve[t_iStimIndex].cols()) = m_qListPostStimAve[t_iStimIndex];
590 
591  //
592  // Emit evoked
593  //
594  QString t_sStimChName = m_pFiffInfo->ch_names[m_qListStimChannelIdcs[t_iStimIndex]];
595  FiffEvoked::SPtr t_pEvokedPreStim(new FiffEvoked(t_preStimEvoked));
596  t_pEvokedPreStim->nave = m_iNumAverages;
597  t_pEvokedPreStim->comment = t_sStimChName;
598  t_pEvokedPreStim->data = m_qListPreStimAve[t_iStimIndex];
599  emit evokedPreStim(t_pEvokedPreStim);
600 
601  FiffEvoked::SPtr t_pEvokedPostStim(new FiffEvoked(t_postStimEvoked));
602  t_pEvokedPostStim->nave = m_iNumAverages;
603  t_pEvokedPostStim->comment = t_sStimChName;
604  t_pEvokedPostStim->data = m_qListPostStimAve[t_iStimIndex];
605  emit evokedPostStim(t_pEvokedPostStim);
606 
607  FiffEvoked::SPtr t_pEvokedStim(new FiffEvoked(t_stimEvoked));
608  t_pEvokedStim->nave = m_iNumAverages;
609  t_pEvokedStim->comment = t_sStimChName;
610  t_pEvokedStim->data = m_qListStimAve[t_iStimIndex];
611  emit evokedStim(t_pEvokedStim);
612  }
613  m_qMutex.unlock();
614  }
615  }
616  }
617 
618 
619  //
620  //dump oldest buffer
621  //
622  t_qListRawMatBuf.pop_front();
623  }
624  }
625  }
626 }
RtAve(quint32 numAverages, quint32 p_iPreStimSamples, quint32 p_iPostStimSamples, FiffInfo::SPtr p_pFiffInfo, QObject *parent=0)
Definition: rtave.cpp:74
void evokedPostStim(FIFFLIB::FiffEvoked::SPtr p_pEvokedPostStim)
void numAveragesChanged()
void setPreStim(qint32 samples)
Definition: rtave.cpp:122
virtual bool stop()
Definition: rtave.cpp:308
void evokedStim(FIFFLIB::FiffEvoked::SPtr p_pEvokedStim)
QSharedPointer< CircularMatrixBuffer > SPtr
evoked data
Definition: fiff_evoked.h:91
RowVectorXf times
Definition: fiff_evoked.h:216
QSharedPointer< FiffInfo > SPtr
Definition: fiff_info.h:99
fiff_int_t aspect_kind
Definition: fiff_evoked.h:212
void push(const Matrix< _Tp, Dynamic, Dynamic > *pMatrix)
RtAve class declaration.
QSharedPointer< FiffEvoked > SPtr
Definition: fiff_evoked.h:94
void setAverages(qint32 numAve)
Definition: rtave.cpp:111
void setPostStim(qint32 samples)
Definition: rtave.cpp:131
#define FIFFV_ASPECT_AVERAGE
Matrix< _Tp, Dynamic, Dynamic > pop()
void evokedPreStim(FIFFLIB::FiffEvoked::SPtr p_pEvokedPreStim)
Definition: fiff.h:98
void append(const MatrixXd &p_DataSegment)
Definition: rtave.cpp:98
Definition: rtave.h:89
virtual bool start()
Definition: rtave.cpp:290
IOUtils class declaration.
void setInfo(FiffInfo &p_info, bool proj=true)
bool isRunning()
Definition: rtave.h:284
virtual void run()
Definition: rtave.cpp:324