void TW_CALL SkinningCallback::compute_weights(void * clientData) { Skinning * skinning = scast(clientData); skinning->auto_dof = false; verbose("Computing BBW weights\n"); // Determine which Bones have weights bool success = distribute_weight_indices(skinning->skel->roots); if(!success) { return; } // Gather samples along controls MatrixXd S; gather_samples(skinning->skel->roots,10,S); VectorXi IM; faces_first(skinning->V,skinning->F,IM); skinning->Tets = skinning->Tets.unaryExpr(bind1st(mem_fun( static_cast<VectorXi::Scalar& (VectorXi::*)(VectorXi::Index)>(&VectorXi::operator())), &IM)).eval(); // Surface vertices MatrixXd SV = skinning->V.block(0,0,skinning->F.maxCoeff()+1,skinning->V.cols()); // Remesh at control samples MatrixXd VS = cat(1,SV,S); // Boundary faces MatrixXi BF; cout<<"tetgen begin()"<<endl; int status = igl::tetgen::tetrahedralize( VS,skinning->F,"Ypq100",skinning->V,skinning->Tets,BF); cout<<"tetgen end()"<<endl; if(BF.rows() != skinning->F.rows()) { //assert(BF.maxCoeff() == skinning->F.maxCoeff()); verbose("^%s: Warning: boundary faces != orignal faces\n",__FUNCTION__); } if(status != 0) { verbose( "************************************************************\n" "************************************************************\n" "************************************************************\n" "************************************************************\n" "* ^%s: tetgen failed. Just meshing convex hull\n" "************************************************************\n" "************************************************************\n" "************************************************************\n" "************************************************************\n" ,__FUNCTION__); status = igl::tetgen::tetrahedralize( VS,skinning->F,"q1.414",skinning->V,skinning->Tets,BF); assert(skinning->F.maxCoeff() < skinning->V.rows()); if(status != 0) { verbose("^%s: tetgen failed again.\n",__FUNCTION__); return; } } #ifdef __APPLE__ launch_medit(skinning->V,skinning->Tets,skinning->F,false); #endif skinning->initialize_mesh(); // Get boundary conditions VectorXi b; MatrixXd bc; boundary_conditions(skinning->V,skinning->Tets,skinning->skel->roots,b,bc); // call BBW igl::bbw::BBWData bbw_data; bbw_data.active_set_params.max_iter = 10; success = igl::bbw::bbw( skinning->V, skinning->Tets, b, bc, bbw_data, skinning->OW ); skinning->OW = (skinning->OW.array().colwise() / skinning->OW.rowwise().sum().array()).eval(); if(!success) { return; } // Clear extra weights skinning->skel->set_editing(false); skinning->EW.resize(skinning->OW.rows(),0); skinning->initialize_weights(); }
int main(int argc, char *argv[]) { const char *inLabelExt = ".txt"; const char *outScoreFile = NULL; bool bShowConfusion = false; // process commandline arguments DRWN_BEGIN_CMDLINE_PROCESSING(argc, argv) DRWN_CMDLINE_STR_OPTION("-inLabels", inLabelExt) DRWN_CMDLINE_STR_OPTION("-outScores", outScoreFile) DRWN_CMDLINE_BOOL_OPTION("-confusion", bShowConfusion) DRWN_END_CMDLINE_PROCESSING(usage()); if (DRWN_CMDLINE_ARGC != 1) { usage(); return -1; } drwnCodeProfiler::tic(drwnCodeProfiler::getHandle("main")); // read list of evaluation images const char *evalList = DRWN_CMDLINE_ARGV[0]; DRWN_LOG_MESSAGE("Reading evaluation list from " << evalList << "..."); vector<string> baseNames = drwnReadFile(evalList); DRWN_LOG_MESSAGE("...read " << baseNames.size() << " images"); const int nLabels = gMultiSegRegionDefs.maxKey() + 1; drwnConfusionMatrix confusion(nLabels); vector<double> scores(baseNames.size()); // process results DRWN_LOG_MESSAGE("Processing results (" << inLabelExt << ")..."); int hProcessImage = drwnCodeProfiler::getHandle("processImage"); for (int i = 0; i < (int)baseNames.size(); i++) { drwnCodeProfiler::tic(hProcessImage); string lblFilename = gMultiSegConfig.filename("lblDir", baseNames[i], "lblExt"); string resFilename = gMultiSegConfig.filebase("outputDir", baseNames[i]) + string(inLabelExt); DRWN_LOG_STATUS("..." << baseNames[i] << " (" << (i + 1) << " of " << baseNames.size() << ")"); // read ground-truth labels MatrixXi actualLabels; //drwnReadUnknownMatrix(actualLabels, lblFilename.c_str()); drwnLoadPixelLabels(actualLabels, lblFilename.c_str(), nLabels); // read inferred labels MatrixXi predictedLabels(actualLabels.rows(), actualLabels.cols()); drwnReadMatrix(predictedLabels, resFilename.c_str()); DRWN_ASSERT((predictedLabels.rows() == actualLabels.rows()) && (predictedLabels.cols() == actualLabels.cols())); // accumulate results for this image drwnConfusionMatrix imageConfusion(nLabels); for (int y = 0; y < actualLabels.rows(); y++) { for (int x = 0; x < actualLabels.cols(); x++) { if (actualLabels(y, x) < 0) continue; imageConfusion.accumulate(actualLabels(y, x), predictedLabels(y, x)); } } scores[i] = imageConfusion.accuracy(); // add to dataset results confusion.accumulate(imageConfusion); drwnCodeProfiler::toc(hProcessImage); } // display results if (bShowConfusion) { confusion.printRowNormalized(cout, "--- Class Confusion Matrix ---"); confusion.printPrecisionRecall(cout, "--- Recall/Precision (by Class) ---"); confusion.printF1Score(cout, "--- F1-Score (by Class) ---"); confusion.printJaccard(cout, "--- Intersection/Union Metric (by Class) ---"); } DRWN_LOG_MESSAGE("Overall class accuracy: " << confusion.accuracy() << " (" << evalList << ")"); DRWN_LOG_MESSAGE("Average class accuracy: " << confusion.avgRecall() << " (" << evalList << ")"); DRWN_LOG_MESSAGE("Average jaccard score: " << confusion.avgJaccard() << " (" << evalList << ")"); // write scores if (outScoreFile != NULL) { ofstream ofs(outScoreFile); DRWN_ASSERT_MSG(!ofs.fail(), outScoreFile); for (int i = 0; i < (int)scores.size(); i++) { ofs << scores[i] << "\n"; } ofs.close(); } // clean up and print profile information drwnCodeProfiler::toc(drwnCodeProfiler::getHandle("main")); drwnCodeProfiler::print(); return 0; }
/** * The function main marks the entry point of the program. * By default, main has the storage class extern. * * @param [in] argc (argument count) is an integer that indicates how many arguments were entered on the command line when the program was started. * @param [in] argv (argument vector) is an array of pointers to arrays of character objects. The array objects are null-terminated strings, representing the arguments that were entered on the command line when the program was started. * @return the value that was set to exit() (which is 0 if exit() is called via quit()). */ int main(int argc, char *argv[]) { QApplication a(argc, argv); // Command Line Parser QCommandLineParser parser; parser.setApplicationDescription("Clustered Inverse Powell Rap Music Raw Example"); parser.addHelpOption(); QCommandLineOption inputOption("fileIn", "The input file <in>.", "in", QCoreApplication::applicationDirPath() + "/MNE-sample-data/MEG/sample/sample_audvis_raw.fif"); QCommandLineOption eventsFileOption("eve", "Path to the event <file>.", "file", QCoreApplication::applicationDirPath() + "/MNE-sample-data/MEG/sample/sample_audvis_raw-eve.fif"); QCommandLineOption fwdOption("fwd", "Path to forwad solution <file>.", "file", QCoreApplication::applicationDirPath() + "/MNE-sample-data/MEG/sample/sample_audvis-meg-eeg-oct-6-fwd.fif"); QCommandLineOption surfOption("surfType", "Surface type <type>.", "type", "orig"); QCommandLineOption annotOption("annotType", "Annotation type <type>.", "type", "aparc.a2009s"); QCommandLineOption subjectOption("subject", "Selected subject <subject>.", "subject", "sample"); QCommandLineOption subjectPathOption("subjectPath", "Selected subject path <subjectPath>.", "subjectPath", QCoreApplication::applicationDirPath() + "/MNE-sample-data/subjects"); QCommandLineOption stcFileOption("stcOut", "Path to stc <file>, which is to be written.", "file", ""); QCommandLineOption numDipolePairsOption("numDip", "<number> of dipole pairs to localize.", "number", "7"); QCommandLineOption evokedIdxOption("aveIdx", "The average <index> to choose from the average file.", "index", "1"); QCommandLineOption hemiOption("hemi", "Selected hemisphere <hemi>.", "hemi", "2"); QCommandLineOption doMovieOption("doMovie", "Create overlapping movie.", "doMovie", "false"); QCommandLineOption keepCompOption("keepComp", "Keep compensators.", "keepComp", "false"); QCommandLineOption pickAllOption("pickAll", "Pick all channels.", "pickAll", "true"); QCommandLineOption destCompsOption("destComps", "<Destination> of the compensator which is to be calculated.", "destination", "0"); parser.addOption(inputOption); parser.addOption(eventsFileOption); parser.addOption(fwdOption); parser.addOption(surfOption); parser.addOption(annotOption); parser.addOption(subjectOption); parser.addOption(subjectPathOption); parser.addOption(stcFileOption); parser.addOption(numDipolePairsOption); parser.addOption(evokedIdxOption); parser.addOption(hemiOption); parser.addOption(doMovieOption); parser.addOption(keepCompOption); parser.addOption(pickAllOption); parser.addOption(destCompsOption); parser.process(a); //Load data QFile t_fileRaw(parser.value(inputOption)); QString t_sEventName = parser.value(eventsFileOption); QFile t_fileFwd(parser.value(fwdOption)); SurfaceSet t_surfSet (parser.value(subjectOption), parser.value(hemiOption).toInt(), parser.value(surfOption), parser.value(subjectPathOption)); AnnotationSet t_annotationSet (parser.value(subjectOption), parser.value(hemiOption).toInt(), parser.value(annotOption), parser.value(subjectPathOption)); QString t_sFileNameStc(parser.value(stcFileOption)); qint32 numDipolePairs = parser.value(numDipolePairsOption).toInt(); //Choose average qint32 event = parser.value(evokedIdxOption).toInt(); float tmin = 0.1f; float tmax = 0.2f; bool keep_comp = false; if(parser.value(keepCompOption) == "false" || parser.value(keepCompOption) == "0") { keep_comp = false; } else if(parser.value(keepCompOption) == "true" || parser.value(keepCompOption) == "1") { keep_comp = true; } fiff_int_t dest_comp = parser.value(destCompsOption).toInt(); bool pick_all = false; if(parser.value(pickAllOption) == "false" || parser.value(pickAllOption) == "0") { pick_all = false; } else if(parser.value(pickAllOption) == "true" || parser.value(pickAllOption) == "1") { pick_all = true; } qint32 k, p; bool doMovie = false; if(parser.value(doMovieOption) == "false" || parser.value(doMovieOption) == "0") { pick_all = false; } else if(parser.value(doMovieOption) == "true" || parser.value(doMovieOption) == "1") { pick_all = true; } // // Load data // MNEForwardSolution t_Fwd(t_fileFwd); if(t_Fwd.isEmpty()) return 1; // // Setup for reading the raw data // FiffRawData raw(t_fileRaw); RowVectorXi picks; if (pick_all) { // // Pick all // picks.resize(raw.info.nchan); for(k = 0; k < raw.info.nchan; ++k) picks(k) = k; // } else { QStringList include; include << "STI 014"; bool want_meg = true; bool want_eeg = false; bool want_stim = false; picks = raw.info.pick_types(want_meg, want_eeg, want_stim, include, raw.info.bads);//prefer member function } QStringList ch_names; for(k = 0; k < picks.cols(); ++k) ch_names << raw.info.ch_names[picks(0,k)]; // // Set up projection // if (raw.info.projs.size() == 0) printf("No projector specified for these data\n"); else { // // Activate the projection items // for (k = 0; k < raw.info.projs.size(); ++k) raw.info.projs[k].active = true; printf("%d projection items activated\n",raw.info.projs.size()); // // Create the projector // // fiff_int_t nproj = MNE::make_projector_info(raw.info, raw.proj); Using the member function instead fiff_int_t nproj = raw.info.make_projector(raw.proj); if (nproj == 0) { printf("The projection vectors do not apply to these channels\n"); } else { printf("Created an SSP operator (subspace dimension = %d)\n",nproj); } } // // Set up the CTF compensator // qint32 current_comp = raw.info.get_current_comp(); if (current_comp > 0) printf("Current compensation grade : %d\n",current_comp); if (keep_comp) dest_comp = current_comp; if (current_comp != dest_comp) { qDebug() << "This part needs to be debugged"; if(MNE::make_compensator(raw.info, current_comp, dest_comp, raw.comp)) { raw.info.set_current_comp(dest_comp); printf("Appropriate compensator added to change to grade %d.\n",dest_comp); } else { printf("Could not make the compensator\n"); return 0; } } // // Read the events // QFile t_EventFile; MatrixXi events; if (t_sEventName.size() == 0) { p = t_fileRaw.fileName().indexOf(".fif"); if (p > 0) { t_sEventName = t_fileRaw.fileName().replace(p, 4, "-eve.fif"); } else { printf("Raw file name does not end properly\n"); return 0; } // events = mne_read_events(t_sEventName); t_EventFile.setFileName(t_sEventName); MNE::read_events(t_EventFile, events); printf("Events read from %s\n",t_sEventName.toUtf8().constData()); } else { // // Binary file // p = t_fileRaw.fileName().indexOf(".fif"); if (p > 0) { t_EventFile.setFileName(t_sEventName); if(!MNE::read_events(t_EventFile, events)) { printf("Error while read events.\n"); return 0; } printf("Binary event file %s read\n",t_sEventName.toUtf8().constData()); } else { // // Text file // printf("Text file %s is not supported jet.\n",t_sEventName.toUtf8().constData()); // try // events = load(eventname); // catch // error(me,mne_omit_first_line(lasterr)); // end // if size(events,1) < 1 // error(me,'No data in the event file'); // end // // // // Convert time to samples if sample number is negative // // // for p = 1:size(events,1) // if events(p,1) < 0 // events(p,1) = events(p,2)*raw.info.sfreq; // end // end // // // // Select the columns of interest (convert to integers) // // // events = int32(events(:,[1 3 4])); // // // // New format? // // // if events(1,2) == 0 && events(1,3) == 0 // fprintf(1,'The text event file %s is in the new format\n',eventname); // if events(1,1) ~= raw.first_samp // error(me,'This new format event file is not compatible with the raw data'); // end // else // fprintf(1,'The text event file %s is in the old format\n',eventname); // // // // Offset with first sample // // // events(:,1) = events(:,1) + raw.first_samp; // end } } // // Select the desired events // qint32 count = 0; MatrixXi selected = MatrixXi::Zero(1, events.rows()); for (p = 0; p < events.rows(); ++p) { if (events(p,1) == 0 && events(p,2) == event) { selected(0,count) = p; ++count; } } selected.conservativeResize(1, count); if (count > 0) printf("%d matching events found\n",count); else { printf("No desired events found.\n"); return 0; } fiff_int_t event_samp, from, to; MatrixXd timesDummy; MNEEpochDataList data; MNEEpochData* epoch = NULL; MatrixXd times; for (p = 0; p < count; ++p) { // // Read a data segment // event_samp = events(selected(p),0); from = event_samp + tmin*raw.info.sfreq; to = event_samp + floor(tmax*raw.info.sfreq + 0.5); epoch = new MNEEpochData(); if(raw.read_raw_segment(epoch->epoch, timesDummy, from, to, picks)) { if (p == 0) { times.resize(1, to-from+1); for (qint32 i = 0; i < times.cols(); ++i) times(0, i) = ((float)(from-event_samp+i)) / raw.info.sfreq; } epoch->event = event; epoch->tmin = ((float)(from)-(float)(raw.first_samp))/raw.info.sfreq; epoch->tmax = ((float)(to)-(float)(raw.first_samp))/raw.info.sfreq; data.append(MNEEpochData::SPtr(epoch));//List takes ownwership of the pointer - no delete need } else { printf("Can't read the event data segments"); return 0; } } if(data.size() > 0) { printf("Read %d epochs, %d samples each.\n",data.size(),(qint32)data[0]->epoch.cols()); // //DEBUG // std::cout << data[0]->epoch.block(0,0,10,10) << std::endl; // qDebug() << data[0]->epoch.rows() << " x " << data[0]->epoch.cols(); // std::cout << times.block(0,0,1,10) << std::endl; // qDebug() << times.rows() << " x " << times.cols(); } // Calculate the average // Option 1 - Random selection VectorXi vecSel(2); srand (time(NULL)); // initialize random seed for(qint32 i = 0; i < vecSel.size(); ++i) { qint32 val = rand() % count; vecSel(i) = val; } // //Option 3 - Take all epochs // VectorXi vecSel(data.size()); // for(qint32 i = 0; i < vecSel.size(); ++i) // { // vecSel(i) = i; // } // //Option 3 - Manual selection // VectorXi vecSel(20); // vecSel << 76, 74, 13, 61, 97, 94, 75, 71, 60, 56, 26, 57, 56, 0, 52, 72, 33, 86, 96, 67; std::cout << "Select following epochs to average:\n" << vecSel << std::endl; FiffEvoked evoked = data.average(raw.info, tmin*raw.info.sfreq, floor(tmax*raw.info.sfreq + 0.5), vecSel); QStringList ch_sel_names = t_Fwd.info.ch_names; FiffEvoked pickedEvoked = evoked.pick_channels(ch_sel_names); //######################################################################################## // RAP MUSIC Source Estimate // // Cluster forward solution; // MNEForwardSolution t_clusteredFwd = t_Fwd.cluster_forward_solution(t_annotationSet, 20);//40); // // Compute inverse solution // PwlRapMusic t_pwlRapMusic(t_clusteredFwd, false, numDipolePairs); #ifdef BENCHMARK MNESourceEstimate sourceEstimate; QList<qint64> qVecElapsedTime; for(qint32 i = 0; i < 100; ++i) { //Benchmark time QElapsedTimer timer; timer.start(); sourceEstimate = t_pwlRapMusic.calculateInverse(pickedEvoked); qVecElapsedTime.append(timer.elapsed()); } double meanTime = 0.0; qint32 offset = 19; qint32 c = 0; for(qint32 i = offset; i < qVecElapsedTime.size(); ++i) { meanTime += qVecElapsedTime[i]; ++c; } meanTime /= (double)c; double varTime = 0; for(qint32 i = offset; i < qVecElapsedTime.size(); ++i) varTime += pow(qVecElapsedTime[i] - meanTime,2); varTime /= (double)c - 1.0f; varTime = sqrt(varTime); qDebug() << "RAP-MUSIC calculation took" << meanTime << "+-" << varTime << "ms in average"; #else int iWinSize = 200; if(doMovie) { t_pwlRapMusic.setStcAttr(iWinSize, 0.6f); } MNESourceEstimate sourceEstimate = t_pwlRapMusic.calculateInverse(pickedEvoked); if(doMovie) { //Select only the activations once MatrixXd dataPicked(sourceEstimate.data.rows(), int(std::floor(sourceEstimate.data.cols()/iWinSize))); for(int i = 0; i < dataPicked.cols(); ++i) { dataPicked.col(i) = sourceEstimate.data.col(i*iWinSize); } sourceEstimate.data = dataPicked; } if(sourceEstimate.isEmpty()) { return 1; } #endif if(sourceEstimate.isEmpty()) return 1; // // View activation time-series // std::cout << "\nsourceEstimate:\n" << sourceEstimate.data.block(0,0,10,10) << std::endl; // std::cout << "time\n" << sourceEstimate.times.block(0,0,1,10) << std::endl; // std::cout << "timeMin\n" << sourceEstimate.times[0] << std::endl; // std::cout << "timeMax\n" << sourceEstimate.times[sourceEstimate.times.size()-1] << std::endl; // std::cout << "time step\n" << sourceEstimate.tstep << std::endl; //Source Estimate end //######################################################################################## // //only one time point - P100 // qint32 sample = 0; // for(qint32 i = 0; i < sourceEstimate.times.size(); ++i) // { // if(sourceEstimate.times(i) >= 0) // { // sample = i; // break; // } // } // sample += (qint32)ceil(0.106/sourceEstimate.tstep); //100ms // sourceEstimate = sourceEstimate.reduce(sample, 1); AbstractView::SPtr p3DAbstractView = AbstractView::SPtr(new AbstractView()); Data3DTreeModel::SPtr p3DDataModel = p3DAbstractView->getTreeModel(); p3DDataModel->addSurfaceSet(parser.value(subjectOption), evoked.comment, t_surfSet, t_annotationSet); //Add rt source loc data and init some visualization values if(MneEstimateTreeItem* pRTDataItem = p3DDataModel->addSourceData(parser.value(subjectOption), evoked.comment, sourceEstimate, t_clusteredFwd, t_surfSet, t_annotationSet)) { pRTDataItem->setLoopState(true); pRTDataItem->setTimeInterval(17); pRTDataItem->setNumberAverages(1); pRTDataItem->setStreamingState(true); pRTDataItem->setThresholds(QVector3D(0.01f,0.5f,1.0f)); pRTDataItem->setVisualizationType("Annotation based"); pRTDataItem->setColormapType("Hot"); } p3DAbstractView->show(); QList<Label> t_qListLabels; QList<RowVector4i> t_qListRGBAs; //ToDo overload toLabels using instead of t_surfSet rr of MNESourceSpace t_annotationSet.toLabels(t_surfSet, t_qListLabels, t_qListRGBAs); if(!t_sFileNameStc.isEmpty()) { QFile t_fileClusteredStc(t_sFileNameStc); sourceEstimate.write(t_fileClusteredStc); } return a.exec();//1;//a.exec(); }
/** * The function main marks the entry point of the program. * By default, main has the storage class extern. * * @param [in] argc (argument count) is an integer that indicates how many arguments were entered on the command line when the program was started. * @param [in] argv (argument vector) is an array of pointers to arrays of character objects. The array objects are null-terminated strings, representing the arguments that were entered on the command line when the program was started. * @return the value that was set to exit() (which is 0 if exit() is called via quit()). */ int main(int argc, char *argv[]) { QApplication a(argc, argv); QFile t_fileRaw("./MNE-sample-data/MEG/sample/sample_audvis_raw.fif"); QString t_sEventName = "./MNE-sample-data/MEG/sample/sample_audvis_raw-eve.fif"; QFile t_fileFwd("./MNE-sample-data/MEG/sample/sample_audvis-meg-eeg-oct-6-fwd.fif"); AnnotationSet t_annotationSet("./MNE-sample-data/subjects/sample/label/lh.aparc.a2009s.annot", "./MNE-sample-data/subjects/sample/label/rh.aparc.a2009s.annot"); SurfaceSet t_surfSet("./MNE-sample-data/subjects/sample/surf/lh.white", "./MNE-sample-data/subjects/sample/surf/rh.white"); // QFile t_fileRaw("E:/Data/sl_data/MEG/mind006/mind006_051209_auditory01_raw.fif"); // QString t_sEventName = "E:/Data/sl_data/MEG/mind006/mind006_051209_auditory01_raw-eve.fif"; // QFile t_fileFwd("E:/Data/sl_data/MEG/mind006/mind006_051209_auditory01_raw-oct-6p-fwd.fif"); // AnnotationSet t_annotationSet("E:/Data/sl_data/subjects/mind006/label/lh.aparc.a2009s.annot", "E:/Data/sl_data/subjects/mind006/label/rh.aparc.a2009s.annot"); // SurfaceSet t_surfSet("E:/Data/sl_data/subjects/mind006/surf/lh.white", "E:/Data/sl_data/subjects/mind006/surf/rh.white"); // QFile t_fileRaw("E:/Data/sl_data/MEG/mind006/mind006_051209_median01_raw.fif"); // QString t_sEventName = "E:/Data/sl_data/MEG/mind006/mind006_051209_median01_raw-eve.fif"; // QFile t_fileFwd("E:/Data/sl_data/MEG/mind006/mind006_051209_median01_raw-oct-6-fwd.fif"); // AnnotationSet t_annotationSet("E:/Data/sl_data/subjects/mind006/label/lh.aparc.a2009s.annot", "E:/Data/sl_data/subjects/mind006/label/rh.aparc.a2009s.annot"); // SurfaceSet t_surfSet("E:/Data/sl_data/subjects/mind006/surf/lh.white", "E:/Data/sl_data/subjects/mind006/surf/rh.white"); QString t_sFileNameStc("");//("mind006_051209_auditory01.stc"); bool doMovie = false;//true; qint32 numDipolePairs = 7; qint32 event = 1; float tmin = -0.2f; float tmax = 0.4f; bool keep_comp = false; fiff_int_t dest_comp = 0; bool pick_all = true; qint32 k, p; // Parse command line parameters for(qint32 i = 0; i < argc; ++i) { if(strcmp(argv[i], "-stc") == 0 || strcmp(argv[i], "--stc") == 0) { if(i + 1 < argc) t_sFileNameStc = QString::fromUtf8(argv[i+1]); } } // // Load data // MNEForwardSolution t_Fwd(t_fileFwd); if(t_Fwd.isEmpty()) return 1; // // Setup for reading the raw data // FiffRawData raw(t_fileRaw); RowVectorXi picks; if (pick_all) { // // Pick all // picks.resize(raw.info.nchan); for(k = 0; k < raw.info.nchan; ++k) picks(k) = k; // } else { QStringList include; include << "STI 014"; bool want_meg = true; bool want_eeg = false; bool want_stim = false; picks = raw.info.pick_types(want_meg, want_eeg, want_stim, include, raw.info.bads);//prefer member function } QStringList ch_names; for(k = 0; k < picks.cols(); ++k) ch_names << raw.info.ch_names[picks(0,k)]; // // Set up projection // if (raw.info.projs.size() == 0) printf("No projector specified for these data\n"); else { // // Activate the projection items // for (k = 0; k < raw.info.projs.size(); ++k) raw.info.projs[k].active = true; printf("%d projection items activated\n",raw.info.projs.size()); // // Create the projector // // fiff_int_t nproj = MNE::make_projector_info(raw.info, raw.proj); Using the member function instead fiff_int_t nproj = raw.info.make_projector(raw.proj); if (nproj == 0) { printf("The projection vectors do not apply to these channels\n"); } else { printf("Created an SSP operator (subspace dimension = %d)\n",nproj); } } // // Set up the CTF compensator // qint32 current_comp = raw.info.get_current_comp(); if (current_comp > 0) printf("Current compensation grade : %d\n",current_comp); if (keep_comp) dest_comp = current_comp; if (current_comp != dest_comp) { qDebug() << "This part needs to be debugged"; if(MNE::make_compensator(raw.info, current_comp, dest_comp, raw.comp)) { raw.info.set_current_comp(dest_comp); printf("Appropriate compensator added to change to grade %d.\n",dest_comp); } else { printf("Could not make the compensator\n"); return 0; } } // // Read the events // QFile t_EventFile; MatrixXi events; if (t_sEventName.size() == 0) { p = t_fileRaw.fileName().indexOf(".fif"); if (p > 0) { t_sEventName = t_fileRaw.fileName().replace(p, 4, "-eve.fif"); } else { printf("Raw file name does not end properly\n"); return 0; } // events = mne_read_events(t_sEventName); t_EventFile.setFileName(t_sEventName); MNE::read_events(t_EventFile, events); printf("Events read from %s\n",t_sEventName.toUtf8().constData()); } else { // // Binary file // p = t_fileRaw.fileName().indexOf(".fif"); if (p > 0) { t_EventFile.setFileName(t_sEventName); if(!MNE::read_events(t_EventFile, events)) { printf("Error while read events.\n"); return 0; } printf("Binary event file %s read\n",t_sEventName.toUtf8().constData()); } else { // // Text file // printf("Text file %s is not supported jet.\n",t_sEventName.toUtf8().constData()); // try // events = load(eventname); // catch // error(me,mne_omit_first_line(lasterr)); // end // if size(events,1) < 1 // error(me,'No data in the event file'); // end // // // // Convert time to samples if sample number is negative // // // for p = 1:size(events,1) // if events(p,1) < 0 // events(p,1) = events(p,2)*raw.info.sfreq; // end // end // // // // Select the columns of interest (convert to integers) // // // events = int32(events(:,[1 3 4])); // // // // New format? // // // if events(1,2) == 0 && events(1,3) == 0 // fprintf(1,'The text event file %s is in the new format\n',eventname); // if events(1,1) ~= raw.first_samp // error(me,'This new format event file is not compatible with the raw data'); // end // else // fprintf(1,'The text event file %s is in the old format\n',eventname); // // // // Offset with first sample // // // events(:,1) = events(:,1) + raw.first_samp; // end } } // // Select the desired events // qint32 count = 0; MatrixXi selected = MatrixXi::Zero(1, events.rows()); for (p = 0; p < events.rows(); ++p) { if (events(p,1) == 0 && events(p,2) == event) { selected(0,count) = p; ++count; } } selected.conservativeResize(1, count); if (count > 0) printf("%d matching events found\n",count); else { printf("No desired events found.\n"); return 0; } fiff_int_t event_samp, from, to; MatrixXd timesDummy; MNEEpochDataList data; MNEEpochData* epoch = NULL; MatrixXd times; for (p = 0; p < count; ++p) { // // Read a data segment // event_samp = events(selected(p),0); from = event_samp + tmin*raw.info.sfreq; to = event_samp + floor(tmax*raw.info.sfreq + 0.5); epoch = new MNEEpochData(); if(raw.read_raw_segment(epoch->epoch, timesDummy, from, to, picks)) { if (p == 0) { times.resize(1, to-from+1); for (qint32 i = 0; i < times.cols(); ++i) times(0, i) = ((float)(from-event_samp+i)) / raw.info.sfreq; } epoch->event = event; epoch->tmin = ((float)(from)-(float)(raw.first_samp))/raw.info.sfreq; epoch->tmax = ((float)(to)-(float)(raw.first_samp))/raw.info.sfreq; data.append(MNEEpochData::SPtr(epoch));//List takes ownwership of the pointer - no delete need } else { printf("Can't read the event data segments"); return 0; } } if(data.size() > 0) { printf("Read %d epochs, %d samples each.\n",data.size(),(qint32)data[0]->epoch.cols()); //DEBUG std::cout << data[0]->epoch.block(0,0,10,10) << std::endl; qDebug() << data[0]->epoch.rows() << " x " << data[0]->epoch.cols(); std::cout << times.block(0,0,1,10) << std::endl; qDebug() << times.rows() << " x " << times.cols(); } // // calculate the average // // //Option 1 // qint32 numAverages = 99; // VectorXi vecSel(numAverages); // srand (time(NULL)); // initialize random seed // for(qint32 i = 0; i < vecSel.size(); ++i) // { // qint32 val = rand() % data.size(); // vecSel(i) = val; // } //Option 2 // VectorXi vecSel(20); //// vecSel << 76, 74, 13, 61, 97, 94, 75, 71, 60, 56, 26, 57, 56, 0, 52, 72, 33, 86, 96, 67; // vecSel << 65, 22, 47, 55, 16, 29, 14, 36, 57, 97, 89, 46, 9, 93, 83, 52, 71, 52, 3, 96; //Option 3 Newest // VectorXi vecSel(10); // vecSel << 0, 96, 80, 55, 66, 25, 26, 2, 55, 58, 6, 88; VectorXi vecSel(1); vecSel << 0; std::cout << "Select following epochs to average:\n" << vecSel << std::endl; FiffEvoked evoked = data.average(raw.info, tmin*raw.info.sfreq, floor(tmax*raw.info.sfreq + 0.5), vecSel); QStringList ch_sel_names = t_Fwd.info.ch_names; FiffEvoked pickedEvoked = evoked.pick_channels(ch_sel_names); //######################################################################################## // RAP MUSIC Source Estimate // // Cluster forward solution; // MNEForwardSolution t_clusteredFwd = t_Fwd.cluster_forward_solution(t_annotationSet, 20);//40); // // Compute inverse solution // RapMusic t_rapMusic(t_clusteredFwd, false, numDipolePairs); if(doMovie) t_rapMusic.setStcAttr(200,0.5); MNESourceEstimate sourceEstimate = t_rapMusic.calculateInverse(pickedEvoked); if(sourceEstimate.isEmpty()) return 1; // // View activation time-series // std::cout << "\nsourceEstimate:\n" << sourceEstimate.data.block(0,0,10,10) << std::endl; // std::cout << "time\n" << sourceEstimate.times.block(0,0,1,10) << std::endl; // std::cout << "timeMin\n" << sourceEstimate.times[0] << std::endl; // std::cout << "timeMax\n" << sourceEstimate.times[sourceEstimate.times.size()-1] << std::endl; // std::cout << "time step\n" << sourceEstimate.tstep << std::endl; //Source Estimate end //######################################################################################## // //only one time point - P100 // qint32 sample = 0; // for(qint32 i = 0; i < sourceEstimate.times.size(); ++i) // { // if(sourceEstimate.times(i) >= 0) // { // sample = i; // break; // } // } // sample += (qint32)ceil(0.106/sourceEstimate.tstep); //100ms // sourceEstimate = sourceEstimate.reduce(sample, 1); View3D::SPtr testWindow = View3D::SPtr(new View3D()); testWindow->addBrainData("Subject01", "HemiLRSet", t_surfSet, t_annotationSet); QList<BrainRTSourceLocDataTreeItem*> rtItemList = testWindow->addRtBrainData("Subject01", "HemiLRSet", sourceEstimate, t_clusteredFwd); testWindow->show(); Control3DWidget::SPtr control3DWidget = Control3DWidget::SPtr(new Control3DWidget()); control3DWidget->setView3D(testWindow); control3DWidget->show(); if(!t_sFileNameStc.isEmpty()) { QFile t_fileClusteredStc(t_sFileNameStc); sourceEstimate.write(t_fileClusteredStc); } return a.exec();//1;//a.exec(); }
int main(int argc, char *argv[]) { cout << "Usage: " << argv[0] << " [FILENAME].[off|obj|ply] [1-7] [sl]" << endl; cout << "where 1-7 is the cost function to use" << endl; cout << " s = save images at all decimation steps" << endl; cout << " l = disable lighting" << endl; cout << endl; cout << "Keybindings:" << endl; cout << " [space] toggle animation." << endl; cout << " 'r' reset." << endl; cout << " '1' edge collapse." << endl; cout << " '2' vertex split." << endl; cout << " 's' save screenshot." << endl; cout << " 'c' switch color mode." << endl; cout << " 'f' cycle cost function." << endl; cout << endl; // Load a closed manifold mesh string filename; if (argc >= 2) { filename = argv[1]; } else { return 0; } if (argc >= 3) { int idx = stoi(argv[2]) - 1; cost_function_n = idx; if (idx >= 0 && idx < cost_functions.size()) shortest_edge_and_midpoint = *(cost_functions.begin() + idx); } if (!igl::read_triangle_mesh(filename, OV, OF)) { cout << "could not read mesh from \"" << filename << "\"" << endl; return 1; } // compute normals igl::per_face_normals(OV, OF, normals); // Prepare array-based edge data structures and priority queue // EMAP is a map from faces to edges. // Index into it like EMAP(face + i*F.rows()) where i is an edge index // between 0 and 2 corresponding to the three edges of a triangle. VectorXi EMAP; // E is a map from edges to vertices. Given some edge index e, // E(e, 0) and E(e, 1) are the two vertices that the edge is composed of. MatrixXi E; // EF is a map from edges to faces. For some edge index e, // EF(e, 0) and E(e, 1) are the two faces that contain the edge e. MatrixXi EF; // EI is a map from edges to face corners. For some edge index e, // EI(e, 0) is the index i such that EMAP(EF(e, 0) + i*F.rows()) == e and // EI(e, 1) is the index i such that EMAP(EF(e, 1) + i*F.rows()) == e. MatrixXi EI; typedef std::set<std::pair<double, int>> PriorityQueue; // Q stores the list of possible edge collapses and their costs PriorityQueue Q; std::vector<PriorityQueue::iterator> Qit; // If an edge were collapsed, we'd collapse it to these points: MatrixXd C; // Keep some info on edge collapses for reversal and debug reasons int num_collapsed; std::vector<MeshModification> mods; std::vector<int> iters; int total_decimations = 0; const auto &reset_view = [&]() { viewer.data.clear(); viewer.data.set_mesh(V, F); switch (color_mode) { case DISTANCE_VISUALIZATION: generate_distance_field(); case COST_VISUALIZATION: viewer.data.set_colors(colors); break; case SOLID: viewer.data.set_colors(RowVector3d(1.0, 1.0, 1.0)); break; } viewer.data.set_face_based(false); }; // Function to reset original mesh and data structures const auto &reset = [&]() { total_decimations = 0; mods.clear(); iters.clear(); F = OF; V = OV; igl::edge_flaps(F, E, EMAP, EF, EI); Qit.resize(E.rows()); C.resize(E.rows(), V.cols()); colors.resize(V.rows(), 3); colors.setZero(); VectorXd costs(V.rows()); costs.setZero(); for (int e = 0; e < E.rows(); e++) { double cost = e; RowVectorXd p(1, 3); shortest_edge_and_midpoint(e, V, F, E, EMAP, EF, EI, cost, p); C.row(e) = p; Qit[e] = Q.insert(std::pair<double, int>(cost, e)).first; costs(E(e, 0)) += cost; costs(E(e, 1)) += cost; } igl::jet(costs, true, colors); num_collapsed = 0; reset_view(); }; const auto &collapse_edges = [&](igl::viewer::Viewer &viewer) -> bool { // If animating then collapse 10% of edges if (viewer.core.is_animating && !Q.empty()) { bool something_collapsed = false; // collapse edge const int num_iters = 50; // Store the state from before the collapse so that it can be // reversed later. MatrixXd prev_V = V; MatrixXi prev_F = F; MatrixXi prev_E = E; num_collapsed = 0; int total_failures = 0; // If a certain number of failures have // occurred, we exit an infinte fail loop. for (int j = 0; j < num_iters; j++) { int e, e1, e2, f1, f2; std::vector<int> faceInd, vertInd; if (Q.empty()) break; if (!collapse_edge(shortest_edge_and_midpoint, V, F, E, EMAP, EF, EI, Q, Qit, C, e, e1, e2, f1, f2, faceInd)) { total_failures++; j--; if (total_failures > 1000) { break; } continue; } else { total_decimations++; num_collapsed++; } MatrixXi faces(faceInd.size() + 2, 3); faceInd.push_back(f1); faceInd.push_back(f2); for (int i = 0; i < faceInd.size(); i++) { faces.row(i) = prev_F.row(faceInd[i]); // cout << "ffF" << faces.row(i) << endl; } MatrixXd verts(2, 3); vertInd.push_back(prev_E(e, 0)); vertInd.push_back(prev_E(e, 1)); for (int i = 0; i < vertInd.size(); i++) { verts.row(i) = prev_V.row(vertInd[i]); } mods.push_back( MeshModification(vertInd, verts, faceInd, faces)); something_collapsed = true; } if (something_collapsed) { iters.push_back(num_collapsed); reset_view(); } } cout << "Collapsed an Edge\n" << "Decimations: " << total_decimations << "\n"; return false; }; // function to reverse edge collapse const auto &uncollapse_edges = [&](igl::viewer::Viewer &viewer) -> bool { if (viewer.core.is_animating && !mods.empty() && !iters.empty()) { int max_iter = iters.back(); iters.pop_back(); for (int i = 0; i < max_iter; i++) { MeshModification mod = mods.back(); mods.pop_back(); total_decimations--; for (int i = 0; i < mod.vertInd.size(); i++) { V.row(mod.vertInd[i]) = mod.verts.row(i); } for (int i = 0; i < mod.faceInd.size(); i++) { F.row(mod.faceInd[i]) = mod.faces.row(i); } } reset_view(); cout << "Uncollapsed an Edge\n" << "Decimations: " << total_decimations << "\n"; } }; const auto &save_images = [&]() -> bool { reset(); viewer.draw(); save_screenshot(viewer, "images/before.png"); char fn[100]; char command[512]; ofstream distfile("surface_distances", ofstream::trunc); for (int i = 0; i <= 50; i++) { collapse_edges(viewer); distfile << generate_distance_field() << endl; viewer.draw(); sprintf(fn, "images/after%03d.png", i); save_screenshot(viewer, fn); sprintf(command, "composite images/before.png " "images/after%03d.png -compose difference " "images/diff%03d.png ", i, i); system(command); sprintf(command, "composite images/after%03d.png " "images/after%03d.png -compose difference " "images/delta%03d.png ", i, i - 1, i); system(command); cout << "Step " << i << " / 100" << endl; } distfile.close(); exit(EXIT_SUCCESS); }; const auto &key_down = [&](igl::viewer::Viewer &viewer, unsigned char key, int mod) -> bool { switch (key) { case ' ': viewer.core.is_animating ^= 1; break; case 'R': case 'r': reset(); break; case '1': collapse_edges(viewer); break; case '2': uncollapse_edges(viewer); break; case '3': save_images(); break; case 'S': case 's': save_screenshot(viewer, "images/screen.png"); cout << "saved screen to images/screen.png" << endl; break; case 'C': case 'c': ((int &)color_mode)++; ((int &)color_mode) %= MAX_COLOR_MODE; reset_view(); break; case 'F': case 'f': cost_function_n++; cost_function_n %= cost_functions.size(); shortest_edge_and_midpoint = *(cost_functions.begin() + cost_function_n); reset(); break; case 'g': case 'G': cout << generate_distance_field() << endl; break; default: return false; } return true; }; const auto &s_option = [&](igl::viewer::Viewer &viewer) -> bool { if (argc >= 4) { for (char c : string(argv[3])) { switch (c) { case 's': save_images(); break; case 'l': viewer.core.shininess = 1.0; viewer.core.lighting_factor = 0.0; break; } } } }; reset(); viewer.core.is_animating = true; viewer.callback_key_pressed = key_down; viewer.callback_init = s_option; viewer.core.show_lines = false; viewer.core.camera_zoom = 2.0; return viewer.launch(); }
/** * The function main marks the entry point of the program. * By default, main has the storage class extern. * * @param [in] argc (argument count) is an integer that indicates how many arguments were entered on the command line when the program was started. * @param [in] argv (argument vector) is an array of pointers to arrays of character objects. The array objects are null-terminated strings, representing the arguments that were entered on the command line when the program was started. * @return the value that was set to exit() (which is 0 if exit() is called via quit()). */ int main(int argc, char *argv[]) { QGuiApplication app(argc, argv); QGuiApplication::setApplicationName("RTC Evaluation"); QGuiApplication::setApplicationVersion("Revision 1"); ///////////////////////////////////// #1 CLI Parser ///////////////////////////////////// QCommandLineParser parser; parser.setApplicationDescription("RTC Evaluation"); parser.addHelpOption(); parser.addVersionOption(); // MEG Source Directory QCommandLineOption srcDirectoryOption(QStringList() << "s" << "meg-source-directory", QCoreApplication::translate("main", "Read MEG (fwd, cov, raw, eve) source files from <directory>."), QCoreApplication::translate("main", "directory"), "./MNE-sample-data/MEG/sample/"); parser.addOption(srcDirectoryOption); // Forward Solution File QCommandLineOption fwdFileOption(QStringList() << "fwd" << "forward-solution", QCoreApplication::translate("main", "The forward solution <file>."), QCoreApplication::translate("main", "file"), "sample_audvis-meg-eeg-oct-6-fwd.fif"); parser.addOption(fwdFileOption); // Raw MEG File QCommandLineOption rawFileOption(QStringList() << "raw" << "raw-file", QCoreApplication::translate("main", "The raw MEG data <file>."), QCoreApplication::translate("main", "file"), "sample_audvis_raw.fif"); parser.addOption(rawFileOption); // Event File QCommandLineOption eveFileOption(QStringList() << "eve" << "event-file", QCoreApplication::translate("main", "The event <file>."), QCoreApplication::translate("main", "file"), "sample_audvis_raw-eve.fif"); parser.addOption(eveFileOption); // Event Num QCommandLineOption evenNumOption(QStringList() << "evenum" << "event-number", QCoreApplication::translate("main", "The <event number>."), QCoreApplication::translate("main", "event"), "1");//2;//3;//4; parser.addOption(evenNumOption); // FS Subject Directory QCommandLineOption subjDirectoryOption(QStringList() << "subjdir" << "subject-directory", QCoreApplication::translate("main", "The FreeSurfer <subjects directory>."), QCoreApplication::translate("main", "directory"), "./MNE-sample-data/subjects"); parser.addOption(subjDirectoryOption); // FS Subject QCommandLineOption subjIdOption(QStringList() << "subjid" << "subject-id", QCoreApplication::translate("main", "The FreeSurfer <subject id>."), QCoreApplication::translate("main", "subject id"), "sample"); parser.addOption(subjIdOption); // Target Directory QCommandLineOption targetDirectoryOption(QStringList() << "t" << "target-directory", QCoreApplication::translate("main", "Copy all result files into <directory>."), QCoreApplication::translate("main", "directory")); parser.addOption(targetDirectoryOption); // Target Prefix QCommandLineOption targetPrefixOption(QStringList() << "p" << "prefix", QCoreApplication::translate("main", "The result file's <prefix>."), QCoreApplication::translate("main", "prefix")); parser.addOption(targetPrefixOption); // tmin QCommandLineOption tMinOption(QStringList() << "tmin" << "t-min", QCoreApplication::translate("main", "The starting time point <tmin>."), QCoreApplication::translate("main", "tmin"), "0.1"); parser.addOption(tMinOption); // tmax QCommandLineOption tMaxOption(QStringList() << "tmax" << "t-max", QCoreApplication::translate("main", "The end time point <tmax>."), QCoreApplication::translate("main", "tmax"), "0.2"); parser.addOption(tMaxOption); // Process the actual command line arguments given by the user parser.process(app); //////////////////////////////// #2 get parsed values ///////////////////////////////// //Sources QString sFwdName = parser.value(srcDirectoryOption)+parser.value(fwdFileOption); qDebug() << "Forward Solution" << sFwdName; QString sRawName = parser.value(srcDirectoryOption)+parser.value(rawFileOption); qDebug() << "Raw data" << sRawName; QString t_sEventName = parser.value(srcDirectoryOption)+parser.value(eveFileOption); qDebug() << "Events" << t_sEventName; qint32 eveNum = (qint32)parser.value(evenNumOption).toInt(); qDebug() << "Event Number" << eveNum; QString t_sSubjectsDir = parser.value(subjDirectoryOption); qDebug() << "Subjects Directory" << t_sSubjectsDir; QString t_sSubject = parser.value(subjIdOption); qDebug() << "Subject" << t_sSubject; //Targets QString sTargetDir = parser.value(targetDirectoryOption); qDebug() << "Target Directory" << sTargetDir; QString sTargetPrefix = parser.value(targetPrefixOption); qDebug() << "Target Prefix" << sTargetPrefix; //Parameters float tmin = (float)parser.value(tMinOption).toFloat(); qDebug() << "tMin" << tmin; float tmax = (float)parser.value(tMaxOption).toFloat(); qDebug() << "tMax" << tmax; QFile t_fileFwd(sFwdName); // // Load data // MNEForwardSolution t_Fwd(t_fileFwd); if(t_Fwd.isEmpty()) return 1; AnnotationSet t_annotationSet(t_sSubject, 2, "aparc.a2009s", t_sSubjectsDir); // std::cout << "LabelIDs:\n" << t_annotationSet[0].getColortable().getLabelIds() << std::endl; // // Cluster forward solution; // MNEForwardSolution t_clusteredFwd = t_Fwd.cluster_forward_solution(t_annotationSet, 20);//40); QFile t_fileRaw(sRawName); // bool doMovie = false;//true; qint32 numDipolePairs = 1; bool keep_comp = false; fiff_int_t dest_comp = 0; bool pick_all = true; qint32 k, p; // // Setup for reading the raw data // FiffRawData raw(t_fileRaw); RowVectorXi picks; if (pick_all) { // // Pick all // picks.resize(raw.info.nchan); for(k = 0; k < raw.info.nchan; ++k) picks(k) = k; // } else { QStringList include; include << "STI 014"; bool want_meg = true; bool want_eeg = false; bool want_stim = false; picks = raw.info.pick_types(want_meg, want_eeg, want_stim, include, raw.info.bads);//prefer member function } QStringList ch_names; for(k = 0; k < picks.cols(); ++k) ch_names << raw.info.ch_names[picks(0,k)]; // // Set up projection // if (raw.info.projs.size() == 0) printf("No projector specified for these data\n"); else { // // Activate the projection items // for (k = 0; k < raw.info.projs.size(); ++k) raw.info.projs[k].active = true; printf("%d projection items activated\n",raw.info.projs.size()); // // Create the projector // // fiff_int_t nproj = MNE::make_projector_info(raw.info, raw.proj); Using the member function instead fiff_int_t nproj = raw.info.make_projector(raw.proj); if (nproj == 0) { printf("The projection vectors do not apply to these channels\n"); } else { printf("Created an SSP operator (subspace dimension = %d)\n",nproj); } } // // Set up the CTF compensator // qint32 current_comp = raw.info.get_current_comp(); if (current_comp > 0) printf("Current compensation grade : %d\n",current_comp); if (keep_comp) dest_comp = current_comp; if (current_comp != dest_comp) { qDebug() << "This part needs to be debugged"; if(MNE::make_compensator(raw.info, current_comp, dest_comp, raw.comp)) { raw.info.set_current_comp(dest_comp); printf("Appropriate compensator added to change to grade %d.\n",dest_comp); } else { printf("Could not make the compensator\n"); return 0; } } // // Read the events // QFile t_EventFile; MatrixXi events; if (t_sEventName.size() == 0) { p = t_fileRaw.fileName().indexOf(".fif"); if (p > 0) { t_sEventName = t_fileRaw.fileName().replace(p, 4, "-eve.fif"); } else { printf("Raw file name does not end properly\n"); return 0; } // events = mne_read_events(t_sEventName); t_EventFile.setFileName(t_sEventName); MNE::read_events(t_EventFile, events); printf("Events read from %s\n",t_sEventName.toUtf8().constData()); } else { // // Binary file // p = t_fileRaw.fileName().indexOf(".fif"); if (p > 0) { t_EventFile.setFileName(t_sEventName); if(!MNE::read_events(t_EventFile, events)) { printf("Error while read events.\n"); return 0; } printf("Binary event file %s read\n",t_sEventName.toUtf8().constData()); } else { // // Text file // printf("Text file %s is not supported jet.\n",t_sEventName.toUtf8().constData()); // try // events = load(eventname); // catch // error(me,mne_omit_first_line(lasterr)); // end // if size(events,1) < 1 // error(me,'No data in the event file'); // end // // // // Convert time to samples if sample number is negative // // // for p = 1:size(events,1) // if events(p,1) < 0 // events(p,1) = events(p,2)*raw.info.sfreq; // end // end // // // // Select the columns of interest (convert to integers) // // // events = int32(events(:,[1 3 4])); // // // // New format? // // // if events(1,2) == 0 && events(1,3) == 0 // fprintf(1,'The text event file %s is in the new format\n',eventname); // if events(1,1) ~= raw.first_samp // error(me,'This new format event file is not compatible with the raw data'); // end // else // fprintf(1,'The text event file %s is in the old format\n',eventname); // // // // Offset with first sample // // // events(:,1) = events(:,1) + raw.first_samp; // end } } // std::cout << "Events:\n" << events << std::endl; // // Select the desired events // qint32 count = 0; MatrixXi selected = MatrixXi::Zero(1, events.rows()); for (p = 0; p < events.rows(); ++p) { if (events(p,1) == 0 && events(p,2) == eveNum) { selected(0,count) = p; ++count; } } selected.conservativeResize(1, count); if (count > 0) printf("%d matching events found\n",count); else { printf("No desired events found.\n"); return 0; } fiff_int_t event_samp, from, to; MatrixXd timesDummy; MNEEpochDataList data; MNEEpochData* epoch = NULL; MatrixXd times; for (p = 0; p < count; ++p) { // // Read a data segment // event_samp = events(selected(p),0); from = event_samp + tmin*raw.info.sfreq; to = event_samp + floor(tmax*raw.info.sfreq + 0.5); epoch = new MNEEpochData(); if(raw.read_raw_segment(epoch->epoch, timesDummy, from, to, picks)) { if (p == 0) { times.resize(1, to-from+1); for (qint32 i = 0; i < times.cols(); ++i) times(0, i) = ((float)(from-event_samp+i)) / raw.info.sfreq; } epoch->event = eveNum; epoch->tmin = ((float)(from)-(float)(raw.first_samp))/raw.info.sfreq; epoch->tmax = ((float)(to)-(float)(raw.first_samp))/raw.info.sfreq; data.append(MNEEpochData::SPtr(epoch));//List takes ownwership of the pointer - no delete need } else { printf("Can't read the event data segments"); return 0; } } if(data.size() > 0) { printf("Read %d epochs, %d samples each.\n",data.size(),(qint32)data[0]->epoch.cols()); // //DEBUG // std::cout << data[0]->epoch.block(0,0,10,10) << std::endl; // qDebug() << data[0]->epoch.rows() << " x " << data[0]->epoch.cols(); // std::cout << times.block(0,0,1,10) << std::endl; // qDebug() << times.rows() << " x " << times.cols(); } // // Init RAP-MUSIC // RapMusic t_rapMusic(t_clusteredFwd, false, numDipolePairs); // // calculate the average // for(qint32 numAverages = 1; numAverages <= 20; numAverages += 1) { for(qint32 it = 0; it <= 30; ++it) { // // calculate the average // VectorXi vecSel(numAverages); srand (time(NULL)); // initialize random seed for(qint32 i = 0; i < vecSel.size(); ++i) { qint32 val = rand() % data.size(); vecSel(i) = val; } // std::cout << "Select following epochs to average:\n" << vecSel << std::endl; // QString sSelFile = QString("aveInfo_%1_%2.txt").arg(numAverages).arg(it); // std::ofstream selFile(sSelFile.toLatin1().constData()); // if (selFile.is_open()) // { // selFile << vecSel << '\n'; // } FiffEvoked evoked = data.average(raw.info, tmin*raw.info.sfreq, floor(tmax*raw.info.sfreq + 0.5), vecSel); QStringList ch_sel_names = t_Fwd.info.ch_names; FiffEvoked pickedEvoked = evoked.pick_channels(ch_sel_names); //######################################################################################## // RAP MUSIC Source Estimate // if(doMovie) // t_pwlRapMusic.setStcAttr(200,0.5); MNESourceEstimate sourceEstimate = t_rapMusic.calculateInverse(pickedEvoked); // std::cout << "Source Estimate:\n" << sourceEstimate.data << std::endl; // std::cout << "Source Estimate vertices:\n" << sourceEstimate.vertices << std::endl; if(!sourceEstimate.isEmpty()) { QString t_sFileNameStc = sTargetDir+QString("%1_%2_ave_it_%3.stc").arg(sTargetPrefix).arg(numAverages).arg(it); qDebug() << "Write to:" << t_sFileNameStc; QDir dir(sTargetDir); if (!dir.exists()) { dir.mkpath("."); } if(!t_sFileNameStc.isEmpty()) { QFile t_fileClusteredStc(t_sFileNameStc); sourceEstimate.write(t_fileClusteredStc); } } } } return 0;//app.exec(); }
/** * The function main marks the entry point of the program. * By default, main has the storage class extern. * * @param [in] argc (argument count) is an integer that indicates how many arguments were entered on the command line when the program was started. * @param [in] argv (argument vector) is an array of pointers to arrays of character objects. The array objects are null-terminated strings, representing the arguments that were entered on the command line when the program was started. * @return the value that was set to exit() (which is 0 if exit() is called via quit()). */ int main(int argc, char *argv[]) { QGuiApplication app(argc, argv); QGuiApplication::setApplicationName("MNE ROI Cluster Evaluation"); QGuiApplication::setApplicationVersion("Revision 2"); ///////////////////////////////////// #1 CLI Parser ///////////////////////////////////// QCommandLineParser parser; parser.setApplicationDescription("MNE ROI Cluster Evaluation"); parser.addHelpOption(); parser.addVersionOption(); // MEG Source Directory QCommandLineOption srcDirectoryOption(QStringList() << "s" << "meg-source-directory", QCoreApplication::translate("main", "Read MEG (fwd, cov, raw, eve) source files from <directory>."), QCoreApplication::translate("main", "directory"), "./MNE-sample-data/MEG/sample/"); parser.addOption(srcDirectoryOption); // Forward Solution File QCommandLineOption fwdFileOption(QStringList() << "fwd" << "forward-solution", QCoreApplication::translate("main", "The forward solution <file>."), QCoreApplication::translate("main", "file"), "sample_audvis-meg-eeg-oct-6-fwd.fif"); parser.addOption(fwdFileOption); // Fixed Forward Solution File QCommandLineOption xfwdFileOption(QStringList() << "xfwd" << "fixed-forward-solution", QCoreApplication::translate("main", "The fixed forward solution <file>."), QCoreApplication::translate("main", "file"), "sample_audvis-meg-eeg-oct-6-fwd-fixed.fif");//"D:/Data/MEG/mind006/mind006_051209_auditory01_raw-oct-6-fwd-fixed.fif"); parser.addOption(xfwdFileOption); // Covariance File QCommandLineOption covFileOption(QStringList() << "cov" << "covariance", QCoreApplication::translate("main", "The covariance <file>."), QCoreApplication::translate("main", "file"), "sample_audvis-cov.fif"); parser.addOption(covFileOption); // Raw MEG File QCommandLineOption rawFileOption(QStringList() << "raw" << "raw-file", QCoreApplication::translate("main", "The raw MEG data <file>."), QCoreApplication::translate("main", "file"), "sample_audvis_raw.fif"); parser.addOption(rawFileOption); // Event File QCommandLineOption eveFileOption(QStringList() << "eve" << "event-file", QCoreApplication::translate("main", "The event <file>."), QCoreApplication::translate("main", "file"), "sample_audvis_raw-eve.fif"); parser.addOption(eveFileOption); // Event Num QCommandLineOption evenNumOption(QStringList() << "evenum" << "event-number", QCoreApplication::translate("main", "The <event number>."), QCoreApplication::translate("main", "event"), "1");//2;//3;//4; parser.addOption(evenNumOption); // FS Subject Directory QCommandLineOption subjDirectoryOption(QStringList() << "subjdir" << "subject-directory", QCoreApplication::translate("main", "The FreeSurfer <subjects directory>."), QCoreApplication::translate("main", "directory"), "./MNE-sample-data/subjects"); parser.addOption(subjDirectoryOption); // FS Subject QCommandLineOption subjIdOption(QStringList() << "subjid" << "subject-id", QCoreApplication::translate("main", "The FreeSurfer <subject id>."), QCoreApplication::translate("main", "subject id"), "sample"); parser.addOption(subjIdOption); // Target Directory QCommandLineOption targetDirectoryOption(QStringList() << "t" << "target-directory", QCoreApplication::translate("main", "Copy all result files into <directory>."), QCoreApplication::translate("main", "directory")); parser.addOption(targetDirectoryOption); // Target Prefix QCommandLineOption targetPrefixOption(QStringList() << "p" << "prefix", QCoreApplication::translate("main", "The result file's <prefix>."), QCoreApplication::translate("main", "prefix")); parser.addOption(targetPrefixOption); //// Source estimate parameters //// // SNR QCommandLineOption snrOption(QStringList() << "snr" << "signal-to-noise-ratio", QCoreApplication::translate("main", "The <snr> estimation for the given data file."), QCoreApplication::translate("main", "snr"), "1.0");//0.1f;//1.0f;//3.0f; parser.addOption(snrOption); // METHOD QCommandLineOption methodOption(QStringList() << "m" << "method", QCoreApplication::translate("main", "The estimation <method>."), QCoreApplication::translate("main", "method"), "dSPM");//"MNE" | "dSPM" | "sLORETA" parser.addOption(methodOption); // File Name Clustered Inverse Operator QCommandLineOption clustInvFileOption(QStringList() << "icf" << "inverse-clustered-file", QCoreApplication::translate("main", "Target <file> to store clustered inverse operator to."), QCoreApplication::translate("main", "file")); parser.addOption(clustInvFileOption); // File Name of the Source Estimate QCommandLineOption stcFileOption(QStringList() << "stcf" << "stc-file", QCoreApplication::translate("main", "Target <stcfile> to store stc to."), QCoreApplication::translate("main", "file"));//"mind006_051209_auditory01.stc" parser.addOption(stcFileOption); // Process the actual command line arguments given by the user parser.process(app); //////////////////////////////// #2 get parsed values ///////////////////////////////// //Sources QString sFwdName = parser.value(srcDirectoryOption)+parser.value(fwdFileOption); qDebug() << "Forward Solution" << sFwdName; QString sXFwdName = parser.value(srcDirectoryOption)+parser.value(xfwdFileOption); qDebug() << "Fixed Forward Solution" << sXFwdName; // QFile t_fileXFwd(sXFwdName); QString sCovName = parser.value(srcDirectoryOption)+parser.value(covFileOption); qDebug() << "Covariance matrix" << sCovName; QString sRawName = parser.value(srcDirectoryOption)+parser.value(rawFileOption); qDebug() << "Raw data" << sRawName; QString t_sEventName = parser.value(srcDirectoryOption)+parser.value(eveFileOption); qDebug() << "Events" << t_sEventName; qint32 eveNum = (qint32)parser.value(evenNumOption).toInt(); qDebug() << "Event Number" << eveNum; QString t_sSubjectsDir = parser.value(subjDirectoryOption); qDebug() << "Subjects Directory" << t_sSubjectsDir; QString t_sSubject = parser.value(subjIdOption); qDebug() << "Subject" << t_sSubject; AnnotationSet t_annotationSet(t_sSubject, 2, "aparc.a2009s", t_sSubjectsDir); SurfaceSet t_surfSet(t_sSubject, 2, "white", t_sSubjectsDir); //Targets QString sTargetDir = parser.value(targetDirectoryOption); qDebug() << "Target Directory" << sTargetDir; QString sTargetPrefix = parser.value(targetPrefixOption); qDebug() << "Target Prefix" << sTargetPrefix; //// Source estimate parameters //// double snr = parser.value(snrOption).toFloat(); qDebug() << "SNR" << snr; QString method = parser.value(methodOption); qDebug() << "Method" << method; QString t_sFileNameClusteredInv = parser.value(clustInvFileOption); qDebug() << "Store clustered inverse operator to:" << t_sFileNameClusteredInv; QString t_sFileNameStc = parser.value(stcFileOption); qDebug() << "Store stc to:" << t_sFileNameStc; //OLD // QFile t_fileFwd("./MNE-sample-data/MEG/sample/sample_audvis-meg-eeg-oct-6-fwd.fif"); // QFile t_fileCov("./MNE-sample-data/MEG/sample/sample_audvis-cov.fif"); // QFile t_fileRaw("./MNE-sample-data/MEG/sample/sample_audvis_raw.fif"); // QString t_sEventName = "./MNE-sample-data/MEG/sample/sample_audvis_raw-eve.fif"; // AnnotationSet t_annotationSet("sample", 2, "aparc.a2009s", "./MNE-sample-data/subjects"); // SurfaceSet t_surfSet("sample", 2, "white", "./MNE-sample-data/subjects"); // QFile t_fileFwd("D:/Data/MEG/mind006/mind006_051209_auditory01_raw-oct-6p-fwd.fif"); // QFile t_fileCov("D:/Data/MEG/mind006/mind006_051209_auditory01_raw-cov.fif"); // QFile t_fileRaw("D:/Data/MEG/mind006/mind006_051209_auditory01_raw.fif"); // QString t_sEventName = "D:/Data/MEG/mind006/mind006_051209_auditory01_raw-eve.fif"; // AnnotationSet t_annotationSet("mind006", 2, "aparc.a2009s", "D:/Data/subjects"); // SurfaceSet t_surfSet("mind006", 2, "white", "D:/Data/subjects"); ///////////////////////////////////// #3 read data ////////////////////////////////////// qint32 event = eveNum;//1; float tmin = -0.2f; float tmax = 0.4f; bool keep_comp = false; fiff_int_t dest_comp = 0; bool pick_all = true; qint32 k, p; // // Setup for reading the raw data // QFile t_fileRaw(sRawName); FiffRawData raw(t_fileRaw); RowVectorXi picks; if (pick_all) { // // Pick all // picks.resize(raw.info.nchan); for(k = 0; k < raw.info.nchan; ++k) picks(k) = k; // } else { QStringList include; include << "STI 014"; bool want_meg = true; bool want_eeg = false; bool want_stim = false; picks = raw.info.pick_types(want_meg, want_eeg, want_stim, include, raw.info.bads); } QStringList ch_names; for(k = 0; k < picks.cols(); ++k) ch_names << raw.info.ch_names[picks(0,k)]; // // Set up projection // if (raw.info.projs.size() == 0) printf("No projector specified for these data\n"); else { // // Activate the projection items // for (k = 0; k < raw.info.projs.size(); ++k) raw.info.projs[k].active = true; printf("%d projection items activated\n",raw.info.projs.size()); // // Create the projector // fiff_int_t nproj = raw.info.make_projector(raw.proj); if (nproj == 0) { printf("The projection vectors do not apply to these channels\n"); } else { printf("Created an SSP operator (subspace dimension = %d)\n",nproj); } } // // Set up the CTF compensator // qint32 current_comp = raw.info.get_current_comp(); if (current_comp > 0) printf("Current compensation grade : %d\n",current_comp); if (keep_comp) dest_comp = current_comp; if (current_comp != dest_comp) { qDebug() << "This part needs to be debugged"; if(MNE::make_compensator(raw.info, current_comp, dest_comp, raw.comp)) { raw.info.set_current_comp(dest_comp); printf("Appropriate compensator added to change to grade %d.\n",dest_comp); } else { printf("Could not make the compensator\n"); return 0; } } // // Read the events // QFile t_EventFile; MatrixXi events; if (t_sEventName.size() == 0) { p = t_fileRaw.fileName().indexOf(".fif"); if (p > 0) { t_sEventName = t_fileRaw.fileName().replace(p, 4, "-eve.fif"); } else { printf("Raw file name does not end properly\n"); return 0; } t_EventFile.setFileName(t_sEventName); MNE::read_events(t_EventFile, events); printf("Events read from %s\n",t_sEventName.toUtf8().constData()); } else { // // Binary file // p = t_fileRaw.fileName().indexOf(".fif"); if (p > 0) { t_EventFile.setFileName(t_sEventName); if(!MNE::read_events(t_EventFile, events)) { printf("Error while read events.\n"); return 0; } printf("Binary event file %s read\n",t_sEventName.toUtf8().constData()); } else { // // Text file // printf("Text file %s is not supported jet.\n",t_sEventName.toUtf8().constData()); // try // events = load(eventname); // catch // error(me,mne_omit_first_line(lasterr)); // end // if size(events,1) < 1 // error(me,'No data in the event file'); // end // // // // Convert time to samples if sample number is negative // // // for p = 1:size(events,1) // if events(p,1) < 0 // events(p,1) = events(p,2)*raw.info.sfreq; // end // end // // // // Select the columns of interest (convert to integers) // // // events = int32(events(:,[1 3 4])); // // // // New format? // // // if events(1,2) == 0 && events(1,3) == 0 // fprintf(1,'The text event file %s is in the new format\n',eventname); // if events(1,1) ~= raw.first_samp // error(me,'This new format event file is not compatible with the raw data'); // end // else // fprintf(1,'The text event file %s is in the old format\n',eventname); // // // // Offset with first sample // // // events(:,1) = events(:,1) + raw.first_samp; // end } } // // Select the desired events // qint32 count = 0; MatrixXi selected = MatrixXi::Zero(1, events.rows()); // std::cout << "Events:\n" << events << std::endl; for (p = 0; p < events.rows(); ++p) { if (events(p,1) == 0 && events(p,2) == event) { selected(0,count) = p; ++count; } } selected.conservativeResize(1, count); if (count > 0) printf("%d matching events found\n",count); else { printf("No desired events found.\n"); return 0; } fiff_int_t event_samp, from, to; MatrixXd timesDummy; MNEEpochDataList data; MNEEpochData* epoch = NULL; MatrixXd times; for (p = 0; p < count; ++p) { // // Read a data segment // event_samp = events(selected(p),0); from = event_samp + tmin*raw.info.sfreq; to = event_samp + floor(tmax*raw.info.sfreq + 0.5); epoch = new MNEEpochData(); if(raw.read_raw_segment(epoch->epoch, timesDummy, from, to, picks)) { if (p == 0) { times.resize(1, to-from+1); for (qint32 i = 0; i < times.cols(); ++i) times(0, i) = ((float)(from-event_samp+i)) / raw.info.sfreq; } epoch->event = event; epoch->tmin = ((float)(from)-(float)(raw.first_samp))/raw.info.sfreq; epoch->tmax = ((float)(to)-(float)(raw.first_samp))/raw.info.sfreq; data.append(MNEEpochData::SPtr(epoch));//List takes ownwership of the pointer - no delete need } else { printf("Can't read the event data segments"); return 0; } } //DEBUG Output if(data.size() > 0) { printf("Sampling frequency, %f\n", raw.info.sfreq); printf("Read %d epochs, %d samples each.\n",data.size(),(qint32)data[0]->epoch.cols()); // //DEBUG // std::cout << data[0]->epoch.block(0,0,10,10) << std::endl; // qDebug() << data[0]->epoch.rows() << " x " << data[0]->epoch.cols(); // std::cout << times.block(0,0,1,10) << std::endl; // qDebug() << times.rows() << " x " << times.cols(); } /////////////////////////////////// #4 process data ///////////////////////////////////// // // calculate the average // FiffEvoked evoked = data.average(raw.info, tmin*raw.info.sfreq, floor(tmax*raw.info.sfreq + 0.5)); //######################################################################################## // Source Estimate double lambda2 = 1.0 / pow(snr, 2); qDebug() << "Start calculation with: SNR" << snr << "; Lambda" << lambda2 << "; Method" << method << "; stc:" << t_sFileNameStc; // // Load data // fiff_int_t setno = 1; // QPair<QVariant, QVariant> baseline(QVariant(), 0); // FiffEvoked evoked(t_fileEvoked, setno, baseline); // if(evoked.isEmpty()) // return 1; QFile t_fileFwd(sFwdName); MNEForwardSolution t_Fwd(t_fileFwd); if(t_Fwd.isEmpty()) return 1; QFile t_fileFwdFixed(sXFwdName); MNEForwardSolution t_FwdFixed(t_fileFwdFixed); if(t_FwdFixed.isEmpty()) return 1; QFile t_fileCov(sCovName); FiffCov noise_cov(t_fileCov); // regularize noise covariance noise_cov = noise_cov.regularize(evoked.info, 0.05, 0.05, 0.1, true); qDebug() << ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 1. t_Fwd <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"; QString sG = sTargetDir + sTargetPrefix + QString("G.txt"); std::ofstream ofs_G(sG.toUtf8().constData(), std::ofstream::out); if (ofs_G.is_open()) { printf("writing to %s\n",sG.toUtf8().constData()); ofs_G << t_Fwd.sol->data << '\n'; } else printf("Not writing to %s\n",sG.toUtf8().constData()); ofs_G.close(); // qDebug() << ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 1. t_Fwd_whitened <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"; // // // // Whiten L1 gain matrix // // // MatrixXd t_Fwd_whitened(0,0); // // // // Whiten gain matrix before clustering -> cause diffenerent units Magnetometer, Gradiometer and EEG // // // if(!noise_cov.isEmpty() && !evoked.info.isEmpty()) // { // FiffInfo p_outFwdInfo; // FiffCov p_outNoiseCov; // MatrixXd p_outWhitener; // qint32 p_outNumNonZero; // //do whitening with noise cov // t_Fwd.prepare_forward(evoked.info, noise_cov, false, p_outFwdInfo, t_Fwd_whitened, p_outNoiseCov, p_outWhitener, p_outNumNonZero); // printf("\tWhitening the forward solution.\n"); // t_Fwd_whitened = p_outWhitener*t_Fwd_whitened; // } // QString sG_Whitened = sTargetDir + sTargetPrefix + QString("G_whitened.txt"); // std::ofstream ofs_G_Whitened(sG_Whitened.toUtf8().constData(), std::ofstream::out);//"G_whitened.txt", std::ofstream::out); // if (ofs_G_Whitened.is_open()) // { // printf("writing to %s\n",sG_Whitened.toUtf8().constData()); // ofs_G_Whitened << t_Fwd_whitened << '\n'; // } // else // printf("Not writing to %s\n",sG_Whitened.toUtf8().constData()); // ofs_G_Whitened.close(); // //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // // Cluster forward solution; // MatrixXd D_L1; std::cout << "t_Fwd " << t_Fwd.sol->data.rows() << " x " << t_Fwd.sol->data.cols() << std::endl; MNEForwardSolution t_clusteredFwd_L1 = t_Fwd.cluster_forward_solution(t_annotationSet, 20, D_L1, noise_cov, evoked.info, "cityblock"); QString sCILHL1 = sTargetDir + sTargetPrefix + QString("ClusterInfoLH_L1.txt"); t_clusteredFwd_L1.src[0].cluster_info.write(sCILHL1); QString sCIRHL1 = sTargetDir + sTargetPrefix + QString("ClusterInfoRH_L1.txt"); t_clusteredFwd_L1.src[1].cluster_info.write(sCIRHL1); qDebug() << ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2. t_clusteredFwd_L1 <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"; QString sG_L1 = sTargetDir + sTargetPrefix + QString("G_L1.txt"); std::ofstream ofs_G_L1(sG_L1.toUtf8().constData(), std::ofstream::out); if (ofs_G_L1.is_open()) { printf("writing to %s\n",sG_L1.toUtf8().constData()); ofs_G_L1 << t_clusteredFwd_L1.sol->data << '\n'; } else printf("Not writing to %s\n",sG_L1.toUtf8().constData()); ofs_G_L1.close(); // qDebug() << ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2. t_clusteredFwd_L1_whitened <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"; // // // // Whiten L1 gain matrix // // // MatrixXd t_clusteredFwd_L1_whitened(0,0); // // // // Whiten gain matrix before clustering -> cause diffenerent units Magnetometer, Gradiometer and EEG // // // if(!noise_cov.isEmpty() && !evoked.info.isEmpty()) // { // FiffInfo p_outFwdInfo; // FiffCov p_outNoiseCov; // MatrixXd p_outWhitener; // qint32 p_outNumNonZero; // //do whitening with noise cov // t_clusteredFwd_L1.prepare_forward(evoked.info, noise_cov, false, p_outFwdInfo, t_clusteredFwd_L1_whitened, p_outNoiseCov, p_outWhitener, p_outNumNonZero); // printf("\tWhitening the forward solution.\n"); // t_clusteredFwd_L1_whitened = p_outWhitener*t_clusteredFwd_L1_whitened; // } // QString sG_L1_Whitened = sTargetDir + sTargetPrefix + QString("G_L1_whitened.txt"); // std::ofstream ofs_G_L1_Whitened(sG_L1_Whitened.toUtf8().constData(), std::ofstream::out);//"G_L1_whitened.txt", std::ofstream::out); // if (ofs_G_L1_Whitened.is_open()) // { // printf("writing to %s\n",sG_L1_Whitened.toUtf8().constData()); // ofs_G_L1_Whitened << t_clusteredFwd_L1_whitened << '\n'; // } // else // printf("Not writing to %s\n",sG_L1_Whitened.toUtf8().constData()); // ofs_G_L1_Whitened.close(); // //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// std::cout << "D_L1 " << D_L1.rows() << " x " << D_L1.cols() << std::endl; std::cout << "t_clusteredFwd_L1 " << t_clusteredFwd_L1.sol->data.rows() << " x " << t_clusteredFwd_L1.sol->data.cols() << std::endl; MatrixXd D_L2; MNEForwardSolution t_clusteredFwd_L2 = t_Fwd.cluster_forward_solution(t_annotationSet, 20, D_L2, noise_cov, evoked.info, "sqeuclidean"); QString sCILH_L2 = sTargetDir + sTargetPrefix + QString("ClusterInfoLH_L2.txt"); t_clusteredFwd_L2.src[0].cluster_info.write(sCILH_L2); QString sCIRH_L2 = sTargetDir + sTargetPrefix + QString("ClusterInfoRH_L2.txt"); t_clusteredFwd_L2.src[1].cluster_info.write(sCIRH_L2); std::cout << "D_L2 " << D_L2.rows() << " x " << D_L2.cols() << std::endl; std::cout << "t_clusteredFwd_L2 " << t_clusteredFwd_L2.sol->data.rows() << " x " << t_clusteredFwd_L2.sol->data.cols() << std::endl; qDebug() << ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 3. t_clusteredFwd_L2 <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"; QString sG_L2 = sTargetDir + sTargetPrefix + QString("G_L2.txt"); std::ofstream ofs_G_L2(sG_L2.toUtf8().constData(), std::ofstream::out); if (ofs_G_L2.is_open()) { printf("writing to %s\n",sG_L2.toUtf8().constData()); ofs_G_L2 << t_clusteredFwd_L2.sol->data << '\n'; } else printf("Not writing to %s\n",sG_L2.toUtf8().constData()); ofs_G_L2.close(); // qDebug() << ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 3. t_clusteredFwd_L2_whitened <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"; // // // // Whiten L1 gain matrix // // // MatrixXd t_clusteredFwd_L2_whitened(0,0); // // // // Whiten gain matrix before clustering -> cause diffenerent units Magnetometer, Gradiometer and EEG // // // if(!noise_cov.isEmpty() && !evoked.info.isEmpty()) // { // FiffInfo p_outFwdInfo; // FiffCov p_outNoiseCov; // MatrixXd p_outWhitener; // qint32 p_outNumNonZero; // //do whitening with noise cov // t_clusteredFwd_L2.prepare_forward(evoked.info, noise_cov, false, p_outFwdInfo, t_clusteredFwd_L2_whitened, p_outNoiseCov, p_outWhitener, p_outNumNonZero); // printf("\tWhitening the forward solution.\n"); // t_clusteredFwd_L2_whitened = p_outWhitener*t_clusteredFwd_L2_whitened; // } // QString sG_L2_Whitened = sTargetDir + sTargetPrefix + QString("G_L2_whitened.txt"); // std::ofstream ofs_G_L2_Whitened(sG_L2_Whitened.toUtf8().constData(), std::ofstream::out);//"G_L2_whitened.txt", std::ofstream::out); // if (ofs_G_L2_Whitened.is_open()) // { // printf("writing to %s\n",sG_L2_Whitened.toUtf8().constData()); // ofs_G_L2_Whitened << t_clusteredFwd_L2_whitened << '\n'; // } // else // printf("Not writing to %s\n",sG_L2_Whitened.toUtf8().constData()); // ofs_G_L2_Whitened.close(); return CommandLineOk; // //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // // make an inverse operators // FiffInfo info = evoked.info; QFile t_fileSelectedFwd(sFwdName); // QFile t_fileFwd("D:/Data/MEG/mind006/mind006_051209_auditory01_raw-oct-6p-fwd.fif"); // QFile t_fileCov("D:/Data/MEG/mind006/mind006_051209_auditory01_raw-cov.fif"); // QFile t_fileRaw("D:/Data/MEG/mind006/mind006_051209_auditory01_raw.fif"); // QString t_sEventName = "D:/Data/MEG/mind006/mind006_051209_auditory01_raw-eve.fif"; // AnnotationSet t_annotationSet("mind006", 2, "aparc.a2009s", "D:/Data/subjects"); // SurfaceSet t_surfSet("mind006", 2, "white", "D:/Data/subjects"); MNEForwardSolution t_selectedRawFwd(t_fileSelectedFwd); if(t_selectedRawFwd.isEmpty()) return 1; MatrixXd D_selected; MNEForwardSolution t_selectedFwd = t_selectedRawFwd.reduce_forward_solution(t_clusteredFwd_L2.isFixedOrient() ? t_clusteredFwd_L2.sol->data.cols() : t_clusteredFwd_L2.sol->data.cols()/3, D_selected); // qDebug() << "#### t_selectedFwd" << t_selectedFwd.sol->data.rows() << "x" << t_selectedFwd.sol->data.cols(); MNEInverseOperator inverse_operator_selected(info, t_selectedFwd, noise_cov, 0.2f, 0.8f); MNEInverseOperator inverse_operator_clustered_L1(info, t_clusteredFwd_L1, noise_cov, 0.2f, 0.8f); MNEInverseOperator inverse_operator_clustered_L2(info, t_clusteredFwd_L2, noise_cov, 0.2f, 0.8f); MNEInverseOperator inverse_operator(info, t_Fwd, noise_cov, 0.2f, 0.8f); // // // // save clustered inverse // // // if(!t_sFileNameClusteredInv.isEmpty()) // { // QFile t_fileClusteredInverse(t_sFileNameClusteredInv); // inverse_operator_clustered_L2.write(t_fileClusteredInverse); // } // // Compute inverse solution // MinimumNorm minimumNormSelected(inverse_operator_selected, lambda2, method); MinimumNorm minimumNormClustered_L1(inverse_operator_clustered_L1, lambda2, method); MinimumNorm minimumNormClustered_L2(inverse_operator_clustered_L2, lambda2, method); MinimumNorm minimumNorm(inverse_operator, lambda2, method); //#ifdef BENCHMARK // // // // Set up the inverse according to the parameters // // // minimumNormClustered.doInverseSetup(vecSel.size(),false); // MNESourceEstimate sourceEstimate; // QList<qint64> qVecElapsedTime; // for(qint32 i = 0; i < 100; ++i) // { // //Benchmark time // QElapsedTimer timer; // timer.start(); // sourceEstimate = minimumNormClustered.calculateInverse(evoked.data, evoked.times(0), evoked.times(1)-evoked.times(0)); // qVecElapsedTime.append(timer.elapsed()); // } // double meanTime = 0.0; // qint32 offset = 19; // qint32 c = 0; // for(qint32 i = offset; i < qVecElapsedTime.size(); ++i) // { // meanTime += qVecElapsedTime[i]; // ++c; // } // meanTime /= (double)c; // double varTime = 0; // for(qint32 i = offset; i < qVecElapsedTime.size(); ++i) // varTime += pow(qVecElapsedTime[i] - meanTime,2); // varTime /= (double)c - 1.0f; // varTime = sqrt(varTime); // qDebug() << "MNE calculation took" << meanTime << "+-" << varTime << "ms in average"; //#else // MNESourceEstimate sourceEstimateSelected = minimumNormSelected.calculateInverse(evoked); // MNESourceEstimate sourceEstimateClustered_L1 = minimumNormClustered_L1.calculateInverse(evoked); // MNESourceEstimate sourceEstimateClustered_L2 = minimumNormClustered_L2.calculateInverse(evoked); // MNESourceEstimate sourceEstimate = minimumNorm.calculateInverse(evoked); //#endif // ////////////////////////////////// original // // #### R calculation #### // printf("R original calculation\n"); // MatrixXd M_orig = minimumNorm.getKernel(); // MatrixXd R_orig = M_orig * t_FwdFixed.sol->data; // QString sROrig = sTargetDir + sTargetPrefix + QString("R_orig.txt"); // std::ofstream ofs_R_orig(sROrig.toUtf8().constData(), std::ofstream::out);//, std::ofstream::out); // if (ofs_R_orig.is_open()) // { // printf("writing to %s\n", sROrig.toUtf8().constData()); // ofs_R_orig << R_orig << '\n'; // } // else // printf("Not writing to %s\n", sROrig.toUtf8().constData()); // ofs_R_orig.close(); // R_orig.resize(0,0); // //ToDo:just original // return CommandLineOk; ////////////////////////////////// L1 calculations MatrixXd D_MT_L1; MatrixXd MT_clustered_L1 = minimumNorm.getPreparedInverseOperator().cluster_kernel(t_annotationSet, 20, D_MT_L1, "cityblock"); // #### R calculation #### //// Option II_L1 //Cluster Inverse operator MatrixXd M_L1 = D_L1.transpose() * minimumNorm.getKernel(); MatrixXd R_L1 = M_L1 * t_FwdFixed.sol->data; // QString sTargetDir = parser.value(targetDirectoryOption); // qDebug() << "Target Directory" << sTargetDir; // QString sTargetPrefix = parser.value(targetPrefixOption); // qDebug() << "Target Prefix" << sTargetPrefix; QString sR_L1 = sTargetDir + sTargetPrefix + QString("R_L1.txt"); std::ofstream ofs_R_L1(sR_L1.toUtf8().constData(), std::ofstream::out);//"R_L1.txt", std::ofstream::out); if (ofs_R_L1.is_open()) { printf("writing to %s\n",sR_L1.toUtf8().constData()); ofs_R_L1 << R_L1 << '\n'; } else printf("Not writing to %s\n",sR_L1.toUtf8().constData()); ofs_R_L1.close(); M_L1.resize(0,0); R_L1.resize(0,0); //// Option I_L1 printf("[3]\n"); MatrixXd M_clusterd_L1 = minimumNormClustered_L1.getKernel(); printf("[4]\n"); MatrixXd R_clustered_L1 = M_clusterd_L1 * t_FwdFixed.sol->data; QString sRClustered_L1 = sTargetDir + sTargetPrefix + QString("R_clustered_L1.txt"); std::ofstream ofs_R_clustered_L1(sRClustered_L1.toUtf8().constData(), std::ofstream::out);//, std::ofstream::out); if (ofs_R_clustered_L1.is_open()) { printf("writing to %s\n", sRClustered_L1.toUtf8().constData()); ofs_R_clustered_L1 << R_clustered_L1 << '\n'; } else printf("Not writing to %s\n", sRClustered_L1.toUtf8().constData()); ofs_R_clustered_L1.close(); M_clusterd_L1.resize(0,0); R_clustered_L1.resize(0,0); //Cluster Operator D_L1 QString sD_L1 = sTargetDir + sTargetPrefix + QString("D_L1.txt"); std::ofstream ofs_D_L1(sD_L1.toUtf8().constData(), std::ofstream::out);//"D_L1.txt", std::ofstream::out); if (ofs_D_L1.is_open()) { printf("writing to %s\n",sD_L1.toUtf8().constData()); ofs_D_L1 << D_L1 << '\n'; } else printf("Not writing to %s\n",sD_L1.toUtf8().constData()); ofs_D_L1.close(); //// Option III_L1 printf("[5]\n"); MatrixXd R_MT_clustered_L1 = MT_clustered_L1.transpose() * t_FwdFixed.sol->data; QString sRMTClust_L1 = sTargetDir + sTargetPrefix + QString("R_MT_clustered_L1.txt"); std::ofstream ofs_R_MT_clustered_L1(sRMTClust_L1.toUtf8().constData(), std::ofstream::out); if (ofs_R_MT_clustered_L1.is_open()) { printf("writing to %s\n",sRMTClust_L1.toUtf8().constData()); ofs_R_MT_clustered_L1 << R_MT_clustered_L1 << '\n'; } else printf("Not writing to %s\n",sRMTClust_L1.toUtf8().constData()); ofs_R_MT_clustered_L1.close(); R_MT_clustered_L1.resize(0,0); //Cluster Operator D QString sDMT_L1 = sTargetDir + sTargetPrefix + QString("D_MT_L1.txt"); std::ofstream ofs_D_MT_L1(sDMT_L1.toUtf8().constData(), std::ofstream::out); if (ofs_D_MT_L1.is_open()) { printf("writing to %s\n",sDMT_L1.toUtf8().constData()); ofs_D_MT_L1 << D_MT_L1 << '\n'; } else printf("Not writing to %s\n",sDMT_L1.toUtf8().constData()); ofs_D_MT_L1.close(); ////////////////////////////////// L2 calculations MatrixXd D_MT_L2; MatrixXd MT_clustered_L2 = minimumNorm.getPreparedInverseOperator().cluster_kernel(t_annotationSet, 20, D_MT_L2, "sqeuclidean"); // #### R calculation #### //// Option II_L2 MatrixXd M_L2 = D_L2.transpose() * minimumNorm.getKernel(); MatrixXd R_L2 = M_L2 * t_FwdFixed.sol->data; // QString sTargetDir = parser.value(targetDirectoryOption); // qDebug() << "Target Directory" << sTargetDir; // QString sTargetPrefix = parser.value(targetPrefixOption); // qDebug() << "Target Prefix" << sTargetPrefix; QString sR_L2 = sTargetDir + sTargetPrefix + QString("R_L2.txt"); std::ofstream ofs_R_L2(sR_L2.toUtf8().constData(), std::ofstream::out);//"R_L2.txt", std::ofstream::out); if (ofs_R_L2.is_open()) { printf("writing to %s\n",sR_L2.toUtf8().constData()); ofs_R_L2 << R_L2 << '\n'; } else printf("Not writing to %s\n",sR_L2.toUtf8().constData()); ofs_R_L2.close(); M_L2.resize(0,0); R_L2.resize(0,0); //// Option I_L2 printf("[3]\n"); MatrixXd M_clusterd_L2 = minimumNormClustered_L2.getKernel(); printf("[4]\n"); MatrixXd R_clustered_L2 = M_clusterd_L2 * t_FwdFixed.sol->data; QString sRClustered_L2 = sTargetDir + sTargetPrefix + QString("R_clustered_L2.txt"); std::ofstream ofs_R_clustered_L2(sRClustered_L2.toUtf8().constData(), std::ofstream::out);//, std::ofstream::out); if (ofs_R_clustered_L2.is_open()) { printf("writing to %s\n", sRClustered_L2.toUtf8().constData()); ofs_R_clustered_L2 << R_clustered_L2 << '\n'; } else printf("Not writing to %s\n", sRClustered_L2.toUtf8().constData()); ofs_R_clustered_L2.close(); M_clusterd_L2.resize(0,0); R_clustered_L2.resize(0,0); //Cluster Operator D_L2 QString sD_L2 = sTargetDir + sTargetPrefix + QString("D_L2.txt"); std::ofstream ofs_D_L2(sD_L2.toUtf8().constData(), std::ofstream::out);//"D_L2.txt", std::ofstream::out); if (ofs_D_L2.is_open()) { printf("writing to %s\n",sD_L2.toUtf8().constData()); ofs_D_L2 << D_L2 << '\n'; } else printf("Not writing to %s\n",sD_L2.toUtf8().constData()); ofs_D_L2.close(); //// Option III_L2 printf("[5]\n"); MatrixXd R_MT_clustered_L2 = MT_clustered_L2.transpose() * t_FwdFixed.sol->data; QString sRMTClust_L2 = sTargetDir + sTargetPrefix + QString("R_MT_clustered_L2.txt"); std::ofstream ofs_R_MT_clustered_L2(sRMTClust_L2.toUtf8().constData(), std::ofstream::out); if (ofs_R_MT_clustered_L2.is_open()) { printf("writing to %s\n",sRMTClust_L2.toUtf8().constData()); ofs_R_MT_clustered_L2 << R_MT_clustered_L2 << '\n'; } else printf("Not writing to %s\n",sRMTClust_L2.toUtf8().constData()); ofs_R_MT_clustered_L2.close(); R_MT_clustered_L2.resize(0,0); //Cluster Operator D QString sDMT_L2 = sTargetDir + sTargetPrefix + QString("D_MT_L2.txt"); std::ofstream ofs_D_MT_L2(sDMT_L2.toUtf8().constData(), std::ofstream::out); if (ofs_D_MT_L2.is_open()) { printf("writing to %s\n",sDMT_L2.toUtf8().constData()); ofs_D_MT_L2 << D_MT_L2 << '\n'; } else printf("Not writing to %s\n",sDMT_L2.toUtf8().constData()); ofs_D_MT_L2.close(); ////////////////////////////////// Selection calculation //option d) MatrixXd M_selected = minimumNormSelected.getKernel(); // qDebug() << "M_selected: " << M_selected.rows() << "x" << M_selected.cols(); printf("[7]\n"); MatrixXd R_selected= M_selected * t_FwdFixed.sol->data; QString sRselected = sTargetDir + sTargetPrefix + QString("R_selected.txt"); std::ofstream ofs_R_selected(sRselected.toUtf8().constData(), std::ofstream::out);//"R_selected.txt", std::ofstream::out); if (ofs_R_selected.is_open()) { printf("writing to %s\n",sRselected.toUtf8().constData()); ofs_R_selected << R_selected << '\n'; } else printf("Not writing to %s\n",sRselected.toUtf8().constData()); ofs_R_selected.close(); R_selected.resize(0,0); //Cluster Operator D QString sDselected = sTargetDir + sTargetPrefix + QString("D_selected.txt"); std::ofstream ofs_D_selected(sDselected.toUtf8().constData(), std::ofstream::out);//"D_selected.txt", std::ofstream::out); if (ofs_D_selected.is_open()) { printf("writing to %s\n",sDselected.toUtf8().constData()); ofs_D_selected << D_selected << '\n'; } else printf("Not writing to %s\n",sDselected.toUtf8().constData()); ofs_D_selected.close(); // #### R calculation end #### /////////////////////////////////// #5 METHOD I ///////////////////////////////////// // I) M_D -> I_L1 // { // qDebug() << "METHOD I_L1"; // } /////////////////////////////////// #6 METHOD II ///////////////////////////////////// // II) D_G^T M -> II_L1 // { // qDebug() << "METHOD II_L1"; // } /////////////////////////////////// #7 METHOD III ///////////////////////////////////// // III) D^T_{M^T} M -> III_L1 // { // qDebug() << "METHOD III_L1"; // } /////////////////////////////////// #8 METHOD IV ///////////////////////////////////// // IV) M_D -> I_L2 // { // qDebug() << "METHOD I_L2"; // } /////////////////////////////////// #9 METHOD V ///////////////////////////////////// // V) D^T_G M -> II_L2 // { // qDebug() << "METHOD II_L2"; // } /////////////////////////////////// #10 METHOD VI ///////////////////////////////////// // VI) D^T_{M^T} M -> III_L2 // { // qDebug() << "METHOD III_L2"; // } /////////////////////////////////// #11 METHOD VII ///////////////////////////////////// // VII) M -> IV // { // qDebug() << "METHOD IV"; // } // //Condition Numbers Attention - Condition only with fixed orientation!!!!!!!!! // VectorXd s; // double t_dConditionNumber = MNEMath::getConditionNumber(t_Fwd.sol->data, s); // std::cout << "Condition Number:\n" << t_dConditionNumber << std::endl; // // // QString sKappa = sTargetDir + sTargetPrefix + QString("Kappa.txt"); // std::ofstream ofs_Kappa(sKappa.toUtf8().constData(), std::ofstream::out); // if (ofs_Kappa.is_open()) // { // printf("writing to %s\n",sKappa.toUtf8().constData()); // ofs_Kappa << t_dConditionNumber << '\n'; // } // else // printf("Not writing to %s\n",sKappa.toUtf8().constData()); // ofs_Kappa.close(); // // s // QString sS = sTargetDir + sTargetPrefix + QString("S.txt"); // std::ofstream ofs_sS(sS.toUtf8().constData(), std::ofstream::out); // if (ofs_sS.is_open()) // { // printf("writing to %s\n",sS.toUtf8().constData()); // ofs_sS << s << '\n'; // } // else // printf("Not writing to %s\n",sS.toUtf8().constData()); // ofs_sS.close(); // double t_dConditionNumberClustered_L1 = MNEMath::getConditionNumber(t_clusteredFwd_L1.sol->data, s); // std::cout << "Clustered L1 Condition Number:\n" << t_dConditionNumberClustered_L1 << std::endl; // // // QString sKappaL1 = sTargetDir + sTargetPrefix + QString("Kappa_L1.txt"); // std::ofstream ofs_KappaL1(sKappaL1.toUtf8().constData(), std::ofstream::out); // if (ofs_KappaL1.is_open()) // { // printf("writing to %s\n",sKappaL1.toUtf8().constData()); // ofs_KappaL1 << t_dConditionNumberClustered_L1 << '\n'; // } // else // printf("Not writing to %s\n",sKappaL1.toUtf8().constData()); // ofs_KappaL1.close(); // // s // QString sSL1 = sTargetDir + sTargetPrefix + QString("S_L1.txt"); // std::ofstream ofs_SL1(sSL1.toUtf8().constData(), std::ofstream::out); // if (ofs_SL1.is_open()) // { // printf("writing to %s\n",sSL1.toUtf8().constData()); // ofs_SL1 << s << '\n'; // } // else // printf("Not writing to %s\n",sSL1.toUtf8().constData()); // ofs_SL1.close(); // double t_dConditionNumberClustered_L2 = MNEMath::getConditionNumber(t_clusteredFwd_L2.sol->data, s); // std::cout << "Clustered L2 Condition Number:\n" << t_dConditionNumberClustered_L2 << std::endl; // // Kappa // QString sKappaL2 = sTargetDir + sTargetPrefix + QString("Kappa_L2.txt"); // std::ofstream ofs_KappaL2(sKappaL2.toUtf8().constData(), std::ofstream::out); // if (ofs_KappaL2.is_open()) // { // printf("writing to %s\n",sKappaL2.toUtf8().constData()); // ofs_KappaL2 << t_dConditionNumberClustered_L2 << '\n'; // } // else // printf("Not writing to %s\n",sKappaL2.toUtf8().constData()); // ofs_KappaL2.close(); // // s // QString sSL2 = sTargetDir + sTargetPrefix + QString("S_L2.txt"); // std::ofstream ofs_SL2(sSL2.toUtf8().constData(), std::ofstream::out); // if (ofs_SL2.is_open()) // { // printf("writing to %s\n",sSL2.toUtf8().constData()); // ofs_SL2 << s << '\n'; // } // else // printf("Not writing to %s\n",sSL2.toUtf8().constData()); // ofs_SL2.close(); // double t_dConditionNumberMags = MNEMath::getConditionNumber(mags, s); // double t_dConditionNumberMagsClustered = MNEMath::getConditionNumber(magsClustered, s); // std::cout << "Condition Number Magnetometers:\n" << t_dConditionNumberMags << std::endl; // std::cout << "Clustered Condition Number Magnetometers:\n" << t_dConditionNumberMagsClustered << std::endl; // double t_dConditionNumberGrads = MNEMath::getConditionNumber(grads, s); // double t_dConditionNumberGradsClustered = MNEMath::getConditionNumber(gradsClustered, s); // std::cout << "Condition Number Gradiometers:\n" << t_dConditionNumberGrads << std::endl; // std::cout << "Clustered Condition Number Gradiometers:\n" << t_dConditionNumberGradsClustered << std::endl; return CommandLineOk; }
RcppExport SEXP BMEclustering(SEXP mat, SEXP moda, SEXP nb_cluster, SEXP partition_initiale, SEXP nb_init,SEXP stop_criterion){ srand(time(0)); MatrixXi data=convertMatrix<MatrixXi,NumericMatrix>(mat); VectorXi modalite=convertvector<VectorXi,NumericVector>(moda); datafile dataF(data,modalite); NumericMatrix red=convertMatrix<NumericMatrix,MatrixXi>(dataF.Get_mat_datafile()); VectorXi partition_vbles=convertvector<VectorXi,NumericVector>(partition_initiale); MatrixXi m; int g=as<int>(nb_cluster); //int borne=as<int>(nbiter); m.resize(g,partition_vbles.rows()); for (int k=0;k<g;k++){ m.row(k)=partition_vbles; } NumericMatrix test=convertMatrix<NumericMatrix,MatrixXi>(m); int nbinit=as<int>(nb_init); int borne=as<int>(stop_criterion); MCMCAlgo ref(dataF,m,m.rows(),2,1,2,6,borne); for (int ini=0;ini<nbinit;ini++){ MCMCAlgo test(dataF,m,m.rows(),2,1,2,6,borne); if (test.Get_best_bic()>ref.Get_best_bic()){ ref=test; } } //sauvegarde des caractéristiques du modèle NumericMatrix model=convertMatrix<NumericMatrix,MatrixXi>(ref.Get_best_omega()); double bic=ref.Get_best_bic(); double likelihood=ref.Get_best_like(); NumericMatrix probapost=convertMatrix<NumericMatrix,MatrixXd>(ref.Sauv_probapost()); NumericVector localise=convertvector<NumericVector,VectorXi>(dataF.Get_localise()); vector< vector< NumericVector > > tau; vector< vector< vector< NumericVector > > > delta; vector< vector< vector< NumericVector > > > alpha; vector< vector< double > > rho; tau.resize(g); rho.resize(g); delta.resize(g); alpha.resize(g); for (int k=0;k<g;k++){ tau[k].resize(ref.Get_best_omega().row(k).maxCoeff()+1); rho[k].resize(ref.Get_best_omega().row(k).maxCoeff()+1); delta[k].resize(ref.Get_best_omega().row(k).maxCoeff()+1); alpha[k].resize(ref.Get_best_omega().row(k).maxCoeff()+1); for (int b=0;b<=ref.Get_best_omega().row(k).maxCoeff();b++){ //for (int b=0;b<2;b++){ //vectblock[k][b]=ref.Get_rho(k,b); //vector < VectorXd > passe=ref.Get_alpha(k,b); if ((ref.Get_best_omega().row(k).array()==b).count()>0){ vector<VectorXd> passe=ref.Get_alpha(k,b); alpha[k][b].resize((ref.Get_best_omega().row(k).array()==b).count()); for (int loc=0;loc<((ref.Get_best_omega().row(k).array()==b).count());loc++){ alpha[k][b][loc]=convertvector<NumericVector,VectorXd>(passe[loc]); } } if ((ref.Get_best_omega().row(k).array()==b).count()>1){ MatrixXi passe=ref.Get_delta(k,b); delta[k][b].resize(passe.cols()); tau[k][b]=convertvector<NumericVector,VectorXd>(ref.Get_tau(k,b)); for (int loc=0;loc<passe.cols();loc++){ delta[k][b][loc]=convertvector<NumericVector,VectorXi>(passe.col(loc)); } //delta[k][b]=convertMatrix<NumericMatrix,MatrixXi>(ref.Get_delta(k,b)); rho[k][b]=ref.Get_rho(k,b); } } } List param=List::create(Rcpp::Named("tau")=tau,Rcpp::Named("rho")=rho,Rcpp::Named("delta")=delta,Rcpp::Named("alpha")=alpha,Rcpp::Named("proportions")=convertvector<NumericVector,VectorXd>(ref.Get_propor())); List desc_model = List::create(Rcpp::Named("sigma")=model,Rcpp::Named("bic")=bic,Rcpp::Named("likelihood")=likelihood,Rcpp::Named("probapost")=probapost,Rcpp::Named("partition")=localise,Rcpp::Named("nbcluster")=nb_cluster,Rcpp::Named("parameters")=param); return desc_model; }
void drwnNNGraphImageData::setLabels(const MatrixXi& labels) { DRWN_ASSERT(((size_t)labels.rows() == height()) && ((size_t)labels.cols() == width())); _labels = labels; }
void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { using namespace std; using namespace Eigen; using namespace igl; using namespace igl::matlab; igl::matlab::MexStream mout; std::streambuf *outbuf = cout.rdbuf(&mout); //mexPrintf("Compiled at %s on %s\n",__TIME__,__DATE__); MatrixXd P,V,C,N; MatrixXi F; VectorXi I; VectorXd S; SignedDistanceType type; parse_rhs(nrhs,prhs,P,V,F,type); if(F.rows() > 0) { switch(V.cols()) { case 2: { // Persistent data not supported for 2D signed_distance(P,V,F,type,S,I,C,N); break; } case 3: { if(g_sign_type != type || g_V != V || g_F != F) { g_V = V; g_F = F; g_sign_type = type; // Clear the tree g_tree.deinit(); // Prepare distance computation g_tree.init(V,F); switch(type) { default: assert(false && "Unknown SignedDistanceType"); case SIGNED_DISTANCE_TYPE_DEFAULT: case SIGNED_DISTANCE_TYPE_WINDING_NUMBER: g_hier.set_mesh(V,F); g_hier.grow(); break; case SIGNED_DISTANCE_TYPE_PSEUDONORMAL: // "Signed Distance Computation Using the Angle Weighted Pseudonormal" // [Bærentzen & Aanæs 2005] per_face_normals(V,F,g_FN); per_vertex_normals(V,F,PER_VERTEX_NORMALS_WEIGHTING_TYPE_ANGLE, g_FN,g_VN); per_edge_normals( V,F,PER_EDGE_NORMALS_WEIGHTING_TYPE_UNIFORM, g_FN,g_EN,g_E,g_EMAP); break; } } N.resize(P.rows(),3); S.resize(P.rows(),1); I.resize(P.rows(),1); C.resize(P.rows(),3); //for(int p = 0;p<P.rows();p++) igl::parallel_for(P.rows(),[&](const int p) { const Eigen::RowVector3d q(P(p,0),P(p,1),P(p,2)); double s,sqrd; Eigen::RowVector3d c; int i; switch(type) { default: assert(false && "Unknown SignedDistanceType"); case SIGNED_DISTANCE_TYPE_DEFAULT: case SIGNED_DISTANCE_TYPE_WINDING_NUMBER: signed_distance_winding_number( g_tree,g_V,g_F,g_hier,q,s,sqrd,i,c); break; case SIGNED_DISTANCE_TYPE_PSEUDONORMAL: { RowVector3d n(0,0,0); signed_distance_pseudonormal( g_tree,g_V,g_F,g_FN,g_VN,g_EN,g_EMAP, q,s,sqrd,i,c,n); N.row(p) = n; break; } } I(p) = i; S(p) = s*sqrt(sqrd); C.row(p) = c; },10000); break; } } } switch(nlhs) { default: { mexErrMsgTxt(false,"Too many output parameters."); } case 4: { prepare_lhs_double(N,plhs+3); // Fall through } case 3: { prepare_lhs_double(C,plhs+2); // Fall through } case 2: { prepare_lhs_index(I,plhs+1); // Fall through } case 1: { prepare_lhs_double(S,plhs+0); // Fall through } case 0: break; } // Restore the std stream buffer Important! std::cout.rdbuf(outbuf); }
/** * The function main marks the entry point of the program. * By default, main has the storage class extern. * * @param [in] argc (argument count) is an integer that indicates how many arguments were entered on the command line when the program was started. * @param [in] argv (argument vector) is an array of pointers to arrays of character objects. The array objects are null-terminated strings, representing the arguments that were entered on the command line when the program was started. * @return the value that was set to exit() (which is 0 if exit() is called via quit()). */ int main(int argc, char *argv[]) { QGuiApplication a(argc, argv); // QFile t_fileFwd("./MNE-sample-data/MEG/sample/sample_audvis-meg-eeg-oct-6-fwd.fif"); // QFile t_fileCov("./MNE-sample-data/MEG/sample/sample_audvis-cov.fif"); // QFile t_fileRaw("./MNE-sample-data/MEG/sample/sample_audvis_raw.fif"); // QString t_sEventName = "./MNE-sample-data/MEG/sample/sample_audvis_raw-eve.fif"; // AnnotationSet t_annotationSet("./MNE-sample-data/subjects/sample/label/lh.aparc.a2009s.annot", "./MNE-sample-data/subjects/sample/label/rh.aparc.a2009s.annot"); // SurfaceSet t_surfSet("./MNE-sample-data/subjects/sample/surf/lh.white", "./MNE-sample-data/subjects/sample/surf/rh.white"); QFile t_fileFwd("E:/Data/sl_data/MEG/mind006/mind006_051209_auditory01_raw-oct-6p-fwd.fif"); QFile t_fileCov("E:/Data/sl_data/MEG/mind006/mind006_051209_auditory01_raw-cov.fif"); QFile t_fileRaw("E:/Data/sl_data/MEG/mind006/mind006_051209_auditory01_raw.fif"); QString t_sEventName = "E:/Data/sl_data/MEG/mind006/mind006_051209_auditory01_raw-eve.fif"; AnnotationSet t_annotationSet("E:/Data/sl_data/subjects/mind006/label/lh.aparc.a2009s.annot", "E:/Data/sl_data/subjects/mind006/label/rh.aparc.a2009s.annot"); SurfaceSet t_surfSet("E:/Data/sl_data/subjects/mind006/surf/lh.white", "E:/Data/sl_data/subjects/mind006/surf/rh.white"); qint32 event = 1; float tmin = -0.2f; float tmax = 0.4f; bool keep_comp = false; fiff_int_t dest_comp = 0; bool pick_all = true; qint32 k, p; // // Setup for reading the raw data // FiffRawData raw(t_fileRaw); RowVectorXi picks; if (pick_all) { // // Pick all // picks.resize(raw.info.nchan); for(k = 0; k < raw.info.nchan; ++k) picks(k) = k; // } else { QStringList include; include << "STI 014"; bool want_meg = true; bool want_eeg = false; bool want_stim = false; // picks = Fiff::pick_types(raw.info, want_meg, want_eeg, want_stim, include, raw.info.bads); picks = raw.info.pick_types(want_meg, want_eeg, want_stim, include, raw.info.bads);//prefer member function } QStringList ch_names; for(k = 0; k < picks.cols(); ++k) ch_names << raw.info.ch_names[picks(0,k)]; // // Set up projection // if (raw.info.projs.size() == 0) printf("No projector specified for these data\n"); else { // // Activate the projection items // for (k = 0; k < raw.info.projs.size(); ++k) raw.info.projs[k].active = true; printf("%d projection items activated\n",raw.info.projs.size()); // // Create the projector // // fiff_int_t nproj = MNE::make_projector_info(raw.info, raw.proj); Using the member function instead fiff_int_t nproj = raw.info.make_projector(raw.proj); if (nproj == 0) { printf("The projection vectors do not apply to these channels\n"); } else { printf("Created an SSP operator (subspace dimension = %d)\n",nproj); } } // // Set up the CTF compensator // // qint32 current_comp = MNE::get_current_comp(raw.info); qint32 current_comp = raw.info.get_current_comp(); if (current_comp > 0) printf("Current compensation grade : %d\n",current_comp); if (keep_comp) dest_comp = current_comp; if (current_comp != dest_comp) { qDebug() << "This part needs to be debugged"; if(MNE::make_compensator(raw.info, current_comp, dest_comp, raw.comp)) { // raw.info.chs = MNE::set_current_comp(raw.info.chs,dest_comp); raw.info.set_current_comp(dest_comp); printf("Appropriate compensator added to change to grade %d.\n",dest_comp); } else { printf("Could not make the compensator\n"); return 0; } } // // Read the events // QFile t_EventFile; MatrixXi events; if (t_sEventName.size() == 0) { p = t_fileRaw.fileName().indexOf(".fif"); if (p > 0) { t_sEventName = t_fileRaw.fileName().replace(p, 4, "-eve.fif"); } else { printf("Raw file name does not end properly\n"); return 0; } // events = mne_read_events(t_sEventName); t_EventFile.setFileName(t_sEventName); MNE::read_events(t_EventFile, events); printf("Events read from %s\n",t_sEventName.toUtf8().constData()); } else { // // Binary file // p = t_fileRaw.fileName().indexOf(".fif"); if (p > 0) { t_EventFile.setFileName(t_sEventName); if(!MNE::read_events(t_EventFile, events)) { printf("Error while read events.\n"); return 0; } printf("Binary event file %s read\n",t_sEventName.toUtf8().constData()); } else { // // Text file // printf("Text file %s is not supported jet.\n",t_sEventName.toUtf8().constData()); // try // events = load(eventname); // catch // error(me,mne_omit_first_line(lasterr)); // end // if size(events,1) < 1 // error(me,'No data in the event file'); // end // // // // Convert time to samples if sample number is negative // // // for p = 1:size(events,1) // if events(p,1) < 0 // events(p,1) = events(p,2)*raw.info.sfreq; // end // end // // // // Select the columns of interest (convert to integers) // // // events = int32(events(:,[1 3 4])); // // // // New format? // // // if events(1,2) == 0 && events(1,3) == 0 // fprintf(1,'The text event file %s is in the new format\n',eventname); // if events(1,1) ~= raw.first_samp // error(me,'This new format event file is not compatible with the raw data'); // end // else // fprintf(1,'The text event file %s is in the old format\n',eventname); // // // // Offset with first sample // // // events(:,1) = events(:,1) + raw.first_samp; // end } } // // Select the desired events // qint32 count = 0; MatrixXi selected = MatrixXi::Zero(1, events.rows()); for (p = 0; p < events.rows(); ++p) { if (events(p,1) == 0 && events(p,2) == event) { selected(0,count) = p; ++count; } } selected.conservativeResize(1, count); if (count > 0) printf("%d matching events found\n",count); else { printf("No desired events found.\n"); return 0; } fiff_int_t event_samp, from, to; MatrixXd timesDummy; MNEEpochDataList data; MNEEpochData* epoch = NULL; MatrixXd times; for (p = 0; p < count; ++p) { // // Read a data segment // event_samp = events(selected(p),0); from = event_samp + tmin*raw.info.sfreq; to = event_samp + floor(tmax*raw.info.sfreq + 0.5); epoch = new MNEEpochData(); if(raw.read_raw_segment(epoch->epoch, timesDummy, from, to, picks)) { if (p == 0) { times.resize(1, to-from+1); for (qint32 i = 0; i < times.cols(); ++i) times(0, i) = ((float)(from-event_samp+i)) / raw.info.sfreq; } epoch->event = event; epoch->tmin = ((float)(from)-(float)(raw.first_samp))/raw.info.sfreq; epoch->tmax = ((float)(to)-(float)(raw.first_samp))/raw.info.sfreq; data.append(MNEEpochData::SPtr(epoch));//List takes ownwership of the pointer - no delete need } else { printf("Can't read the event data segments"); return 0; } } if(data.size() > 0) { printf("Read %d epochs, %d samples each.\n",data.size(),(qint32)data[0]->epoch.cols()); //DEBUG std::cout << data[0]->epoch.block(0,0,10,10) << std::endl; qDebug() << data[0]->epoch.rows() << " x " << data[0]->epoch.cols(); std::cout << times.block(0,0,1,10) << std::endl; qDebug() << times.rows() << " x " << times.cols(); } // // calculate the average // // //Option 1 // qint32 numAverages = 99; // VectorXi vecSel(numAverages); // srand (time(NULL)); // initialize random seed // for(qint32 i = 0; i < vecSel.size(); ++i) // { // qint32 val = rand() % data.size(); // vecSel(i) = val; // } // //Option 2 // VectorXi vecSel(20); //// vecSel << 76, 74, 13, 61, 97, 94, 75, 71, 60, 56, 26, 57, 56, 0, 52, 72, 33, 86, 96, 67; // vecSel << 65, 22, 47, 55, 16, 29, 14, 36, 57, 97, 89, 46, 9, 93, 83, 52, 71, 52, 3, 96; //Option 3 Newest VectorXi vecSel(10); vecSel << 0, 96, 80, 55, 66, 25, 26, 2, 55, 58, 6, 88; std::cout << "Select following epochs to average:\n" << vecSel << std::endl; FiffEvoked evoked = data.average(raw.info, tmin*raw.info.sfreq, floor(tmax*raw.info.sfreq + 0.5), vecSel); //######################################################################################## // Source Estimate double snr = 1.0f;//0.1f;//1.0f;//3.0f;//0.1f;//3.0f; QString method("dSPM"); //"MNE" | "dSPM" | "sLORETA" QString t_sFileNameClusteredInv(""); QString t_sFileNameStc("mind006_051209_auditory01.stc"); // Parse command line parameters for(qint32 i = 0; i < argc; ++i) { if(strcmp(argv[i], "-snr") == 0 || strcmp(argv[i], "--snr") == 0) { if(i + 1 < argc) snr = atof(argv[i+1]); } else if(strcmp(argv[i], "-method") == 0 || strcmp(argv[i], "--method") == 0) { if(i + 1 < argc) method = QString::fromUtf8(argv[i+1]); } else if(strcmp(argv[i], "-inv") == 0 || strcmp(argv[i], "--inv") == 0) { if(i + 1 < argc) t_sFileNameClusteredInv = QString::fromUtf8(argv[i+1]); } else if(strcmp(argv[i], "-stc") == 0 || strcmp(argv[i], "--stc") == 0) { if(i + 1 < argc) t_sFileNameStc = QString::fromUtf8(argv[i+1]); } } double lambda2 = 1.0 / pow(snr, 2); qDebug() << "Start calculation with: SNR" << snr << "; Lambda" << lambda2 << "; Method" << method << "; stc:" << t_sFileNameStc; // // Load data // fiff_int_t setno = 1; // QPair<QVariant, QVariant> baseline(QVariant(), 0); // FiffEvoked evoked(t_fileEvoked, setno, baseline); // if(evoked.isEmpty()) // return 1; MNEForwardSolution t_Fwd(t_fileFwd); if(t_Fwd.isEmpty()) return 1; FiffCov noise_cov(t_fileCov); // regularize noise covariance noise_cov = noise_cov.regularize(evoked.info, 0.05, 0.05, 0.1, true); // // Cluster forward solution; // MNEForwardSolution t_clusteredFwd = t_Fwd.cluster_forward_solution_ccr(t_annotationSet, 20);//40); // // make an inverse operators // FiffInfo info = evoked.info; MNEInverseOperator inverse_operator(info, t_clusteredFwd, noise_cov, 0.2f, 0.8f); // // save clustered inverse // if(!t_sFileNameClusteredInv.isEmpty()) { QFile t_fileClusteredInverse(t_sFileNameClusteredInv); inverse_operator.write(t_fileClusteredInverse); } // // Compute inverse solution // MinimumNorm minimumNorm(inverse_operator, lambda2, method); #ifdef BENCHMARK MNESourceEstimate sourceEstimate; QList<qint64> qVecElapsedTime; for(qint32 i = 0; i < 20; ++i) { //Benchmark time QElapsedTimer timer; timer.start(); sourceEstimate = minimumNorm.calculateInverse(evoked); qVecElapsedTime.append(timer.elapsed()); } double meanTime = 0.0; for(qint32 i = 0; i < qVecElapsedTime.size(); ++i) meanTime += qVecElapsedTime[i]; meanTime /= qVecElapsedTime.size(); qDebug() << "MNE calculation took" << meanTime << "ms in average"; #else MNESourceEstimate sourceEstimate = minimumNorm.calculateInverse(evoked); #endif if(sourceEstimate.isEmpty()) return 1; // View activation time-series std::cout << "\nsourceEstimate:\n" << sourceEstimate.data.block(0,0,10,10) << std::endl; std::cout << "time\n" << sourceEstimate.times.block(0,0,1,10) << std::endl; std::cout << "timeMin\n" << sourceEstimate.times[0] << std::endl; std::cout << "timeMax\n" << sourceEstimate.times[sourceEstimate.times.size()-1] << std::endl; std::cout << "time step\n" << sourceEstimate.tstep << std::endl; //Condition Numbers // MatrixXd mags(102, t_Fwd.sol->data.cols()); // qint32 count = 0; // for(qint32 i = 2; i < 306; i += 3) // { // mags.row(count) = t_Fwd.sol->data.row(i); // ++count; // } // MatrixXd magsClustered(102, t_clusteredFwd.sol->data.cols()); // count = 0; // for(qint32 i = 2; i < 306; i += 3) // { // magsClustered.row(count) = t_clusteredFwd.sol->data.row(i); // ++count; // } // MatrixXd grads(204, t_Fwd.sol->data.cols()); // count = 0; // for(qint32 i = 0; i < 306; i += 3) // { // grads.row(count) = t_Fwd.sol->data.row(i); // ++count; // grads.row(count) = t_Fwd.sol->data.row(i+1); // ++count; // } // MatrixXd gradsClustered(204, t_clusteredFwd.sol->data.cols()); // count = 0; // for(qint32 i = 0; i < 306; i += 3) // { // gradsClustered.row(count) = t_clusteredFwd.sol->data.row(i); // ++count; // gradsClustered.row(count) = t_clusteredFwd.sol->data.row(i+1); // ++count; // } VectorXd s; double t_dConditionNumber = MNEMath::getConditionNumber(t_Fwd.sol->data, s); double t_dConditionNumberClustered = MNEMath::getConditionNumber(t_clusteredFwd.sol->data, s); std::cout << "Condition Number:\n" << t_dConditionNumber << std::endl; std::cout << "Clustered Condition Number:\n" << t_dConditionNumberClustered << std::endl; std::cout << "ForwardSolution" << t_Fwd.sol->data.block(0,0,10,10) << std::endl; std::cout << "Clustered ForwardSolution" << t_clusteredFwd.sol->data.block(0,0,10,10) << std::endl; // double t_dConditionNumberMags = MNEMath::getConditionNumber(mags, s); // double t_dConditionNumberMagsClustered = MNEMath::getConditionNumber(magsClustered, s); // std::cout << "Condition Number Magnetometers:\n" << t_dConditionNumberMags << std::endl; // std::cout << "Clustered Condition Number Magnetometers:\n" << t_dConditionNumberMagsClustered << std::endl; // double t_dConditionNumberGrads = MNEMath::getConditionNumber(grads, s); // double t_dConditionNumberGradsClustered = MNEMath::getConditionNumber(gradsClustered, s); // std::cout << "Condition Number Gradiometers:\n" << t_dConditionNumberGrads << std::endl; // std::cout << "Clustered Condition Number Gradiometers:\n" << t_dConditionNumberGradsClustered << std::endl; //Source Estimate end //######################################################################################## // //only one time point - P100 // qint32 sample = 0; // for(qint32 i = 0; i < sourceEstimate.times.size(); ++i) // { // if(sourceEstimate.times(i) >= 0) // { // sample = i; // break; // } // } // sample += (qint32)ceil(0.106/sourceEstimate.tstep); //100ms // sourceEstimate = sourceEstimate.reduce(sample, 1); QList<Label> t_qListLabels; QList<RowVector4i> t_qListRGBAs; //ToDo overload toLabels using instead of t_surfSet rr of MNESourceSpace t_annotationSet.toLabels(t_surfSet, t_qListLabels, t_qListRGBAs); InverseView view(minimumNorm.getSourceSpace(), t_qListLabels, t_qListRGBAs, 24, true, false, true); if (view.stereoType() != QGLView::RedCyanAnaglyph) view.camera()->setEyeSeparation(0.3f); QStringList args = QCoreApplication::arguments(); int w_pos = args.indexOf("-width"); int h_pos = args.indexOf("-height"); if (w_pos >= 0 && h_pos >= 0) { bool ok = true; int w = args.at(w_pos + 1).toInt(&ok); if (!ok) { qWarning() << "Could not parse width argument:" << args; return 1; } int h = args.at(h_pos + 1).toInt(&ok); if (!ok) { qWarning() << "Could not parse height argument:" << args; return 1; } view.resize(w, h); } else { view.resize(800, 600); } view.show(); //Push Estimate view.pushSourceEstimate(sourceEstimate); if(!t_sFileNameStc.isEmpty()) { QFile t_fileClusteredStc(t_sFileNameStc); sourceEstimate.write(t_fileClusteredStc); } //*/ return a.exec();//1;//a.exec(); }