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