MNE-CPP  beta 1.0
rtdataclient.cpp
Go to the documentation of this file.
1 //=============================================================================================================
38 //*************************************************************************************************************
39 //=============================================================================================================
40 // INCLUDES
41 //=============================================================================================================
42 
43 #include "rtdataclient.h"
44 
45 
46 //*************************************************************************************************************
47 //=============================================================================================================
48 // USED NAMESPACES
49 //=============================================================================================================
50 
51 using namespace RTCLIENTLIB;
52 
53 
54 //*************************************************************************************************************
55 //=============================================================================================================
56 // DEFINE MEMBER METHODS
57 //=============================================================================================================
58 
60 : QTcpSocket(parent)
61 , m_clientID(-1)
62 {
63  getClientId();
64 }
65 
66 
67 //*************************************************************************************************************
68 
69 void RtDataClient::connectToHost(const QString& p_sRtServerHostName)
70 {
71  QTcpSocket::connectToHost(p_sRtServerHostName, 4218);
72 }
73 
74 
75 //*************************************************************************************************************
76 
78 {
79  QTcpSocket::disconnectFromHost();
80  m_clientID = -1;
81 }
82 
83 
84 //*************************************************************************************************************
85 
87 {
88  if(m_clientID == -1)
89  {
90 // sendFiffCommand(1);//MNE_RT.MNE_RT_GET_CLIENT_ID)
91 
92  FiffStream t_fiffStream(this);
93 
94  QString t_sCommand("");
95  t_fiffStream.write_rt_command(1, t_sCommand);
96 
97 
98  this->waitForReadyRead(100);
99  // ID is send as answer
100  FiffTag::SPtr t_pTag;
101  FiffTag::read_tag(&t_fiffStream, t_pTag);
102  if (t_pTag->kind == FIFF_MNE_RT_CLIENT_ID)
103  m_clientID = *t_pTag->toInt();
104  }
105  return m_clientID;
106 }
107 
108 
109 //*************************************************************************************************************
110 
112 {
113  FiffInfo::SPtr p_pFiffInfo(new FiffInfo());
114  bool t_bReadMeasBlockStart = false;
115  bool t_bReadMeasBlockEnd = false;
116 
117  FiffStream t_fiffStream(this);
118  //
119  // Find the start
120  //
121  FiffTag::SPtr t_pTag;
122  while(!t_bReadMeasBlockStart)
123  {
124  FiffTag::read_rt_tag(&t_fiffStream, t_pTag);
125  if(t_pTag->kind == FIFF_BLOCK_START && *(t_pTag->toInt()) == FIFFB_MEAS_INFO)
126  {
127  printf("FIFF_BLOCK_START FIFFB_MEAS_INFO\n");
128  t_bReadMeasBlockStart = true;
129  }
130  }
131 
132  //
133  // Parse until the endblock
134  //
135 
136  bool dev_head_t_read = false;
137  bool ctf_head_t_read = false;
138 
139  while(!t_bReadMeasBlockEnd)
140  {
141  FiffTag::read_rt_tag(&t_fiffStream, t_pTag);
142  //
143  // megacq parameters
144  //
145  if(t_pTag->kind == FIFF_BLOCK_START && *(t_pTag->toInt()) == FIFFB_DACQ_PARS)
146  {
147  while(t_pTag->kind != FIFF_BLOCK_END || *(t_pTag->toInt()) != FIFFB_DACQ_PARS)
148  {
149  FiffTag::read_rt_tag(&t_fiffStream, t_pTag);
150  if(t_pTag->kind == FIFF_DACQ_PARS)
151  p_pFiffInfo->acq_pars = t_pTag->toString();
152  else if(t_pTag->kind == FIFF_DACQ_STIM)
153  p_pFiffInfo->acq_stim = t_pTag->toString();
154  }
155  }
156  //
157  // Coordinate transformations if the HPI result block was not there
158  //
159  if (t_pTag->kind == FIFF_COORD_TRANS)
160  {
161  if (!dev_head_t_read)
162  {
163  p_pFiffInfo->dev_head_t = t_pTag->toCoordTrans();
164  dev_head_t_read = true;
165  }
166  else if (!ctf_head_t_read)
167  {
168  p_pFiffInfo->ctf_head_t = t_pTag->toCoordTrans();
169  ctf_head_t_read = true;
170  }
171  }
172  //
173  // Polhemus data
174  //
175  if(t_pTag->kind == FIFF_BLOCK_START && *(t_pTag->toInt()) == FIFFB_ISOTRAK)
176  {
177  while(t_pTag->kind != FIFF_BLOCK_END || *(t_pTag->toInt()) != FIFFB_ISOTRAK)
178  {
179  FiffTag::read_rt_tag(&t_fiffStream, t_pTag);
180 
181  if(t_pTag->kind == FIFF_DIG_POINT)
182  p_pFiffInfo->dig.append(t_pTag->toDigPoint());
183  }
184  }
185  //
186  // Projectors
187  //
188  if(t_pTag->kind == FIFF_BLOCK_START && *(t_pTag->toInt()) == FIFFB_PROJ)
189  {
190  while(t_pTag->kind != FIFF_BLOCK_END || *(t_pTag->toInt()) != FIFFB_PROJ)
191  {
192  FiffTag::read_rt_tag(&t_fiffStream, t_pTag);
193  if(t_pTag->kind == FIFF_BLOCK_START && *(t_pTag->toInt()) == FIFFB_PROJ_ITEM)
194  {
195  FiffProj proj;
196  qint32 countProj = p_pFiffInfo->projs.size();
197  while(t_pTag->kind != FIFF_BLOCK_END || *(t_pTag->toInt()) != FIFFB_PROJ_ITEM)
198  {
199  FiffTag::read_rt_tag(&t_fiffStream, t_pTag);
200  switch (t_pTag->kind)
201  {
202  case FIFF_NAME: // First proj -> Proj is created
203  proj = FiffProj();
204  p_pFiffInfo->projs.append(proj);
205  p_pFiffInfo->projs[countProj].desc = t_pTag->toString();
206  break;
207  case FIFF_PROJ_ITEM_KIND:
208  p_pFiffInfo->projs[countProj].kind = *(t_pTag->toInt());
209  break;
210  case FIFF_NCHAN: // First data -> FiffNamedMatrix is created
211 // p_pFiffInfo->projs[countProj].data = FiffNamedMatrix();//obsolete
212  p_pFiffInfo->projs[countProj].data->ncol = *(t_pTag->toInt());
213  break;
214  case FIFF_PROJ_ITEM_NVEC:
215  p_pFiffInfo->projs[countProj].data->nrow = *(t_pTag->toInt());
216  break;
218  p_pFiffInfo->projs[countProj].active = *(t_pTag->toInt());
219  break;
220  case FIFF_PROJ_ITEM_CH_NAME_LIST:
221  p_pFiffInfo->projs[countProj].data->col_names = FiffStream::split_name_list(t_pTag->toString());
222  break;
223  case FIFF_PROJ_ITEM_VECTORS:
224  p_pFiffInfo->projs[countProj].data->data = t_pTag->toFloatMatrix().cast<double>();
225  break;
226  }
227  }
228  }
229  }
230  }
231  // Check consisty
232  for(qint32 i = 0; i < p_pFiffInfo->projs.size(); ++i)
233  {
234  if(p_pFiffInfo->projs[i].data->data.rows() != p_pFiffInfo->projs[i].data->nrow)
235  p_pFiffInfo->projs[i].data->data.transposeInPlace();
236  }
237 
238  //
239  // CTF compensation info
240  //
241  if(t_pTag->kind == FIFF_BLOCK_START && *(t_pTag->toInt()) == FIFFB_MNE_CTF_COMP)
242  {
243  while(t_pTag->kind != FIFF_BLOCK_END || *(t_pTag->toInt()) != FIFFB_MNE_CTF_COMP)
244  {
245  FiffTag::read_rt_tag(&t_fiffStream, t_pTag);
246  if(t_pTag->kind == FIFF_BLOCK_START && *(t_pTag->toInt()) == FIFFB_MNE_CTF_COMP_DATA)
247  {
248  FiffCtfComp comp;
249  qint32 countComp = p_pFiffInfo->comps.size();
250  while(t_pTag->kind != FIFF_BLOCK_END || *(t_pTag->toInt()) != FIFFB_MNE_CTF_COMP_DATA)
251  {
252  FiffTag::read_rt_tag(&t_fiffStream, t_pTag);
253  switch (t_pTag->kind)
254  {
255  case FIFF_MNE_CTF_COMP_KIND: //First comp -> create comp
256  comp = FiffCtfComp();
257  p_pFiffInfo->comps.append(comp);
258  p_pFiffInfo->comps[countComp].ctfkind = *(t_pTag->toInt());
259  break;
261  p_pFiffInfo->comps[countComp].save_calibrated = *(t_pTag->toInt());
262  break;
263 // case FIFF_MNE_CTF_COMP_DATA:
264 // p_pFiffInfo->comps[countComp]->data = *(t_pTag->toNamedMatrix());
265 // break;
266  }
267  }
268  }
269  }
270  }
271  //
272  // Bad channels
273  //
274  if(t_pTag->kind == FIFF_BLOCK_START && *(t_pTag->toInt()) == FIFFB_MNE_BAD_CHANNELS)
275  {
276  while(t_pTag->kind != FIFF_BLOCK_END || *(t_pTag->toInt()) != FIFFB_MNE_BAD_CHANNELS)
277  {
278  FiffTag::read_rt_tag(&t_fiffStream, t_pTag);
279  if(t_pTag->kind == FIFF_MNE_CH_NAME_LIST)
280  p_pFiffInfo->bads = FiffStream::split_name_list(t_pTag->data());
281  }
282  }
283  //
284  // General
285  //
286  switch(t_pTag->kind)
287  {
288  case FIFF_SFREQ:
289  p_pFiffInfo->sfreq = *(t_pTag->toFloat());
290  break;
291  case FIFF_HIGHPASS:
292  p_pFiffInfo->highpass = *(t_pTag->toFloat());
293  break;
294  case FIFF_LOWPASS:
295  p_pFiffInfo->lowpass = *(t_pTag->toFloat());
296  break;
297  case FIFF_NCHAN:
298  p_pFiffInfo->nchan = *(t_pTag->toInt());
299  break;
300  case FIFF_MEAS_DATE:
301  p_pFiffInfo->meas_date[0] = t_pTag->toInt()[0];
302  p_pFiffInfo->meas_date[1] = t_pTag->toInt()[1];
303  break;
304  }
305 
306  if (t_pTag->kind == FIFF_CH_INFO)
307  p_pFiffInfo->chs.append(t_pTag->toChInfo());
308 
309  // END MEAS
310  if(t_pTag->kind == FIFF_BLOCK_END && *t_pTag->toInt() == FIFFB_MEAS_INFO)
311  {
312  printf("FIFF_BLOCK_END FIFFB_MEAS_INFO\n");
313  t_bReadMeasBlockEnd = true;
314  }
315  }
316 
317  //
318  // Add the channel information and make a list of channel names
319  // for convenience
320  //
321  for (qint32 c = 0; c < p_pFiffInfo->nchan; ++c)
322  p_pFiffInfo->ch_names << p_pFiffInfo->chs[c].ch_name;
323 
324  return p_pFiffInfo;
325 }
326 
327 
328 //*************************************************************************************************************
329 
330 void RtDataClient::readRawBuffer(qint32 p_nChannels, MatrixXf& data, fiff_int_t& kind)
331 {
332 // data = [];
333 
334  FiffStream t_fiffStream(this);
335  //
336  // Find the start
337  //
338  FiffTag::SPtr t_pTag;
339 
340  FiffTag::read_rt_tag(&t_fiffStream, t_pTag);
341 
342  kind = t_pTag->kind;
343 
344  if(kind == FIFF_DATA_BUFFER)
345  {
346  qint32 nSamples = (t_pTag->size()/4)/p_nChannels;
347  data = MatrixXf(Map< MatrixXf >(t_pTag->toFloat(), p_nChannels, nSamples));
348  }
349 // else
350 // data = tag.data;
351 }
352 
353 
354 //*************************************************************************************************************
355 
356 void RtDataClient::setClientAlias(const QString &p_sAlias)
357 {
358  FiffStream t_fiffStream(this);
359  t_fiffStream.write_rt_command(2, p_sAlias);//MNE_RT.MNE_RT_SET_CLIENT_ALIAS, alias);
360  this->flush();
361 }
#define FIFF_MNE_RT_CLIENT_ID
#define FIFF_MNE_CTF_COMP_KIND
void readRawBuffer(qint32 p_nChannels, MatrixXf &data, fiff_int_t &kind)
FIFF measurement file information.
Definition: fiff_info.h:96
void setClientAlias(const QString &p_sAlias)
static QStringList split_name_list(QString p_sNameList)
QSharedPointer< FiffTag > SPtr
Definition: fiff_tag.h:166
RtDataClient(QObject *parent=0)
void write_rt_command(fiff_int_t command, const QString &data)
static bool read_tag(FiffStream *p_pStream, FiffTag::SPtr &p_pTag, qint64 pos=-1)
Definition: fiff_tag.cpp:204
#define FIFF_MNE_CTF_COMP_CALIBRATED
QSharedPointer< FiffInfo > SPtr
Definition: fiff_info.h:99
#define FIFF_MNE_PROJ_ITEM_ACTIVE
SSP projector data.
Definition: fiff_proj.h:89
FiffInfo::SPtr readInfo()
#define FIFF_DATA_BUFFER
static bool read_rt_tag(FiffStream *p_pStream, FiffTag::SPtr &p_pTag)
Definition: fiff_tag.cpp:184
CTF software compensation data.
Definition: fiff_ctf_comp.h:87
FIFF File I/O routines.
Definition: fiff_stream.h:129
declaration of the RtDataClient Class.
void connectToHost(const QString &p_sRtServerHostName)
virtual void disconnectFromHost()