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