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