v2.0.0
Loading...
Searching...
No Matches
rt_data_client.cpp
Go to the documentation of this file.
1//=============================================================================================================
21
22//=============================================================================================================
23// INCLUDES
24//=============================================================================================================
25
26#include "rt_data_client.h"
27#include <fiff/fiff_file.h>
28
29//=============================================================================================================
30// USED NAMESPACES
31//=============================================================================================================
32
33using namespace COMLIB;
34using namespace FIFFLIB;
35using namespace Eigen;
36
37//=============================================================================================================
38// DEFINE MEMBER METHODS
39//=============================================================================================================
40
41RtDataClient::RtDataClient(QObject *parent)
42: QTcpSocket(parent)
43, m_clientID(-1)
44{
45 getClientId();
46}
47
48//=============================================================================================================
49
50void RtDataClient::disconnectFromHost()
51{
52 QTcpSocket::disconnectFromHost();
53 m_clientID = -1;
54}
55
56//=============================================================================================================
57
58qint32 RtDataClient::getClientId()
59{
60 if(m_clientID == -1)
61 {
62// sendFiffCommand(1);//MNE_RT.MNE_RT_GET_CLIENT_ID)
63
64 FiffStream t_fiffStream(this);
65
66 QString t_sCommand("");
67 t_fiffStream.write_rt_command(1, t_sCommand);
68
69 this->waitForReadyRead(100);
70 // ID is send as answer
71 FiffTag::UPtr t_pTag;
72 t_fiffStream.read_tag(t_pTag);
73 if (t_pTag->kind == FIFF_MNE_RT_CLIENT_ID)
74 m_clientID = *t_pTag->toInt();
75 }
76 return m_clientID;
77}
78
79//=============================================================================================================
80
81FiffInfo::SPtr RtDataClient::readInfo()
82{
83 FiffInfo::SPtr p_pFiffInfo(new FiffInfo());
84 bool t_bReadMeasBlockStart = false;
85 bool t_bReadMeasBlockEnd = false;
86 QString col_names, row_names;
87
88 FiffStream t_fiffStream(this);
89 //
90 // Find the start
91 //
92 FiffTag::UPtr t_pTag;
93 while(!t_bReadMeasBlockStart)
94 {
95 t_fiffStream.read_rt_tag(t_pTag);
96 if(t_pTag->kind == FIFF_BLOCK_START && *(t_pTag->toInt()) == FIFFB_MEAS_INFO)
97 {
98 qInfo("FIFF_BLOCK_START FIFFB_MEAS_INFO");
99 t_bReadMeasBlockStart = true;
100 }
101 }
102
103 //
104 // Parse until the endblock
105 //
106
107 bool dev_head_t_read = false;
108 bool ctf_head_t_read = false;
109
110 while(!t_bReadMeasBlockEnd)
111 {
112 t_fiffStream.read_rt_tag(t_pTag);
113 //
114 // megacq parameters
115 //
116 if(t_pTag->kind == FIFF_BLOCK_START && *(t_pTag->toInt()) == FIFFB_DACQ_PARS)
117 {
118 while(t_pTag->kind != FIFF_BLOCK_END || *(t_pTag->toInt()) != FIFFB_DACQ_PARS)
119 {
120 t_fiffStream.read_rt_tag(t_pTag);
121 if(t_pTag->kind == FIFF_DACQ_PARS)
122 p_pFiffInfo->acq_pars = t_pTag->toString();
123 else if(t_pTag->kind == FIFF_DACQ_STIM)
124 p_pFiffInfo->acq_stim = t_pTag->toString();
125 }
126 }
127 //
128 // Coordinate transformations if the HPI result block was not there
129 //
130 if (t_pTag->kind == FIFF_COORD_TRANS)
131 {
132 if (!dev_head_t_read)
133 {
134 p_pFiffInfo->dev_head_t = t_pTag->toCoordTrans();
135 dev_head_t_read = true;
136 }
137 else if (!ctf_head_t_read)
138 {
139 p_pFiffInfo->ctf_head_t = t_pTag->toCoordTrans();
140 ctf_head_t_read = true;
141 }
142 }
143 //
144 // Polhemus data
145 //
146 if(t_pTag->kind == FIFF_BLOCK_START && *(t_pTag->toInt()) == FIFFB_ISOTRAK)
147 {
148 while(t_pTag->kind != FIFF_BLOCK_END || *(t_pTag->toInt()) != FIFFB_ISOTRAK)
149 {
150 t_fiffStream.read_rt_tag(t_pTag);
151
152 if(t_pTag->kind == FIFF_DIG_POINT)
153 p_pFiffInfo->dig.append(t_pTag->toDigPoint());
154 }
155 }
156 //
157 // Projectors
158 //
159 if(t_pTag->kind == FIFF_BLOCK_START && *(t_pTag->toInt()) == FIFFB_PROJ)
160 {
161 while(t_pTag->kind != FIFF_BLOCK_END || *(t_pTag->toInt()) != FIFFB_PROJ)
162 {
163 t_fiffStream.read_rt_tag(t_pTag);
164 if(t_pTag->kind == FIFF_BLOCK_START && *(t_pTag->toInt()) == FIFFB_PROJ_ITEM)
165 {
166 FiffProj proj;
167 qint32 countProj = p_pFiffInfo->projs.size();
168 while(t_pTag->kind != FIFF_BLOCK_END || *(t_pTag->toInt()) != FIFFB_PROJ_ITEM)
169 {
170 t_fiffStream.read_rt_tag(t_pTag);
171 switch (t_pTag->kind)
172 {
173 case FIFF_NAME: // First proj -> Proj is created
174 proj = FiffProj();
175 p_pFiffInfo->projs.append(proj);
176 p_pFiffInfo->projs[countProj].desc = t_pTag->toString();
177 break;
178 case FIFF_PROJ_ITEM_KIND:
179 p_pFiffInfo->projs[countProj].kind = *(t_pTag->toInt());
180 break;
181 case FIFF_NCHAN: // First data -> FiffNamedMatrix is created
182 p_pFiffInfo->projs[countProj].data->ncol = *(t_pTag->toInt());
183 break;
184 case FIFF_PROJ_ITEM_NVEC:
185 p_pFiffInfo->projs[countProj].data->nrow = *(t_pTag->toInt());
186 break;
187 case FIFF_MNE_PROJ_ITEM_ACTIVE:
188 p_pFiffInfo->projs[countProj].active = *(t_pTag->toInt());
189 break;
190 case FIFF_PROJ_ITEM_CH_NAME_LIST:
191 p_pFiffInfo->projs[countProj].data->col_names = FiffStream::split_name_list(t_pTag->toString());
192 break;
193 case FIFF_PROJ_ITEM_VECTORS:
194 //ToDo: Test; Float Matrix
195 p_pFiffInfo->projs[countProj].data->data = t_pTag->toFloatMatrix().transpose().cast<double>();
196 break;
197 }
198 }
199 }
200 }
201 }
202 // Check consisty
203 for(qint32 i = 0; i < p_pFiffInfo->projs.size(); ++i)
204 {
205 if(p_pFiffInfo->projs[i].data->data.rows() != p_pFiffInfo->projs[i].data->nrow)
206 p_pFiffInfo->projs[i].data->data.transposeInPlace();
207 }
208
209 //
210 // CTF compensation info
211 //
212 if(t_pTag->kind == FIFF_BLOCK_START && *(t_pTag->toInt()) == FIFFB_MNE_CTF_COMP)
213 {
214 while(t_pTag->kind != FIFF_BLOCK_END || *(t_pTag->toInt()) != FIFFB_MNE_CTF_COMP)
215 {
216 t_fiffStream.read_rt_tag(t_pTag);
217 if(t_pTag->kind == FIFF_BLOCK_START && *(t_pTag->toInt()) == FIFFB_MNE_CTF_COMP_DATA)
218 {
219 FiffCtfComp comp;
220 qint32 countComp = p_pFiffInfo->comps.size();
221 while(t_pTag->kind != FIFF_BLOCK_END || *(t_pTag->toInt()) != FIFFB_MNE_CTF_COMP_DATA)
222 {
223 t_fiffStream.read_rt_tag(t_pTag);
224 switch (t_pTag->kind)
225 {
226 case FIFF_MNE_CTF_COMP_KIND: //First comp -> create comp
227 comp = FiffCtfComp();
228 p_pFiffInfo->comps.append(comp);
229 p_pFiffInfo->comps[countComp].ctfkind = *(t_pTag->toInt());
230
231 if (p_pFiffInfo->comps[countComp].ctfkind == 1194410578) //hex2dec('47314252')
232 p_pFiffInfo->comps[countComp].kind = 1;
233 else if (p_pFiffInfo->comps[countComp].ctfkind == 1194476114) //hex2dec('47324252')
234 p_pFiffInfo->comps[countComp].kind = 2;
235 else if (p_pFiffInfo->comps[countComp].ctfkind == 1194541650) //hex2dec('47334252')
236 p_pFiffInfo->comps[countComp].kind = 3;
237 else if (p_pFiffInfo->comps[countComp].ctfkind == 1194479433)
238 p_pFiffInfo->comps[countComp].kind = 4;
239 else if (p_pFiffInfo->comps[countComp].ctfkind == 1194544969)
240 p_pFiffInfo->comps[countComp].kind = 5;
241 else
242 p_pFiffInfo->comps[countComp].kind = p_pFiffInfo->comps[countComp].ctfkind;
243 break;
244 case FIFF_MNE_CTF_COMP_CALIBRATED:
245 p_pFiffInfo->comps[countComp].save_calibrated = *(t_pTag->toInt());
246 break;
247 case FIFF_MNE_NROW:
248 p_pFiffInfo->comps[countComp].data->nrow = *(t_pTag->toInt());
249 break;
250 case FIFF_MNE_NCOL:
251 p_pFiffInfo->comps[countComp].data->ncol = *(t_pTag->toInt());
252 break;
253 case FIFF_MNE_ROW_NAMES:
254 row_names = t_pTag->toString();
255 if (!row_names.isEmpty())
256 p_pFiffInfo->comps[countComp].data->row_names = FiffStream::split_name_list(row_names);
257 break;
258 case FIFF_MNE_COL_NAMES:
259 col_names = t_pTag->toString();
260 if (!col_names.isEmpty())
261 p_pFiffInfo->comps[countComp].data->col_names = FiffStream::split_name_list(col_names);
262 break;
263 case FIFF_MNE_CTF_COMP_DATA:
264 //ToDo: Test; Float Matrix
265 p_pFiffInfo->comps[countComp].data->data = t_pTag->toFloatMatrix().transpose().cast<double>();
266 break;
267 }
268 }
269 }
270 }
271 }
272 //
273 // Bad channels
274 //
275 if(t_pTag->kind == FIFF_BLOCK_START && *(t_pTag->toInt()) == FIFFB_MNE_BAD_CHANNELS)
276 {
277 while(t_pTag->kind != FIFF_BLOCK_END || *(t_pTag->toInt()) != FIFFB_MNE_BAD_CHANNELS)
278 {
279 t_fiffStream.read_rt_tag(t_pTag);
280 if(t_pTag->kind == FIFF_MNE_CH_NAME_LIST)
281 p_pFiffInfo->bads = FiffStream::split_name_list(t_pTag->data());
282 }
283 }
284 //
285 // General
286 //
287 switch(t_pTag->kind)
288 {
289 case FIFF_SFREQ:
290 p_pFiffInfo->sfreq = *(t_pTag->toFloat());
291 break;
292 case FIFF_LINE_FREQ:
293 p_pFiffInfo->linefreq = *(t_pTag->toFloat());
294 break;
295 case FIFF_HIGHPASS:
296 p_pFiffInfo->highpass = *(t_pTag->toFloat());
297 break;
298 case FIFF_LOWPASS:
299 p_pFiffInfo->lowpass = *(t_pTag->toFloat());
300 break;
301 case FIFF_NCHAN:
302 p_pFiffInfo->nchan = *(t_pTag->toInt());
303 break;
304 case FIFF_MEAS_DATE:
305 p_pFiffInfo->meas_date[0] = t_pTag->toInt()[0];
306 p_pFiffInfo->meas_date[1] = t_pTag->toInt()[1];
307 break;
308 case FIFF_PROJ_ID:
309 p_pFiffInfo->proj_id = *t_pTag->toInt();
310 break;
311 case FIFF_PROJ_NAME:
312 p_pFiffInfo->proj_name = t_pTag->toString();
313 break;
314 case FIFF_XPLOTTER_LAYOUT:
315 p_pFiffInfo->xplotter_layout = t_pTag->toString();
316 break;
317 case FIFF_EXPERIMENTER:
318 p_pFiffInfo->experimenter = t_pTag->toString();
319 break;
320 case FIFF_DESCRIPTION:
321 p_pFiffInfo->description = t_pTag->toString();
322 break;
323 case FIFF_GANTRY_ANGLE:
324 p_pFiffInfo->gantry_angle = *t_pTag->toInt();
325 break;
326 case FIFF_UTC_OFFSET:
327 p_pFiffInfo->utc_offset = t_pTag->toString();
328 break;
329 }
330
331 if (t_pTag->kind == FIFF_CH_INFO)
332 p_pFiffInfo->chs.append(t_pTag->toChInfo());
333
334 // END MEAS
335 if(t_pTag->kind == FIFF_BLOCK_END && *t_pTag->toInt() == FIFFB_MEAS_INFO)
336 {
337 qInfo("FIFF_BLOCK_END FIFFB_MEAS_INFO");
338 t_bReadMeasBlockEnd = true;
339 }
340 }
341
342 //
343 // Add the channel information and make a list of channel names
344 // for convenience
345 //
346 for (qint32 c = 0; c < p_pFiffInfo->nchan; ++c)
347 p_pFiffInfo->ch_names << p_pFiffInfo->chs[c].ch_name;
348
349 return p_pFiffInfo;
350}
351
352//=============================================================================================================
353
354MetaData RtDataClient::readMetadata()
355{
356 FiffDigitizerData::SPtr p_pDigData(new FiffDigitizerData());
357 FiffInfo::SPtr p_pFiffInfo(new FiffInfo());
358
359 bool t_bReadMeasBlockStart = false;
360 bool t_bReadMeasBlockEnd = false;
361 QString col_names, row_names;
362
363 FiffStream t_fiffStream(this);
364 //
365 // Find the start
366 //
367 FiffTag::UPtr t_pTag;
368 while(!t_bReadMeasBlockStart)
369 {
370 t_fiffStream.read_rt_tag(t_pTag);
371 if(t_pTag->kind == FIFF_BLOCK_START && *(t_pTag->toInt()) == FIFFB_MEAS_INFO)
372 {
373 qInfo("FIFF_BLOCK_START FIFFB_MEAS_INFO");
374 t_bReadMeasBlockStart = true;
375 }
376 }
377
378 //
379 // Parse until the endblock
380 //
381
382 bool dev_head_t_read = false;
383 bool ctf_head_t_read = false;
384
385 while(!t_bReadMeasBlockEnd)
386 {
387 t_fiffStream.read_rt_tag(t_pTag);
388 //
389 // megacq parameters
390 //
391 if(t_pTag->kind == FIFF_BLOCK_START && *(t_pTag->toInt()) == FIFFB_DACQ_PARS)
392 {
393 while(t_pTag->kind != FIFF_BLOCK_END || *(t_pTag->toInt()) != FIFFB_DACQ_PARS)
394 {
395 t_fiffStream.read_rt_tag(t_pTag);
396 if(t_pTag->kind == FIFF_DACQ_PARS)
397 p_pFiffInfo->acq_pars = t_pTag->toString();
398 else if(t_pTag->kind == FIFF_DACQ_STIM)
399 p_pFiffInfo->acq_stim = t_pTag->toString();
400 }
401 }
402 //
403 // Coordinate transformations if the HPI result block was not there
404 //
405 if (t_pTag->kind == FIFF_COORD_TRANS)
406 {
407 if (!dev_head_t_read)
408 {
409 p_pFiffInfo->dev_head_t = t_pTag->toCoordTrans();
410 dev_head_t_read = true;
411 }
412 else if (!ctf_head_t_read)
413 {
414 p_pFiffInfo->ctf_head_t = t_pTag->toCoordTrans();
415 ctf_head_t_read = true;
416 }
417 }
418 //
419 // Polhemus data
420 //
421 if(t_pTag->kind == FIFF_BLOCK_START && *(t_pTag->toInt()) == FIFFB_ISOTRAK)
422 {
423 while(t_pTag->kind != FIFF_BLOCK_END || *(t_pTag->toInt()) != FIFFB_ISOTRAK)
424 {
425 t_fiffStream.read_rt_tag(t_pTag);
426
427 if(t_pTag->kind == FIFF_DIG_POINT){
428 p_pFiffInfo->dig.append(t_pTag->toDigPoint());
429 p_pDigData->points.append(t_pTag->toDigPoint());
430 }
431 if(t_pTag->kind == FIFF_MNE_COORD_FRAME){
432 p_pDigData->coord_frame = *t_pTag->toInt();
433 }
434 }
435 }
436 //
437 // Projectors
438 //
439 if(t_pTag->kind == FIFF_BLOCK_START && *(t_pTag->toInt()) == FIFFB_PROJ)
440 {
441 while(t_pTag->kind != FIFF_BLOCK_END || *(t_pTag->toInt()) != FIFFB_PROJ)
442 {
443 t_fiffStream.read_rt_tag(t_pTag);
444 if(t_pTag->kind == FIFF_BLOCK_START && *(t_pTag->toInt()) == FIFFB_PROJ_ITEM)
445 {
446 FiffProj proj;
447 qint32 countProj = p_pFiffInfo->projs.size();
448 while(t_pTag->kind != FIFF_BLOCK_END || *(t_pTag->toInt()) != FIFFB_PROJ_ITEM)
449 {
450 t_fiffStream.read_rt_tag(t_pTag);
451 switch (t_pTag->kind)
452 {
453 case FIFF_NAME: // First proj -> Proj is created
454 proj = FiffProj();
455 p_pFiffInfo->projs.append(proj);
456 p_pFiffInfo->projs[countProj].desc = t_pTag->toString();
457 break;
458 case FIFF_PROJ_ITEM_KIND:
459 p_pFiffInfo->projs[countProj].kind = *(t_pTag->toInt());
460 break;
461 case FIFF_NCHAN: // First data -> FiffNamedMatrix is created
462 p_pFiffInfo->projs[countProj].data->ncol = *(t_pTag->toInt());
463 break;
464 case FIFF_PROJ_ITEM_NVEC:
465 p_pFiffInfo->projs[countProj].data->nrow = *(t_pTag->toInt());
466 break;
467 case FIFF_MNE_PROJ_ITEM_ACTIVE:
468 p_pFiffInfo->projs[countProj].active = *(t_pTag->toInt());
469 break;
470 case FIFF_PROJ_ITEM_CH_NAME_LIST:
471 p_pFiffInfo->projs[countProj].data->col_names = FiffStream::split_name_list(t_pTag->toString());
472 break;
473 case FIFF_PROJ_ITEM_VECTORS:
474 //ToDo: Test; Float Matrix
475 p_pFiffInfo->projs[countProj].data->data = t_pTag->toFloatMatrix().transpose().cast<double>();
476 break;
477 }
478 }
479 }
480 }
481 }
482 // Check consisty
483 for(qint32 i = 0; i < p_pFiffInfo->projs.size(); ++i)
484 {
485 if(p_pFiffInfo->projs[i].data->data.rows() != p_pFiffInfo->projs[i].data->nrow)
486 p_pFiffInfo->projs[i].data->data.transposeInPlace();
487 }
488
489 //
490 // CTF compensation info
491 //
492 if(t_pTag->kind == FIFF_BLOCK_START && *(t_pTag->toInt()) == FIFFB_MNE_CTF_COMP)
493 {
494 while(t_pTag->kind != FIFF_BLOCK_END || *(t_pTag->toInt()) != FIFFB_MNE_CTF_COMP)
495 {
496 t_fiffStream.read_rt_tag(t_pTag);
497 if(t_pTag->kind == FIFF_BLOCK_START && *(t_pTag->toInt()) == FIFFB_MNE_CTF_COMP_DATA)
498 {
499 FiffCtfComp comp;
500 qint32 countComp = p_pFiffInfo->comps.size();
501 while(t_pTag->kind != FIFF_BLOCK_END || *(t_pTag->toInt()) != FIFFB_MNE_CTF_COMP_DATA)
502 {
503 t_fiffStream.read_rt_tag(t_pTag);
504 switch (t_pTag->kind)
505 {
506 case FIFF_MNE_CTF_COMP_KIND: //First comp -> create comp
507 comp = FiffCtfComp();
508 p_pFiffInfo->comps.append(comp);
509 p_pFiffInfo->comps[countComp].ctfkind = *(t_pTag->toInt());
510
511 if (p_pFiffInfo->comps[countComp].ctfkind == 1194410578) //hex2dec('47314252')
512 p_pFiffInfo->comps[countComp].kind = 1;
513 else if (p_pFiffInfo->comps[countComp].ctfkind == 1194476114) //hex2dec('47324252')
514 p_pFiffInfo->comps[countComp].kind = 2;
515 else if (p_pFiffInfo->comps[countComp].ctfkind == 1194541650) //hex2dec('47334252')
516 p_pFiffInfo->comps[countComp].kind = 3;
517 else if (p_pFiffInfo->comps[countComp].ctfkind == 1194479433)
518 p_pFiffInfo->comps[countComp].kind = 4;
519 else if (p_pFiffInfo->comps[countComp].ctfkind == 1194544969)
520 p_pFiffInfo->comps[countComp].kind = 5;
521 else
522 p_pFiffInfo->comps[countComp].kind = p_pFiffInfo->comps[countComp].ctfkind;
523 break;
524 case FIFF_MNE_CTF_COMP_CALIBRATED:
525 p_pFiffInfo->comps[countComp].save_calibrated = *(t_pTag->toInt());
526 break;
527 case FIFF_MNE_NROW:
528 p_pFiffInfo->comps[countComp].data->nrow = *(t_pTag->toInt());
529 break;
530 case FIFF_MNE_NCOL:
531 p_pFiffInfo->comps[countComp].data->ncol = *(t_pTag->toInt());
532 break;
533 case FIFF_MNE_ROW_NAMES:
534 row_names = t_pTag->toString();
535 if (!row_names.isEmpty())
536 p_pFiffInfo->comps[countComp].data->row_names = FiffStream::split_name_list(row_names);
537 break;
538 case FIFF_MNE_COL_NAMES:
539 col_names = t_pTag->toString();
540 if (!col_names.isEmpty())
541 p_pFiffInfo->comps[countComp].data->col_names = FiffStream::split_name_list(col_names);
542 break;
543 case FIFF_MNE_CTF_COMP_DATA:
544 //ToDo: Test; Float Matrix
545 p_pFiffInfo->comps[countComp].data->data = t_pTag->toFloatMatrix().transpose().cast<double>();
546 break;
547 }
548 }
549 }
550 }
551 }
552 //
553 // Bad channels
554 //
555 if(t_pTag->kind == FIFF_BLOCK_START && *(t_pTag->toInt()) == FIFFB_MNE_BAD_CHANNELS)
556 {
557 while(t_pTag->kind != FIFF_BLOCK_END || *(t_pTag->toInt()) != FIFFB_MNE_BAD_CHANNELS)
558 {
559 t_fiffStream.read_rt_tag(t_pTag);
560 if(t_pTag->kind == FIFF_MNE_CH_NAME_LIST)
561 p_pFiffInfo->bads = FiffStream::split_name_list(t_pTag->data());
562 }
563 }
564 //
565 // General
566 //
567 switch(t_pTag->kind)
568 {
569 case FIFF_SFREQ:
570 p_pFiffInfo->sfreq = *(t_pTag->toFloat());
571 break;
572 case FIFF_LINE_FREQ:
573 p_pFiffInfo->linefreq = *(t_pTag->toFloat());
574 break;
575 case FIFF_HIGHPASS:
576 p_pFiffInfo->highpass = *(t_pTag->toFloat());
577 break;
578 case FIFF_LOWPASS:
579 p_pFiffInfo->lowpass = *(t_pTag->toFloat());
580 break;
581 case FIFF_NCHAN:
582 p_pFiffInfo->nchan = *(t_pTag->toInt());
583 break;
584 case FIFF_MEAS_DATE:
585 p_pFiffInfo->meas_date[0] = t_pTag->toInt()[0];
586 p_pFiffInfo->meas_date[1] = t_pTag->toInt()[1];
587 break;
588 case FIFF_PROJ_ID:
589 p_pFiffInfo->proj_id = *t_pTag->toInt();
590 break;
591 case FIFF_PROJ_NAME:
592 p_pFiffInfo->proj_name = t_pTag->toString();
593 break;
594 case FIFF_XPLOTTER_LAYOUT:
595 p_pFiffInfo->xplotter_layout = t_pTag->toString();
596 break;
597 case FIFF_EXPERIMENTER:
598 p_pFiffInfo->experimenter = t_pTag->toString();
599 break;
600 case FIFF_DESCRIPTION:
601 p_pFiffInfo->description = t_pTag->toString();
602 break;
603 case FIFF_GANTRY_ANGLE:
604 p_pFiffInfo->gantry_angle = *t_pTag->toInt();
605 break;
606 case FIFF_UTC_OFFSET:
607 p_pFiffInfo->utc_offset = t_pTag->toString();
608 break;
609 }
610
611 if (t_pTag->kind == FIFF_CH_INFO)
612 p_pFiffInfo->chs.append(t_pTag->toChInfo());
613
614 // END MEAS
615 if(t_pTag->kind == FIFF_BLOCK_END && *t_pTag->toInt() == FIFFB_MEAS_INFO)
616 {
617 qInfo("FIFF_BLOCK_END FIFFB_MEAS_INFO");
618 t_bReadMeasBlockEnd = true;
619 }
620 }
621
622 //
623 // Add the channel information and make a list of channel names
624 // for convenience
625 //
626 for (qint32 c = 0; c < p_pFiffInfo->nchan; ++c)
627 p_pFiffInfo->ch_names << p_pFiffInfo->chs[c].ch_name;
628
629 p_pDigData->npoint = p_pDigData->points.size();
630
631 for (int k = 0; k < p_pDigData->npoint; k++) {
632 p_pDigData->active.append(1);
633 p_pDigData->discard.append(0);
634 }
635
636 return MetaData(p_pFiffInfo, p_pDigData);
637}
638
639//=============================================================================================================
640
641void RtDataClient::readRawBuffer(qint32 p_nChannels,
642 MatrixXf& data,
643 fiff_int_t& kind)
644{
645 FiffStream t_fiffStream(this);
646 //
647 // Find the start
648 //
649 FiffTag::UPtr t_pTag;
650
651 t_fiffStream.read_rt_tag(t_pTag);
652
653 kind = t_pTag->kind;
654
655 if(kind == FIFF_DATA_BUFFER)
656 {
657 qint32 nSamples = (t_pTag->size()/4)/p_nChannels;
658 data = MatrixXf(Map<const MatrixXf>(t_pTag->toFloat(), p_nChannels, nSamples));
659 }
660// else
661// data = tag.data;
662}
663
664//=============================================================================================================
665
666void RtDataClient::setClientAlias(const QString &p_sAlias)
667{
668 FiffStream t_fiffStream(this);
669 t_fiffStream.write_rt_command(2, p_sAlias);//MNE_RT.MNE_RT_SET_CLIENT_ALIAS, alias);
670 this->flush();
671}
rt_data_client.h
TCP client for the mne_rt_server raw-data port (4218): pulls FiffInfo, digitizer points and streamed ...
FIFF_MNE_COORD_FRAME
#define FIFF_MNE_COORD_FRAME
Definition fiff_constants.h:341
FIFF_MNE_CTF_COMP_KIND
#define FIFF_MNE_CTF_COMP_KIND
Definition fiff_constants.h:431
FIFFB_MNE_CTF_COMP_DATA
#define FIFFB_MNE_CTF_COMP_DATA
Definition fiff_constants.h:331
FIFF_MNE_CTF_COMP_CALIBRATED
#define FIFF_MNE_CTF_COMP_CALIBRATED
Definition fiff_constants.h:433
FIFF_MNE_ROW_NAMES
#define FIFF_MNE_ROW_NAMES
Definition fiff_constants.h:337
FIFF_MNE_PROJ_ITEM_ACTIVE
#define FIFF_MNE_PROJ_ITEM_ACTIVE
Definition fiff_constants.h:417
FIFF_MNE_RT_CLIENT_ID
#define FIFF_MNE_RT_CLIENT_ID
Definition fiff_constants.h:439
FIFF_MNE_COL_NAMES
#define FIFF_MNE_COL_NAMES
Definition fiff_constants.h:338
FIFF_MNE_CTF_COMP_DATA
#define FIFF_MNE_CTF_COMP_DATA
Definition fiff_constants.h:432
FIFF_MNE_CH_NAME_LIST
#define FIFF_MNE_CH_NAME_LIST
Definition fiff_constants.h:345
FIFF_MNE_NCOL
#define FIFF_MNE_NCOL
Definition fiff_constants.h:340
FIFFB_MNE_CTF_COMP
#define FIFFB_MNE_CTF_COMP
Definition fiff_constants.h:330
FIFF_MNE_NROW
#define FIFF_MNE_NROW
Definition fiff_constants.h:339
FIFFB_MNE_BAD_CHANNELS
#define FIFFB_MNE_BAD_CHANNELS
Definition fiff_constants.h:322
fiff_file.h
FIFF tag-kind, block-kind and type-code numerical definitions, authoritative for FIFFLIB.
FIFF_DATA_BUFFER
#define FIFF_DATA_BUFFER
Definition fiff_file.h:549
FIFF_GANTRY_ANGLE
#define FIFF_GANTRY_ANGLE
Definition fiff_file.h:548
FIFF_DACQ_STIM
#define FIFF_DACQ_STIM
Definition fiff_file.h:344
FIFFB_PROJ
#define FIFFB_PROJ
Definition fiff_file.h:402
FIFF_NCHAN
#define FIFF_NCHAN
Definition fiff_file.h:446
FIFF_BLOCK_END
#define FIFF_BLOCK_END
Definition fiff_file.h:321
FIFF_XPLOTTER_LAYOUT
#define FIFF_XPLOTTER_LAYOUT
Definition fiff_file.h:830
FIFF_PROJ_ID
#define FIFF_PROJ_ID
Definition fiff_file.h:568
FIFFB_ISOTRAK
#define FIFFB_ISOTRAK
Definition fiff_file.h:363
FIFF_HIGHPASS
#define FIFF_HIGHPASS
Definition fiff_file.h:469
FIFF_EXPERIMENTER
#define FIFF_EXPERIMENTER
Definition fiff_file.h:458
FIFF_BLOCK_START
#define FIFF_BLOCK_START
Definition fiff_file.h:320
FIFF_PROJ_NAME
#define FIFF_PROJ_NAME
Definition fiff_file.h:569
FIFF_NAME
#define FIFF_NAME
Definition fiff_file.h:478
FIFF_DESCRIPTION
#define FIFF_DESCRIPTION
Definition fiff_file.h:479
FIFF_LINE_FREQ
#define FIFF_LINE_FREQ
Definition fiff_file.h:482
FIFF_UTC_OFFSET
#define FIFF_UTC_OFFSET
Definition fiff_file.h:444
FIFFB_PROJ_ITEM
#define FIFFB_PROJ_ITEM
Definition fiff_file.h:403
FIFFB_DACQ_PARS
#define FIFFB_DACQ_PARS
Definition fiff_file.h:372
FIFF_PROJ_ITEM_VECTORS
#define FIFF_PROJ_ITEM_VECTORS
Definition fiff_file.h:798
FIFF_COORD_TRANS
#define FIFF_COORD_TRANS
Definition fiff_file.h:468
FIFF_PROJ_ITEM_KIND
#define FIFF_PROJ_ITEM_KIND
Definition fiff_file.h:793
FIFF_DACQ_PARS
#define FIFF_DACQ_PARS
Definition fiff_file.h:343
FIFF_MEAS_DATE
#define FIFF_MEAS_DATE
Definition fiff_file.h:450
FIFF_CH_INFO
#define FIFF_CH_INFO
Definition fiff_file.h:449
FIFF_PROJ_ITEM_CH_NAME_LIST
#define FIFF_PROJ_ITEM_CH_NAME_LIST
Definition fiff_file.h:802
FIFF_DIG_POINT
#define FIFF_DIG_POINT
Definition fiff_file.h:459
FIFF_LOWPASS
#define FIFF_LOWPASS
Definition fiff_file.h:465
FIFFB_MEAS_INFO
#define FIFFB_MEAS_INFO
Definition fiff_file.h:356
FIFF_PROJ_ITEM_NVEC
#define FIFF_PROJ_ITEM_NVEC
Definition fiff_file.h:797
FIFF_SFREQ
#define FIFF_SFREQ
Definition fiff_file.h:447
COMLIB
Real-time client/server communication primitives for talking to mne_rt_server.
FIFFLIB
FIFF file I/O, in-memory data structures and high-level readers/writers.
Definition connectivitysettings.h:66
COMLIB::MetaData
Value-type aggregate of the FIFF metadata blocks mne_rt_server sends at the start of a measurement.
Definition rt_data_client.h:78
COMLIB::RtDataClient::setClientAlias
void setClientAlias(const QString &p_sAlias)
Definition rt_data_client.cpp:666
COMLIB::RtDataClient::readRawBuffer
void readRawBuffer(qint32 p_nChannels, Eigen::MatrixXf &data, FIFFLIB::fiff_int_t &kind)
Definition rt_data_client.cpp:641
COMLIB::RtDataClient::RtDataClient
RtDataClient(QObject *parent=nullptr)
Definition rt_data_client.cpp:41
COMLIB::RtDataClient::readInfo
FIFFLIB::FiffInfo::SPtr readInfo()
Definition rt_data_client.cpp:81
COMLIB::RtDataClient::disconnectFromHost
virtual void disconnectFromHost()
Definition rt_data_client.cpp:50
FIFFLIB::FiffCtfComp
One CTF software-gradient compensation matrix: grade kind, calibration flag and the gradiometer × ref...
Definition fiff_ctf_comp.h:73
FIFFLIB::FiffDigitizerData
Registration-ready digitization data: dig points, device→head transform and HPI fit metadata.
Definition fiff_digitizer_data.h:73
FIFFLIB::FiffDigitizerData::SPtr
QSharedPointer< FiffDigitizerData > SPtr
Definition fiff_digitizer_data.h:75
FIFFLIB::FiffInfo
Full FIFF measurement info: per-channel descriptors, sampling and filter setup, projectors,...
Definition fiff_info.h:88
FIFFLIB::FiffInfo::SPtr
QSharedPointer< FiffInfo > SPtr
Definition fiff_info.h:90
FIFFLIB::FiffProj
Single SSP projection item: kind, active flag, desired flag and the named projection vector matrix.
Definition fiff_proj.h:78
FIFFLIB::FiffStream
FIFF tag-stream reader/writer: wraps a QIODevice and exposes typed read_* / write_* methods for every...
Definition fiff_stream.h:111
FIFFLIB::FiffStream::read_rt_tag
bool read_rt_tag(std::unique_ptr< FiffTag > &p_pTag)
Definition fiff_stream.cpp:1754
FIFFLIB::FiffStream::write_rt_command
void write_rt_command(fiff_int_t command, const QString &data)
Definition fiff_stream.cpp:3364
FIFFLIB::FiffStream::split_name_list
static QStringList split_name_list(QString p_sNameList)
Definition fiff_stream.cpp:2026
FIFFLIB::FiffStream::read_tag
bool read_tag(std::unique_ptr< FiffTag > &p_pTag, fiff_long_t pos=-1)
Definition fiff_stream.cpp:1774
FIFFLIB::FiffTag::UPtr
std::unique_ptr< FiffTag > UPtr
Definition fiff_tag.h:164
Generated on for MNE-CPP by doxygen 1.16.1