// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- int MRCReader::read(const std::string& filepath, int* voxelMin, int* voxelMax) { bool readSubVolume = false; MXAFileReader64 reader(filepath); bool success = reader.initReader(); if (false == success) { return -1; } m_Header = new MRCHeader; ::memset(m_Header, 0, 1024); // Splat zeros across the entire structure m_Header->feiHeaders = NULL; success = reader.rawRead(reinterpret_cast<char*>(m_Header), 1024); if (false == success) { return -2; } // Now read the extended header m_ExtendedHeader.resize(m_Header->next, 0); success = reader.readArray( &(m_ExtendedHeader.front()), m_Header->next); if (false == success) { return -3; } // size_t fp = reader.getFilePointer64(); // If we have an FEI header then parse the extended header information m_Header->feiHeaders = NULL; // If we have an FEI header then parse the extended header information std::string feiLabel(m_Header->labels[0], 80); std::string::size_type pos = feiLabel.find("Fei Company"); if (pos != std::string::npos) { if (NULL != m_Header->feiHeaders) { free(m_Header->feiHeaders); m_Header->feiHeaders = NULL; } // Allocate and copy in the data m_Header->feiHeaders = reinterpret_cast<FEIHeader*>(malloc(sizeof(FEIHeader) * m_Header->nz)); ::memcpy(m_Header->feiHeaders, &(m_ExtendedHeader.front()), sizeof(FEIHeader) * m_Header->nz); } pos = feiLabel.find("EIC project"); if (pos != std::string::npos) { if (NULL != m_Header->feiHeaders) { free(m_Header->feiHeaders); m_Header->feiHeaders = NULL; } // Allocate and copy in the data m_Header->feiHeaders = reinterpret_cast<FEIHeader*>(malloc(sizeof(FEIHeader) * m_Header->nz)); ::memcpy(m_Header->feiHeaders, &(m_ExtendedHeader.front()), sizeof(FEIHeader) * m_Header->nz); } pos = feiLabel.find("MCAP project, MDG, Copyright 2013"); if (pos != std::string::npos) { if (NULL != m_Header->feiHeaders) { free(m_Header->feiHeaders); m_Header->feiHeaders = NULL; } // Allocate and copy in the data m_Header->feiHeaders = reinterpret_cast<FEIHeader*>(malloc(sizeof(FEIHeader) * m_Header->nz)); ::memcpy(m_Header->feiHeaders, &(m_ExtendedHeader.front()), sizeof(FEIHeader) * m_Header->nz); } size_t nVoxels = m_Header->nx * m_Header->ny * m_Header->nz; if ( NULL != voxelMin && NULL != voxelMax) { // The user is requesting a sub-volume so calculate the number of voxels to be read nVoxels = (voxelMax[0] - voxelMin[0] + 1) * (voxelMax[1] - voxelMin[1] + 1) * (voxelMax[2] - voxelMin[2] + 1); readSubVolume = true; } size_t typeSize = 0; void* dataPtr = NULL; switch(m_Header->mode) { case 0: m_UInt8Data = (uint8_t*)(malloc(nVoxels * sizeof(uint8_t))); typeSize = 1; dataPtr = m_UInt8Data; break; case 1: m_Int16Data = (int16_t*)(malloc(nVoxels * sizeof(int16_t))); typeSize = 2; dataPtr = m_Int16Data; break; case 2: m_FloatData = (float*)(malloc(nVoxels * sizeof(float))); typeSize = 4; dataPtr = m_FloatData; break; case 3: break; case 4: break; case 6: m_UInt16Data = (uint16_t*)(malloc(nVoxels * sizeof(int16_t))); typeSize = 2; dataPtr = m_UInt16Data; break; case 16: break; } if (typeSize > 0 && dataPtr != NULL ) { if (false == readSubVolume) { success = reader.rawRead(reinterpret_cast<char*>(dataPtr), typeSize * nVoxels); if(false == success) { return -4; } } else { // Read a subvolume. success = readPartialVolume(reader, reinterpret_cast<char*>(dataPtr), typeSize, nVoxels, voxelMin, voxelMax); } } else { return -5; } return 1; }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- int MRCReader::readHeader(const std::string& filepath, MRCHeader* header) { MXAFileReader64 reader(filepath); bool success = reader.initReader(); if (false == success) { return -1; } header->feiHeaders = NULL; ::memset(header, 0, 1024); // Splat zeros across the entire structure success = reader.rawRead(reinterpret_cast<char*>(header), 1024); if (false == success) { return -2; } // Now read the extended header m_ExtendedHeader.resize(header->next, 0); success = reader.readArray( &(m_ExtendedHeader.front()), header->next); if (false == success) { return -3; } // If we have an FEI header then parse the extended header information std::string feiLabel(header->labels[0], 80); std::string::size_type pos = feiLabel.find("Fei Company"); if (pos != std::string::npos) { if (NULL != header->feiHeaders) { free(header->feiHeaders); header->feiHeaders = NULL; } // Allocate and copy in the data header->feiHeaders = reinterpret_cast<FEIHeader*>(malloc(sizeof(FEIHeader) * header->nz)); ::memcpy(header->feiHeaders, &(m_ExtendedHeader.front()), sizeof(FEIHeader) * header->nz); } pos = feiLabel.find("EIC project"); if (pos != std::string::npos) { if (NULL != header->feiHeaders) { free(header->feiHeaders); header->feiHeaders = NULL; } // Allocate and copy in the data header->feiHeaders = reinterpret_cast<FEIHeader*>(malloc(sizeof(FEIHeader) * header->nz)); ::memcpy(header->feiHeaders, &(m_ExtendedHeader.front()), sizeof(FEIHeader) * header->nz); } pos = feiLabel.find("MCAP project, MDG, Copyright 2013"); if (pos != std::string::npos) { if (NULL != header->feiHeaders) { free(header->feiHeaders); header->feiHeaders = NULL; } // Allocate and copy in the data header->feiHeaders = reinterpret_cast<FEIHeader*>(malloc(sizeof(FEIHeader) * header->nz)); ::memcpy(header->feiHeaders, &(m_ExtendedHeader.front()), sizeof(FEIHeader) * header->nz); } pos = feiLabel.find("tif2mrc: Converted to MRC format"); if (pos != std::string::npos) { if (NULL != header->feiHeaders) { free(header->feiHeaders); header->feiHeaders = NULL; } // // Allocate and copy in the data // header->feiHeaders = reinterpret_cast<FEIHeader*>(malloc(sizeof(FEIHeader) * header->nz)); // ::memcpy(header->feiHeaders, &(m_ExtendedHeader.front()), sizeof(FEIHeader) * header->nz); } return 1; }
bool WidgetBoxTreeWidget::readCategories(const QString &fileName, const QString &contents, CategoryList *cats, QString *errorMessage) { // Read widget box XML: // //<widgetbox version="4.5"> // <category name="Layouts"> // <categoryentry name="Vertical Layout" icon="win/editvlayout.png" type="default"> // <widget class="QListWidget" ...> // ... QXmlStreamReader reader(contents); // Entries of category with name="invisible" should be ignored bool ignoreEntries = false; while (!reader.atEnd()) { switch (reader.readNext()) { case QXmlStreamReader::StartElement: { const QStringRef tag = reader.name(); if (tag == QLatin1String(widgetBoxRootElementC)) { //<widgetbox version="4.5"> continue; } if (tag == QLatin1String(categoryElementC)) { // <category name="Layouts"> const QXmlStreamAttributes attributes = reader.attributes(); const QString categoryName = attributes.value(QLatin1String(nameAttributeC)).toString(); if (categoryName == QLatin1String(invisibleNameC)) { ignoreEntries = true; } else { Category category(categoryName); if (attributes.value(QLatin1String(typeAttributeC)) == QLatin1String(scratchPadValueC)) category.setType(Category::Scratchpad); cats->push_back(category); } continue; } if (tag == QLatin1String(categoryEntryElementC)) { // <categoryentry name="Vertical Layout" icon="win/editvlayout.png" type="default"> if (!ignoreEntries) { QXmlStreamAttributes attr = reader.attributes(); const QString widgetName = attr.value(QLatin1String(nameAttributeC)).toString(); const QString widgetIcon = attr.value(QLatin1String(iconAttributeC)).toString(); const WidgetBoxTreeWidget::Widget::Type widgetType = attr.value(QLatin1String(typeAttributeC)).toString() == QLatin1String(customValueC) ? WidgetBoxTreeWidget::Widget::Custom : WidgetBoxTreeWidget::Widget::Default; Widget w; w.setName(widgetName); w.setIconName(widgetIcon); w.setType(widgetType); if (!readWidget(&w, contents, reader)) continue; cats->back().addWidget(w); } // ignoreEntries continue; } break; } case QXmlStreamReader::EndElement: { const QStringRef tag = reader.name(); if (tag == QLatin1String(widgetBoxRootElementC)) { continue; } if (tag == QLatin1String(categoryElementC)) { ignoreEntries = false; continue; } if (tag == QLatin1String(categoryEntryElementC)) { continue; } break; } default: break; } } if (reader.hasError()) { *errorMessage = msgXmlError(fileName, reader); return false; } return true; }
int main(int argc, char** argv) { try { Sundance::init(&argc, &argv); /* We will do our linear algebra using Epetra */ VectorType<double> vecType = new EpetraVectorType(); /* Create a mesh. It will be of type BasisSimplicialMesh, and will * be built using a PartitionedLineMesher. */ MeshType meshType = new BasicSimplicialMeshType(); MeshSource mesher = new PartitionedLineMesher(0.0, 1.0, 10, meshType); Mesh mesh = mesher.getMesh(); /* Create a cell filter that will identify the maximal cells * in the interior of the domain */ CellFilter interior = new MaximalCellFilter(); /* Create unknown and test functions, discretized using first-order * Lagrange interpolants */ Expr u = new UnknownFunction(new Lagrange(1), "u"); Expr v = new TestFunction(new Lagrange(1), "v"); /* We need a quadrature rule for doing the integrations */ QuadratureFamily quad = new GaussianQuadrature(2); /* Define the weak form */ Expr eqn = Integral(interior, v*(u-1.0), quad); Expr bc; /* We can now set up the linear problem! */ std::cerr << "setting up linear problem" << std::endl; LinearProblem prob(mesh, eqn, bc, v, u, vecType); #ifdef HAVE_CONFIG_H ParameterXMLFileReader reader(searchForFile("SolverParameters/bicgstab.xml")); #else ParameterXMLFileReader reader("bicgstab.xml"); #endif ParameterList solverParams = reader.getParameters(); std::cerr << "params = " << solverParams << std::endl; LinearSolver<double> solver = LinearSolverBuilder::createSolver(solverParams); std::cerr << "solving problem" << std::endl; Expr soln = prob.solve(solver); Expr exactSoln = 1.0; Expr errExpr = Integral(interior, pow(soln-exactSoln, 2), new GaussianQuadrature(4)); std::cerr << "setting up norm" << std::endl; double errorSq = evaluateIntegral(mesh, errExpr); std::cerr << "error norm = " << sqrt(errorSq) << std::endl << std::endl; double tol = 1.0e-12; Sundance::passFailTest(sqrt(errorSq), tol); } catch(std::exception& e) { std::cerr << e.what() << std::endl; } Sundance::finalize(); return Sundance::testStatus(); }
void check(const char* testName){ printf("o Checking %s\n",testName); TH1::AddDirectory(0); // same name is ok gRandom->SetSeed(1); // make all contents identical irrespective of the container std::string binFilename(testName); binFilename+=".root"; std::string xmlFilename(testName); xmlFilename+=".xml"; auto filenames {binFilename.c_str()/*, xmlFilename.c_str()*/}; // NEED XML HERE for (auto&& filename : filenames){ createFile(filename); } Cont<double> doubleCont {1.,2.,3.,4.}; // need double32_t Cont<complex<double>> complexDCont {{1,2},{3,4},{5,6},{7,8},{9,10},{11,12}}; Cont<complex<float>> complexFCont {{1,2},{3,4},{5,6},{7,8},{9,10},{11,12}}; Cont<TH1F> histoCont {TH1F("h","ht",100,-2,2), TH1F("h","ht",10,-1.2,1.2)}; fillHistoCont(histoCont); Cont<Cont<TH1F>> contHistoCont NESTEDCONT; fillHistoNestedCont(contHistoCont); vector<Cont<TH1F>> vecHistoCont NESTEDCONT; fillHistoNestedCont(vecHistoCont); Cont<vector<TH1F>> contHistoVec NESTEDCONT; fillHistoNestedCont(contHistoVec); printf(" - RowWise\n"); // Row wise for (auto&& filename : filenames){ writeReadCheck(doubleCont,"doubleCont",filename); writeReadCheck(complexDCont,"complexDCont",filename); writeReadCheck(complexFCont,"complexFCont",filename); writeReadCheck(histoCont,"histoCont",filename); writeReadCheck(contHistoCont,"contHistoCont",filename); writeReadCheck(vecHistoCont,"vecHistoCont",filename); writeReadCheck(contHistoVec,"contHistoVec",filename); } // ColumnWise printf(" - ColumnWise\n"); int NEvts=100; // Make a backup of the input auto doubleContOrig = doubleCont; auto complexDContOrig = complexDCont; auto complexFContOrig = complexFCont; auto histoContOrig = histoCont; auto contHistoContOrig = contHistoCont; auto vecHistoContOrig = vecHistoCont; auto contHistoVecOrig = contHistoVec; // Write gRandom->SetSeed(1); { printf(" * Write\n"); TFile f(binFilename.c_str(),"UPDATE"); TTree t("t","Test Tree"); t.Branch("doubleCont_split", &doubleCont,16000,99); t.Branch("doubleCont", &doubleCont,16000,0); t.Branch("complexDCont_split", &complexDCont,16000,99); t.Branch("complexDCont", &complexDCont,16000,0); t.Branch("complexFCont_split", &complexFCont,16000,99); t.Branch("complexFCont", &complexFCont,16000,0); t.Branch("histoCont_split", &histoCont,16000,99); t.Branch("histoCont", &histoCont,16000,0); t.Branch("contHistoCont_split", &contHistoCont,16000,99); t.Branch("contHistoCont", &contHistoCont,16000,0); t.Branch("vecHistoCont_split", &vecHistoCont,16000,99); t.Branch("vecHistoCont", &vecHistoCont,16000,0); t.Branch("contHistoVec_split", &contHistoVec,16000,99); t.Branch("contHistoVec", &contHistoVec,16000,0); for (int i=0;i<NEvts;++i){ randomizeCont(doubleCont); randomizeCont(complexDCont); randomizeCont(complexFCont); fillHistoCont(histoCont,10); fillHistoNestedCont(contHistoCont,10); fillHistoNestedCont(vecHistoCont,10); fillHistoNestedCont(contHistoVec,10); t.Fill(); } t.Write(); } // And Read gRandom->SetSeed(1); { printf(" * Read\n"); TFile f(binFilename.c_str()); TTreeReader reader("t", &f); TTreeReaderValue<decltype(doubleCont)> rdoubleCont_split(reader, "doubleCont_split"); TTreeReaderValue<decltype(doubleCont)> rdoubleCont(reader, "doubleCont"); TTreeReaderValue<decltype(complexDCont)> rcomplexDCont_split(reader, "complexDCont_split"); TTreeReaderValue<decltype(complexDCont)> rcomplexDCont(reader, "complexDCont"); TTreeReaderValue<decltype(complexFCont)> rcomplexFCont_split(reader, "complexFCont_split"); TTreeReaderValue<decltype(complexFCont)> rcomplexFCont(reader, "complexFCont"); TTreeReaderValue<decltype(histoCont)> rhistoCont_split(reader, "histoCont_split"); TTreeReaderValue<decltype(histoCont)> rhistoCont(reader, "histoCont"); TTreeReaderValue<decltype(contHistoCont)> rcontHistoCont_split(reader, "contHistoCont_split"); TTreeReaderValue<decltype(contHistoCont)> rcontHistoCont(reader, "contHistoCont"); TTreeReaderValue<decltype(vecHistoCont)> rvecHistoCont_split(reader, "vecHistoCont_split"); TTreeReaderValue<decltype(vecHistoCont)> rvecHistoCont(reader, "vecHistoCont"); TTreeReaderValue<decltype(contHistoVec)> rcontHistoVec_split(reader, "contHistoVec_split"); TTreeReaderValue<decltype(contHistoVec)> rcontHistoVec(reader, "contHistoVec"); for (int i=0;i<NEvts;++i){ // Rebuild original values randomizeCont(doubleContOrig); randomizeCont(complexDContOrig); randomizeCont(complexFContOrig); fillHistoCont(histoContOrig,10); fillHistoNestedCont(contHistoContOrig,10); fillHistoNestedCont(vecHistoContOrig,10); fillHistoNestedCont(contHistoVecOrig,10); // Now check them reader.Next(); checkObjects("doubleCont_split",doubleContOrig,*rdoubleCont_split); checkObjects("doubleCont",doubleContOrig,*rdoubleCont); checkObjects("complexDCont_split",complexDContOrig,*rcomplexDCont_split); checkObjects("complexDCont",complexDContOrig,*rcomplexDCont); checkObjects("complexFCont_split",complexFContOrig,*rcomplexFCont_split); checkObjects("complexFCont",complexFContOrig,*rcomplexFCont); checkObjects("histoCont_split",histoContOrig,*rhistoCont_split); checkObjects("histoCont",histoContOrig,*rhistoCont); checkObjects("contHistoCont_split",contHistoContOrig,*rcontHistoCont_split); checkObjects("contHistoCont",contHistoContOrig,*rcontHistoCont); checkObjects("vecHistoCont_split",vecHistoContOrig,*rvecHistoCont_split); checkObjects("vecHistoCont",vecHistoContOrig,*rvecHistoCont); checkObjects("contHistoVec_split",contHistoVecOrig,*rcontHistoVec_split); checkObjects("contHistoVec",contHistoVecOrig,*rcontHistoVec); } } }
MainWindow::MainWindow(CmdLineParser *cmdLine, QWidget *parent) : QMainWindow(parent) , m_bookmarkWidget(0) , m_filterCombo(0) , m_toolBarMenu(0) , m_cmdLine(cmdLine) , m_progressWidget(0) , m_qtDocInstaller(0) , m_connectedInitSignals(false) { TRACE_OBJ setToolButtonStyle(Qt::ToolButtonFollowStyle); setDockOptions(dockOptions() | AllowNestedDocks); QString collectionFile; if (usesDefaultCollection()) { MainWindow::collectionFileDirectory(true); collectionFile = MainWindow::defaultHelpCollectionFileName(); } else { collectionFile = cmdLine->collectionFile(); } HelpEngineWrapper &helpEngineWrapper = HelpEngineWrapper::instance(collectionFile); BookmarkManager *bookMarkManager = BookmarkManager::instance(); if (!initHelpDB(!cmdLine->collectionFileGiven())) { qDebug("Fatal error: Help engine initialization failed. " "Error message was: %s\nAssistant will now exit.", qPrintable(HelpEngineWrapper::instance().error())); std::exit(1); } m_centralWidget = new CentralWidget(this); setCentralWidget(m_centralWidget); m_indexWindow = new IndexWindow(this); QDockWidget *indexDock = new QDockWidget(tr("Index"), this); indexDock->setObjectName(QLatin1String("IndexWindow")); indexDock->setWidget(m_indexWindow); addDockWidget(Qt::LeftDockWidgetArea, indexDock); m_contentWindow = new ContentWindow; QDockWidget *contentDock = new QDockWidget(tr("Contents"), this); contentDock->setObjectName(QLatin1String("ContentWindow")); contentDock->setWidget(m_contentWindow); addDockWidget(Qt::LeftDockWidgetArea, contentDock); m_searchWindow = new SearchWidget(helpEngineWrapper.searchEngine()); m_searchWindow->setFont(!helpEngineWrapper.usesBrowserFont() ? qApp->font() : helpEngineWrapper.browserFont()); QDockWidget *searchDock = new QDockWidget(tr("Search"), this); searchDock->setObjectName(QLatin1String("SearchWindow")); searchDock->setWidget(m_searchWindow); addDockWidget(Qt::LeftDockWidgetArea, searchDock); QDockWidget *bookmarkDock = new QDockWidget(tr("Bookmarks"), this); bookmarkDock->setObjectName(QLatin1String("BookmarkWindow")); bookmarkDock->setWidget(m_bookmarkWidget = bookMarkManager->bookmarkDockWidget()); addDockWidget(Qt::LeftDockWidgetArea, bookmarkDock); QDockWidget *openPagesDock = new QDockWidget(tr("Open Pages"), this); openPagesDock->setObjectName(QLatin1String("Open Pages")); OpenPagesManager *openPagesManager = OpenPagesManager::createInstance(this, usesDefaultCollection(), m_cmdLine->url()); openPagesDock->setWidget(openPagesManager->openPagesWidget()); addDockWidget(Qt::LeftDockWidgetArea, openPagesDock); connect(m_centralWidget, SIGNAL(addBookmark(QString,QString)), bookMarkManager, SLOT(addBookmark(QString,QString))); connect(bookMarkManager, SIGNAL(escapePressed()), this, SLOT(activateCurrentCentralWidgetTab())); connect(bookMarkManager, SIGNAL(setSource(QUrl)), m_centralWidget, SLOT(setSource(QUrl))); connect(bookMarkManager, SIGNAL(setSourceInNewTab(QUrl)), openPagesManager, SLOT(createPage(QUrl))); QHelpSearchEngine *searchEngine = helpEngineWrapper.searchEngine(); connect(searchEngine, SIGNAL(indexingStarted()), this, SLOT(indexingStarted())); connect(searchEngine, SIGNAL(indexingFinished()), this, SLOT(indexingFinished())); QString defWindowTitle = tr("Qt Assistant"); setWindowTitle(defWindowTitle); setupActions(); statusBar()->show(); m_centralWidget->connectTabBar(); setupFilterToolbar(); setupAddressToolbar(); const QString windowTitle = helpEngineWrapper.windowTitle(); setWindowTitle(windowTitle.isEmpty() ? defWindowTitle : windowTitle); QByteArray iconArray = helpEngineWrapper.applicationIcon(); if (iconArray.size() > 0) { QBuffer buffer(&iconArray); QImageReader reader(&buffer); QIcon appIcon; do { QPixmap pix; pix.convertFromImage(reader.read()); appIcon.addPixmap(pix); } while (reader.jumpToNextImage()); qApp->setWindowIcon(appIcon); } else { QIcon appIcon(QLatin1String(":/qt-project.org/assistant/images/assistant-128.png")); qApp->setWindowIcon(appIcon); } QToolBar *toolBar = addToolBar(tr("Bookmark Toolbar")); toolBar->setObjectName(QLatin1String("Bookmark Toolbar")); bookMarkManager->setBookmarksToolbar(toolBar); toolBar->hide(); toolBarMenu()->addAction(toolBar->toggleViewAction()); QByteArray ba(helpEngineWrapper.mainWindow()); if (!ba.isEmpty()) restoreState(ba); ba = helpEngineWrapper.mainWindowGeometry(); if (!ba.isEmpty()) { restoreGeometry(ba); } else { tabifyDockWidget(contentDock, indexDock); tabifyDockWidget(indexDock, bookmarkDock); tabifyDockWidget(bookmarkDock, searchDock); contentDock->raise(); const QRect screen = QApplication::desktop()->screenGeometry(); resize(4*screen.width()/5, 4*screen.height()/5); adjustSize(); // make sure we won't start outside of the screen move(screen.center() - rect().center()); } if (!helpEngineWrapper.hasFontSettings()) { helpEngineWrapper.setUseAppFont(false); helpEngineWrapper.setUseBrowserFont(false); helpEngineWrapper.setAppFont(qApp->font()); helpEngineWrapper.setAppWritingSystem(QFontDatabase::Latin); helpEngineWrapper.setBrowserFont(qApp->font()); helpEngineWrapper.setBrowserWritingSystem(QFontDatabase::Latin); } else { updateApplicationFont(); } updateAboutMenuText(); QTimer::singleShot(0, this, SLOT(insertLastPages())); if (m_cmdLine->enableRemoteControl()) (void)new RemoteControl(this); if (m_cmdLine->contents() == CmdLineParser::Show) showContents(); else if (m_cmdLine->contents() == CmdLineParser::Hide) hideContents(); if (m_cmdLine->index() == CmdLineParser::Show) showIndex(); else if (m_cmdLine->index() == CmdLineParser::Hide) hideIndex(); if (m_cmdLine->bookmarks() == CmdLineParser::Show) showBookmarksDockWidget(); else if (m_cmdLine->bookmarks() == CmdLineParser::Hide) hideBookmarksDockWidget(); if (m_cmdLine->search() == CmdLineParser::Show) showSearch(); else if (m_cmdLine->search() == CmdLineParser::Hide) hideSearch(); if (m_cmdLine->contents() == CmdLineParser::Activate) showContents(); else if (m_cmdLine->index() == CmdLineParser::Activate) showIndex(); else if (m_cmdLine->bookmarks() == CmdLineParser::Activate) showBookmarksDockWidget(); if (!m_cmdLine->currentFilter().isEmpty()) { const QString &curFilter = m_cmdLine->currentFilter(); if (helpEngineWrapper.customFilters().contains(curFilter)) helpEngineWrapper.setCurrentFilter(curFilter); } if (usesDefaultCollection()) QTimer::singleShot(0, this, SLOT(lookForNewQtDocumentation())); else checkInitState(); connect(&helpEngineWrapper, SIGNAL(documentationRemoved(QString)), this, SLOT(documentationRemoved(QString))); connect(&helpEngineWrapper, SIGNAL(documentationUpdated(QString)), this, SLOT(documentationUpdated(QString))); setTabPosition(Qt::AllDockWidgetAreas, QTabWidget::North); GlobalActions::instance()->updateActions(); if (helpEngineWrapper.addressBarEnabled()) showNewAddress(); }
int CWAV2AMBE::run() { CWAVFileReader reader(m_input, AUDIO_BLOCK_SIZE); bool ret = reader.open(); if (!ret) return 1; if (reader.getSampleRate() != AUDIO_SAMPLE_RATE) { ::fprintf(stderr, "WAV2AMBE: input file has the wrong sample rate\n"); reader.close(); return 1; } if (reader.getChannels() > 1U) { ::fprintf(stderr, "WAV2AMBE: input file has too many channels\n"); reader.close(); return 1; } CAMBEFileWriter writer(m_output, m_signature); ret = writer.open(); if (!ret) { reader.close(); return 1; } if (m_mode == MODE_P25) { float audioFloat[AUDIO_BLOCK_SIZE]; while (reader.read(audioFloat, AUDIO_BLOCK_SIZE) == AUDIO_BLOCK_SIZE) { imbe_vocoder vocoder; int16_t audioInt[AUDIO_BLOCK_SIZE]; for (unsigned int i = 0U; i < AUDIO_BLOCK_SIZE; i++) audioInt[i] = int16_t((audioFloat[i] * 128) + 128); int16_t frameInt[88U]; vocoder.imbe_encode(frameInt, audioInt); unsigned char frame[11U]; for (unsigned int i = 0U; i < 88U; i++) WRITE_BIT1(frame, i, frameInt[i] != 0); if (m_fec) { uint8_t data[18U]; CIMBEFEC fec; fec.encode(data, frame); writer.write(data, 18U); } else { writer.write(frame, 11U); } } } else { CDV3000SerialController controller(m_port, m_speed, m_mode, m_fec, m_amplitude, m_reset, &reader, &writer); ret = controller.open(); if (!ret) { writer.close(); reader.close(); return 1; } controller.process(); controller.close(); } writer.close(); reader.close(); return 0; }
void TMVAClassificationApplication(){ TMVA::Reader reader("!Color:!Silent"); // create a set of variables and declare them to the reader // - the variable names must corresponds in name and type to // those given in the weight file(s) that you use Float_t dsmass; Float_t dspstar; Float_t gamenergy; Float_t gamanglelab; Float_t gamenergycm; Float_t gamangle; Float_t gamKangle; Float_t dsstdecayangle; Float_t dsangle; Float_t Kangle; Float_t Kpstar; Float_t fragpstar; Float_t fragenergy; Float_t fragangle; Float_t tagsidedeltae; Float_t evtpstar; Float_t evtcosstar; Float_t evtvtxprob; Int_t evthassignal; reader.AddVariable( "dspstar", &dspstar ); reader.AddVariable( "dsangle", &dsangle ); reader.AddVariable( "Kangle", &Kangle ); reader.AddVariable( "Kpstar", &Kpstar ); reader.AddVariable( "fragpstar", &fragpstar ); reader.AddVariable( "fragenergy", &fragenergy ); reader.AddVariable( "fragangle", &fragangle ); reader.AddVariable( "tagsidedeltae", &tagsidedeltae ); reader.AddVariable( "gamenergy", &gamenergy ); reader.AddVariable( "gamanglelab", &gamanglelab ); reader.AddVariable( "evtpstar",&evtpstar); reader.AddVariable( "evtcosstar",&evtcosstar); reader.AddVariable( "evtvtxprob",&evtvtxprob); cout<<" reader Added variables"<<endl; // // book the MVA methods // reader.BookMVA("BDT method","weights/TMVAClassification_BDT.weights.txt"); // book output histograms UInt_t nbin = 100; TH1F *histBdt= new TH1F( "MVA_BDT","MVA_BDT",nbin, -0.8, 0.8 ); TH1F *histDsMass= new TH1F( "DsMass","DsMass",50, 1.82, 2.12 ); TH1F *histDsMassBkg= new TH1F( "DsMassBkg","DsMassBkg",50, 1.82, 2.12 ); cout<<" booked histograms"<<endl; // Prepare input tree (this must be replaced by your data source) TFile *input(0); TString fname = "DsTolnu/SP1005/DsReco/Ntuple.root"; input = TFile::Open( fname ); // check if file in local directory exists if (!input){ std::cout << "ERROR: could not open data file" << std::endl; exit(1); } std::cout << "--- TMVAClassificationApp : Using input file: " << input->GetName() << std::endl; input->ls(); // // prepare the tree TTree* theTree = (TTree*)input->Get("Ntuple"); std::cout << "--- Select signal sample" << std::endl; theTree->SetBranchAddress( "dsmass", &dsmass ); theTree->SetBranchAddress( "dspstar", &dspstar ); theTree->SetBranchAddress( "gamenergy", &gamenergy ); theTree->SetBranchAddress( "gamanglelab", &gamanglelab ); theTree->SetBranchAddress( "dsangle", &dsangle ); theTree->SetBranchAddress( "Kangle", &Kangle ); theTree->SetBranchAddress( "Kpstar", &Kpstar ); theTree->SetBranchAddress( "fragpstar", &fragpstar ); theTree->SetBranchAddress( "fragenergy", &fragenergy ); theTree->SetBranchAddress( "fragangle", &fragangle ); theTree->SetBranchAddress( "tagsidedeltae", &tagsidedeltae); theTree->SetBranchAddress( "evtpstar", &evtpstar ); theTree->SetBranchAddress( "evtcosstar", &evtcosstar ); theTree->SetBranchAddress( "evtvtxprob", &evtvtxprob ); theTree->SetBranchAddress( "evthassignal", &evthassignal); std::cout << "--- Processing: " << theTree->GetEntries() << " events" << std::endl; TStopwatch sw; sw.Start(); for (Long64_t ievt=0; ievt<theTree->GetEntries();ievt++) { if (ievt%1000 == 0){ std::cout << "--- ... Processing event: " << ievt << std::endl; } theTree->GetEntry(ievt); Float_t BDTOutPut=reader.EvaluateMVA("BDT method"); histBdt->Fill(BDTOutPut); if(BDTOutPut<-.19)continue; histDsMass->Fill(dsmass); if(!evthassignal)histDsMassBkg->Fill(dsmass); } // get elapsed time sw.Stop(); std::cout << "--- End of event loop: "; sw.Print(); // // write histograms // TFile *target = new TFile("TMVApp.root","RECREATE" ); histBdt ->Write(); histDsMass ->Write(); histDsMassBkg ->Write(); target->Close(); std::cout << "--- Created root file: \"TMVApp.root\" containing the MVA output histograms" << std::endl; std::cout << "==> TMVAClassificationApplication is done!" << endl << std::endl; }
bool jointData::read(yarp::os::ConnectionReader& connection) { yarp::os::idl::WireReader reader(connection); if (!reader.readListHeader(22)) return false; return read(reader); }
bool jointData::Editor::read(yarp::os::ConnectionReader& connection) { if (!isValid()) return false; yarp::os::idl::WireReader reader(connection); reader.expectAccept(); if (!reader.readListHeader()) return false; int len = reader.getLength(); if (len==0) { yarp::os::idl::WireWriter writer(reader); if (writer.isNull()) return true; if (!writer.writeListHeader(1)) return false; writer.writeString("send: 'help' or 'patch (param1 val1) (param2 val2)'"); return true; } std::string tag; if (!reader.readString(tag)) return false; if (tag=="help") { yarp::os::idl::WireWriter writer(reader); if (writer.isNull()) return true; if (!writer.writeListHeader(2)) return false; if (!writer.writeTag("many",1, 0)) return false; if (reader.getLength()>0) { std::string field; if (!reader.readString(field)) return false; if (field=="jointPosition") { if (!writer.writeListHeader(1)) return false; if (!writer.writeString("yarp::sig::VectorOf<double> jointPosition")) return false; } if (field=="jointPosition_isValid") { if (!writer.writeListHeader(1)) return false; if (!writer.writeString("bool jointPosition_isValid")) return false; } if (field=="jointVelocity") { if (!writer.writeListHeader(1)) return false; if (!writer.writeString("yarp::sig::VectorOf<double> jointVelocity")) return false; } if (field=="jointVelocity_isValid") { if (!writer.writeListHeader(1)) return false; if (!writer.writeString("bool jointVelocity_isValid")) return false; } if (field=="jointAcceleration") { if (!writer.writeListHeader(1)) return false; if (!writer.writeString("yarp::sig::VectorOf<double> jointAcceleration")) return false; } if (field=="jointAcceleration_isValid") { if (!writer.writeListHeader(1)) return false; if (!writer.writeString("bool jointAcceleration_isValid")) return false; } if (field=="motorPosition") { if (!writer.writeListHeader(1)) return false; if (!writer.writeString("yarp::sig::VectorOf<double> motorPosition")) return false; } if (field=="motorPosition_isValid") { if (!writer.writeListHeader(1)) return false; if (!writer.writeString("bool motorPosition_isValid")) return false; } if (field=="motorVelocity") { if (!writer.writeListHeader(1)) return false; if (!writer.writeString("yarp::sig::VectorOf<double> motorVelocity")) return false; } if (field=="motorVelocity_isValid") { if (!writer.writeListHeader(1)) return false; if (!writer.writeString("bool motorVelocity_isValid")) return false; } if (field=="motorAcceleration") { if (!writer.writeListHeader(1)) return false; if (!writer.writeString("yarp::sig::VectorOf<double> motorAcceleration")) return false; } if (field=="motorAcceleration_isValid") { if (!writer.writeListHeader(1)) return false; if (!writer.writeString("bool motorAcceleration_isValid")) return false; } if (field=="torque") { if (!writer.writeListHeader(1)) return false; if (!writer.writeString("yarp::sig::VectorOf<double> torque")) return false; } if (field=="torque_isValid") { if (!writer.writeListHeader(1)) return false; if (!writer.writeString("bool torque_isValid")) return false; } if (field=="pwmDutycycle") { if (!writer.writeListHeader(1)) return false; if (!writer.writeString("yarp::sig::VectorOf<double> pwmDutycycle")) return false; } if (field=="pwmDutycycle_isValid") { if (!writer.writeListHeader(1)) return false; if (!writer.writeString("bool pwmDutycycle_isValid")) return false; } if (field=="current") { if (!writer.writeListHeader(1)) return false; if (!writer.writeString("yarp::sig::VectorOf<double> current")) return false; } if (field=="current_isValid") { if (!writer.writeListHeader(1)) return false; if (!writer.writeString("bool current_isValid")) return false; } if (field=="controlMode") { if (!writer.writeListHeader(1)) return false; if (!writer.writeString("yarp::sig::VectorOf<int> controlMode")) return false; } if (field=="controlMode_isValid") { if (!writer.writeListHeader(1)) return false; if (!writer.writeString("bool controlMode_isValid")) return false; } if (field=="interactionMode") { if (!writer.writeListHeader(1)) return false; if (!writer.writeString("yarp::sig::VectorOf<int> interactionMode")) return false; } if (field=="interactionMode_isValid") { if (!writer.writeListHeader(1)) return false; if (!writer.writeString("bool interactionMode_isValid")) return false; } } if (!writer.writeListHeader(23)) return false; writer.writeString("*** Available fields:"); writer.writeString("jointPosition"); writer.writeString("jointPosition_isValid"); writer.writeString("jointVelocity"); writer.writeString("jointVelocity_isValid"); writer.writeString("jointAcceleration"); writer.writeString("jointAcceleration_isValid"); writer.writeString("motorPosition"); writer.writeString("motorPosition_isValid"); writer.writeString("motorVelocity"); writer.writeString("motorVelocity_isValid"); writer.writeString("motorAcceleration"); writer.writeString("motorAcceleration_isValid"); writer.writeString("torque"); writer.writeString("torque_isValid"); writer.writeString("pwmDutycycle"); writer.writeString("pwmDutycycle_isValid"); writer.writeString("current"); writer.writeString("current_isValid"); writer.writeString("controlMode"); writer.writeString("controlMode_isValid"); writer.writeString("interactionMode"); writer.writeString("interactionMode_isValid"); return true; } bool nested = true; bool have_act = false; if (tag!="patch") { if ((len-1)%2 != 0) return false; len = 1 + ((len-1)/2); nested = false; have_act = true; } for (int i=1; i<len; i++) { if (nested && !reader.readListHeader(3)) return false; std::string act; std::string key; if (have_act) { act = tag; } else { if (!reader.readString(act)) return false; } if (!reader.readString(key)) return false; // inefficient code follows, bug paulfitz to improve it if (key == "jointPosition") { will_set_jointPosition(); if (!obj->nested_read_jointPosition(reader)) return false; did_set_jointPosition(); } else if (key == "jointPosition_isValid") { will_set_jointPosition_isValid(); if (!obj->nested_read_jointPosition_isValid(reader)) return false; did_set_jointPosition_isValid(); } else if (key == "jointVelocity") { will_set_jointVelocity(); if (!obj->nested_read_jointVelocity(reader)) return false; did_set_jointVelocity(); } else if (key == "jointVelocity_isValid") { will_set_jointVelocity_isValid(); if (!obj->nested_read_jointVelocity_isValid(reader)) return false; did_set_jointVelocity_isValid(); } else if (key == "jointAcceleration") { will_set_jointAcceleration(); if (!obj->nested_read_jointAcceleration(reader)) return false; did_set_jointAcceleration(); } else if (key == "jointAcceleration_isValid") { will_set_jointAcceleration_isValid(); if (!obj->nested_read_jointAcceleration_isValid(reader)) return false; did_set_jointAcceleration_isValid(); } else if (key == "motorPosition") { will_set_motorPosition(); if (!obj->nested_read_motorPosition(reader)) return false; did_set_motorPosition(); } else if (key == "motorPosition_isValid") { will_set_motorPosition_isValid(); if (!obj->nested_read_motorPosition_isValid(reader)) return false; did_set_motorPosition_isValid(); } else if (key == "motorVelocity") { will_set_motorVelocity(); if (!obj->nested_read_motorVelocity(reader)) return false; did_set_motorVelocity(); } else if (key == "motorVelocity_isValid") { will_set_motorVelocity_isValid(); if (!obj->nested_read_motorVelocity_isValid(reader)) return false; did_set_motorVelocity_isValid(); } else if (key == "motorAcceleration") { will_set_motorAcceleration(); if (!obj->nested_read_motorAcceleration(reader)) return false; did_set_motorAcceleration(); } else if (key == "motorAcceleration_isValid") { will_set_motorAcceleration_isValid(); if (!obj->nested_read_motorAcceleration_isValid(reader)) return false; did_set_motorAcceleration_isValid(); } else if (key == "torque") { will_set_torque(); if (!obj->nested_read_torque(reader)) return false; did_set_torque(); } else if (key == "torque_isValid") { will_set_torque_isValid(); if (!obj->nested_read_torque_isValid(reader)) return false; did_set_torque_isValid(); } else if (key == "pwmDutycycle") { will_set_pwmDutycycle(); if (!obj->nested_read_pwmDutycycle(reader)) return false; did_set_pwmDutycycle(); } else if (key == "pwmDutycycle_isValid") { will_set_pwmDutycycle_isValid(); if (!obj->nested_read_pwmDutycycle_isValid(reader)) return false; did_set_pwmDutycycle_isValid(); } else if (key == "current") { will_set_current(); if (!obj->nested_read_current(reader)) return false; did_set_current(); } else if (key == "current_isValid") { will_set_current_isValid(); if (!obj->nested_read_current_isValid(reader)) return false; did_set_current_isValid(); } else if (key == "controlMode") { will_set_controlMode(); if (!obj->nested_read_controlMode(reader)) return false; did_set_controlMode(); } else if (key == "controlMode_isValid") { will_set_controlMode_isValid(); if (!obj->nested_read_controlMode_isValid(reader)) return false; did_set_controlMode_isValid(); } else if (key == "interactionMode") { will_set_interactionMode(); if (!obj->nested_read_interactionMode(reader)) return false; did_set_interactionMode(); } else if (key == "interactionMode_isValid") { will_set_interactionMode_isValid(); if (!obj->nested_read_interactionMode_isValid(reader)) return false; did_set_interactionMode_isValid(); } else { // would be useful to have a fallback here } } reader.accept(); yarp::os::idl::WireWriter writer(reader); if (writer.isNull()) return true; writer.writeListHeader(1); writer.writeVocab(yarp::os::createVocab('o','k')); return true; }
/** * \brief Constructor. Load an image from a jpeg file. * \param f Jpeg file. */ claw::graphic::jpeg::jpeg( std::istream& f ) { reader(*this, f); } // jpeg::jpeg() [constructor, from file]
zip_result inflate(io::read_map& src, io::write_map& dest, zip_format format, dict_type dict, heap* h){ inflate_reader reader(src, format, long_size_t(-1), dict, h); iref<io::reader> from(reader); io::copy_data(from.get<io::reader>(), dest); return zip_result{ze_ok, src.size(), dest.size()}; }
zip_result inflate(io::reader& src, io::writer& dest, zip_format format, dict_type dict,heap* h ){ inflate_reader reader(src, format, long_size_t(-1), dict, h); iref<io::reader> from(reader); auto size = io::copy_data(from.get<io::reader>(), dest); return zip_result{ze_ok, reader.compressed_size(), size}; }
int main(int argc, char *argv[]){ if ( argc < 3 ){ cout << "execute as ./rec_had_show <param file> <no. events>" <<endl; exit(1); } bool succ; double truP[3], recDir[3]; string param_file = argv[1]; int nEvent = atoi( argv[2] ); bhep::gstore data_store; bhep::sreader reader(data_store); reader.file(param_file); reader.group("DATA"); reader.read(); bhep::sreader reader2(data_store); reader2.file(param_file); reader2.group("ANA");reader2.read(); //EventManager2 *eman = new EventManager2(data_store,bhep::MUTE); //eman->initialize(); bhep::reader_root inDst; inDst.open( data_store.fetch_sstore("idst_file") ); shower_rec* recon = new shower_rec(); recon->initialize( data_store.fetch_dstore("tol"), data_store.fetch_dstore("res") ); TFile *output = new TFile("test_out.root", "recreate"); TTree *data = new TTree("t1","had. rec. info."); data->Branch("Success",&succ,"succ/B"); data->Branch("TrueMom",&truP,"truP[3]/D"); data->Branch("RecDirection",&recDir,"dir[3]/D"); measurement_vector meas; EVector vert(3,0); for (int i = 0;i < nEvent;i++){ //succ = eman->status(); //if ( !succ ) return -1; //bhep::event& e = eman->read(); bhep::event& e = inDst.read_event( i ); std::cout << "...got event " << i <<std::endl; get_event_data( e, meas, vert, truP ); if ( meas.size() != 0 ){ shower *had_show = new shower( meas, vert ); succ = recon->execute( *had_show ); recDir[0] = had_show->get_direction()[0]; recDir[1] = had_show->get_direction()[1]; recDir[2] = had_show->get_direction()[2]; data->Fill(); delete had_show; stc_tools::destroy( meas ); } } output->Write(); output->Close(); recon->finalize(); //eman->finalize(); inDst.close(); return 0; }
int main(int argc, char *argv[]) { enum ExitCode { Success, ParseFailure, ArgumentError, WriteError, FileFailure }; QCoreApplication app(argc, argv); QTextStream errorStream(stderr); if (argc != 2) { errorStream << PrettyPrint::tr( "Usage: prettyprint <path to XML file>\n"); return ArgumentError; } QString inputFilePath(QCoreApplication::arguments().at(1)); QFile inputFile(inputFilePath); if (!QFile::exists(inputFilePath)) { errorStream << PrettyPrint::tr( "File %1 does not exist.\n").arg(inputFilePath); return FileFailure; } else if (!inputFile.open(QIODevice::ReadOnly)) { errorStream << PrettyPrint::tr( "Failed to open file %1.\n").arg(inputFilePath); return FileFailure; } QFile outputFile; if (!outputFile.open(stdout, QIODevice::WriteOnly)) { QTextStream(stderr) << PrettyPrint::tr("Failed to open stdout."); return WriteError; } QXmlStreamReader reader(&inputFile); int indentation = 0; QHash<int,QPair<int, int> > indentationStack; while (!reader.atEnd()) { reader.readNext(); if (reader.isStartElement()) { indentationStack[indentation] = QPair<int,int>( reader.lineNumber(), reader.columnNumber()); indentation += 1; } else if (reader.isEndElement()) { indentationStack.remove(indentation); indentation -= 1; } if (reader.error()) { errorStream << PrettyPrint::tr( "Error: %1 in file %2 at line %3, column %4.\n").arg( reader.errorString(), inputFilePath, QString::number(reader.lineNumber()), QString::number(reader.columnNumber())); if (indentationStack.contains(indentation-1)) { int line = indentationStack[indentation-1].first; int column = indentationStack[indentation-1].second; errorStream << PrettyPrint::tr( "Opened at line %1, column %2.\n").arg( QString::number(line), QString::number(column)); } return ParseFailure; } else if (reader.isStartElement() && !reader.name().isEmpty()) { outputFile.write(QByteArray().fill(' ', indentation)); outputFile.write(reader.name().toString().toLocal8Bit()); outputFile.write(QString(" line %1, column %2\n").arg( reader.lineNumber()).arg(reader.columnNumber()).toLocal8Bit()); } } return Success; }
void ThousandClientDataParser::incomingData() { QueryStruct query; quint16 blockSize = 0; QTcpSocket *socket = workClient->connection; QDataStream stream(socket); quint16 requestSize = sizeof(QueryStruct) - 2 * sizeof(quint16); QByteArray incomingRequest; while (requestSize) { blockSize = socket->bytesAvailable(); if (blockSize > requestSize) blockSize = requestSize; if (!blockSize) { emit(workClient->erorText("Invalid size of query")); break; } char *buffer = new char[blockSize]; stream.readRawData(buffer, blockSize); incomingRequest += QByteArray::fromRawData(buffer, blockSize); requestSize -= blockSize; blockSize = 0; delete []buffer; } QDataStream reader(incomingRequest); reader>>query; //Извлекаем структуру с запросом из входящего потока QByteArray data; requestSize = query.size; while (requestSize) { blockSize = socket->bytesAvailable(); if (blockSize > requestSize) blockSize = requestSize; if (!blockSize) { emit(workClient->erorText("Invalid size of query")); break; } char *buffer = new char[blockSize]; stream.readRawData(buffer, blockSize); data += QByteArray::fromRawData(buffer, blockSize); requestSize -= blockSize; blockSize = 0; delete []buffer; } switch(query.type) { case REGISTER: inRegistration(data); break; case AUTHORIZATION: inAuthorization(data); break; case MESSAGE: inMessage(data); break; case NEWGAME: inNewGame(data); break; case CONNECTGAME: inConnectToGame(data); break; case DISCONNECTGAME: inDisconnectGame(data); break; case STARTGAME: inStartGame(data); break; case CANCELGAME: inCancelGame(data); break; case FINISHGAME: inFinishGame(data); break; case LISTALLCURRENTGAME: inListAllGame(data); break; case LISTALLNEWGAME: inListAllNewGame(data); break; case TOTALSTATISTICS: inTotalStatistics(data); break; case PLAYERSTATISTICS: inPlayerStatistics(data); break; case MOVE: inMove(data); break; } }
void tst_QCameraBackend::testCaptureToBuffer() { QCamera camera; QCameraImageCapture imageCapture(&camera); camera.exposure()->setFlashMode(QCameraExposure::FlashOff); camera.load(); #ifdef Q_WS_MAEMO_6 QVERIFY(imageCapture.isCaptureDestinationSupported(QCameraImageCapture::CaptureToBuffer)); #endif if (!imageCapture.isCaptureDestinationSupported(QCameraImageCapture::CaptureToBuffer)) QSKIP("Buffer capture not supported"); QTRY_COMPARE(camera.status(), QCamera::LoadedStatus); QCOMPARE(imageCapture.bufferFormat(), QVideoFrame::Format_Jpeg); QVERIFY(imageCapture.isCaptureDestinationSupported(QCameraImageCapture::CaptureToFile)); QVERIFY(imageCapture.isCaptureDestinationSupported(QCameraImageCapture::CaptureToBuffer)); QVERIFY(imageCapture.isCaptureDestinationSupported( QCameraImageCapture::CaptureToBuffer | QCameraImageCapture::CaptureToFile)); QSignalSpy destinationChangedSignal(&imageCapture, SIGNAL(captureDestinationChanged(QCameraImageCapture::CaptureDestinations))); QCOMPARE(imageCapture.captureDestination(), QCameraImageCapture::CaptureToFile); imageCapture.setCaptureDestination(QCameraImageCapture::CaptureToBuffer); QCOMPARE(imageCapture.captureDestination(), QCameraImageCapture::CaptureToBuffer); QCOMPARE(destinationChangedSignal.size(), 1); QCOMPARE(destinationChangedSignal.first().first().value<QCameraImageCapture::CaptureDestinations>(), QCameraImageCapture::CaptureToBuffer); QSignalSpy capturedSignal(&imageCapture, SIGNAL(imageCaptured(int,QImage))); QSignalSpy imageAvailableSignal(&imageCapture, SIGNAL(imageAvailable(int,QVideoFrame))); QSignalSpy savedSignal(&imageCapture, SIGNAL(imageSaved(int,QString))); QSignalSpy errorSignal(&imageCapture, SIGNAL(error(int, QCameraImageCapture::Error,QString))); camera.start(); QTRY_VERIFY(imageCapture.isReadyForCapture()); int id = imageCapture.capture(); QTRY_VERIFY(!imageAvailableSignal.isEmpty()); QVERIFY(errorSignal.isEmpty()); QVERIFY(!capturedSignal.isEmpty()); QVERIFY(!imageAvailableSignal.isEmpty()); QTest::qWait(2000); QVERIFY(savedSignal.isEmpty()); QCOMPARE(capturedSignal.first().first().toInt(), id); QCOMPARE(imageAvailableSignal.first().first().toInt(), id); QVideoFrame frame = imageAvailableSignal.first().last().value<QVideoFrame>(); QVERIFY(frame.isValid()); QCOMPARE(frame.pixelFormat(), QVideoFrame::Format_Jpeg); QVERIFY(!frame.size().isEmpty()); QVERIFY(frame.map(QAbstractVideoBuffer::ReadOnly)); QByteArray data((const char *)frame.bits(), frame.mappedBytes()); frame.unmap(); frame = QVideoFrame(); QVERIFY(!data.isEmpty()); QBuffer buffer; buffer.setData(data); buffer.open(QIODevice::ReadOnly); QImageReader reader(&buffer, "JPG"); reader.setScaledSize(QSize(640,480)); QImage img(reader.read()); QVERIFY(!img.isNull()); capturedSignal.clear(); imageAvailableSignal.clear(); savedSignal.clear(); //Capture to yuv buffer #ifdef Q_WS_MAEMO_6 QVERIFY(imageCapture.supportedBufferFormats().contains(QVideoFrame::Format_UYVY)); #endif if (imageCapture.supportedBufferFormats().contains(QVideoFrame::Format_UYVY)) { imageCapture.setBufferFormat(QVideoFrame::Format_UYVY); QCOMPARE(imageCapture.bufferFormat(), QVideoFrame::Format_UYVY); id = imageCapture.capture(); QTRY_VERIFY(!imageAvailableSignal.isEmpty()); QVERIFY(errorSignal.isEmpty()); QVERIFY(!capturedSignal.isEmpty()); QVERIFY(!imageAvailableSignal.isEmpty()); QVERIFY(savedSignal.isEmpty()); QTest::qWait(2000); QVERIFY(savedSignal.isEmpty()); frame = imageAvailableSignal.first().last().value<QVideoFrame>(); QVERIFY(frame.isValid()); qDebug() << frame.pixelFormat(); QCOMPARE(frame.pixelFormat(), QVideoFrame::Format_UYVY); QVERIFY(!frame.size().isEmpty()); frame = QVideoFrame(); capturedSignal.clear(); imageAvailableSignal.clear(); savedSignal.clear(); imageCapture.setBufferFormat(QVideoFrame::Format_Jpeg); QCOMPARE(imageCapture.bufferFormat(), QVideoFrame::Format_Jpeg); } //Try to capture to both buffer and file #ifdef Q_WS_MAEMO_6 QVERIFY(imageCapture.isCaptureDestinationSupported(QCameraImageCapture::CaptureToBuffer | QCameraImageCapture::CaptureToFile)); #endif if (imageCapture.isCaptureDestinationSupported(QCameraImageCapture::CaptureToBuffer | QCameraImageCapture::CaptureToFile)) { imageCapture.setCaptureDestination(QCameraImageCapture::CaptureToBuffer | QCameraImageCapture::CaptureToFile); int oldId = id; id = imageCapture.capture(); QVERIFY(id != oldId); QTRY_VERIFY(!savedSignal.isEmpty()); QVERIFY(errorSignal.isEmpty()); QVERIFY(!capturedSignal.isEmpty()); QVERIFY(!imageAvailableSignal.isEmpty()); QVERIFY(!savedSignal.isEmpty()); QCOMPARE(capturedSignal.first().first().toInt(), id); QCOMPARE(imageAvailableSignal.first().first().toInt(), id); frame = imageAvailableSignal.first().last().value<QVideoFrame>(); QVERIFY(frame.isValid()); QCOMPARE(frame.pixelFormat(), QVideoFrame::Format_Jpeg); QVERIFY(!frame.size().isEmpty()); QString fileName = savedSignal.first().last().toString(); QVERIFY(QFileInfo(fileName).exists()); } }
// This normalizes a set of vertices in any format to SimpleVertex format, by processing away morphing AND skinning. // The rest of the transform pipeline like lighting will go as normal, either hardware or software. // The implementation is initially a bit inefficient but shouldn't be a big deal. // An intermediate buffer of not-easy-to-predict size is stored at bufPtr. u32 TransformDrawEngine::NormalizeVertices(u8 *outPtr, u8 *bufPtr, const u8 *inPtr, VertexDecoder *dec, int lowerBound, int upperBound, u32 vertType) { // First, decode the vertices into a GPU compatible format. This step can be eliminated but will need a separate // implementation of the vertex decoder. dec->DecodeVerts(bufPtr, inPtr, lowerBound, upperBound); // OK, morphing eliminated but bones still remain to be taken care of. // Let's do a partial software transform where we only do skinning. VertexReader reader(bufPtr, dec->GetDecVtxFmt(), vertType); SimpleVertex *sverts = (SimpleVertex *)outPtr; const u8 defaultColor[4] = { (u8)gstate.getMaterialAmbientR(), (u8)gstate.getMaterialAmbientG(), (u8)gstate.getMaterialAmbientB(), (u8)gstate.getMaterialAmbientA(), }; // Let's have two separate loops, one for non skinning and one for skinning. if (!g_Config.bSoftwareSkinning && (vertType & GE_VTYPE_WEIGHT_MASK) != GE_VTYPE_WEIGHT_NONE) { int numBoneWeights = vertTypeGetNumBoneWeights(vertType); for (int i = lowerBound; i <= upperBound; i++) { reader.Goto(i); SimpleVertex &sv = sverts[i]; if (vertType & GE_VTYPE_TC_MASK) { reader.ReadUV(sv.uv); } if (vertType & GE_VTYPE_COL_MASK) { reader.ReadColor0_8888(sv.color); } else { memcpy(sv.color, defaultColor, 4); } float nrm[3], pos[3]; float bnrm[3], bpos[3]; if (vertType & GE_VTYPE_NRM_MASK) { // Normals are generated during tesselation anyway, not sure if any need to supply reader.ReadNrm(nrm); } else { nrm[0] = 0; nrm[1] = 0; nrm[2] = 1.0f; } reader.ReadPos(pos); // Apply skinning transform directly float weights[8]; reader.ReadWeights(weights); // Skinning Vec3f psum(0,0,0); Vec3f nsum(0,0,0); for (int w = 0; w < numBoneWeights; w++) { if (weights[w] != 0.0f) { Vec3ByMatrix43(bpos, pos, gstate.boneMatrix+w*12); Vec3f tpos(bpos); psum += tpos * weights[w]; Norm3ByMatrix43(bnrm, nrm, gstate.boneMatrix+w*12); Vec3f tnorm(bnrm); nsum += tnorm * weights[w]; } } sv.pos = psum; sv.nrm = nsum; } } else { for (int i = lowerBound; i <= upperBound; i++) { reader.Goto(i); SimpleVertex &sv = sverts[i]; if (vertType & GE_VTYPE_TC_MASK) { reader.ReadUV(sv.uv); } else { sv.uv[0] = 0; // This will get filled in during tesselation sv.uv[1] = 0; } if (vertType & GE_VTYPE_COL_MASK) { reader.ReadColor0_8888(sv.color); } else { memcpy(sv.color, defaultColor, 4); } if (vertType & GE_VTYPE_NRM_MASK) { // Normals are generated during tesselation anyway, not sure if any need to supply reader.ReadNrm((float *)&sv.nrm); } else { sv.nrm.x = 0; sv.nrm.y = 0; sv.nrm.z = 1.0f; } reader.ReadPos((float *)&sv.pos); } } // Okay, there we are! Return the new type (but keep the index bits) return GE_VTYPE_TC_FLOAT | GE_VTYPE_COL_8888 | GE_VTYPE_NRM_FLOAT | GE_VTYPE_POS_FLOAT | (vertType & (GE_VTYPE_IDX_MASK | GE_VTYPE_THROUGH)); }
void NewGameTab::addImage(const QString& image) { QImageReader reader(image); if (!reader.canRead()) { return; } // Find image ID QString filename; int image_id = 0; QString image_hash = hash(image); QSettings details(Path::image("details"), QSettings::IniFormat); QStringList images = QDir(Path::images(), "*.*").entryList(QDir::Files); for (const QString& file : images) { image_id = std::max(image_id, file.section(".", 0, 0).toInt()); QString key = file + "/SHA1"; if (!details.contains(key)) { details.setValue(key, hash(Path::image(file))); } if (details.value(key) == image_hash) { filename = file; break; } } image_id++; QListWidgetItem* item = 0; if (filename.isEmpty()) { // Find filename QFileInfo info(image); filename = QString("%1.%2").arg(image_id).arg(info.suffix().toLower()); details.setValue(filename + "/SHA1", image_hash); details.setValue(filename + "/Name", info.completeBaseName()); m_image_tags->addImage(filename); // Copy and rotate image reader.setAutoTransform(true); if (reader.transformation() == QImageIOHandler::TransformationNone) { QFile::copy(image, Path::image(filename)); } else { QImage image = reader.read(); image.save(Path::image(filename), "", 100); } } else { // Find in list of images for (int i = 0; i < m_images->count(); ++i) { if (m_images->item(i)->data(ImageRole).toString() == filename) { item = m_images->item(i); break; } } } // Select item if (!item) { m_images->blockSignals(true); item = createItem(filename, details); m_images->blockSignals(false); m_images->setCurrentItem(item); } m_images->setCurrentItem(item); m_images->scrollToItem(item, QAbstractItemView::PositionAtTop); }
void MapViewerMain::showEvent(QShowEvent* event){ if(!event->spontaneous()){ if(this->storage.open("/Applications/World of Warcraft/data")){ qDebug() << "Opened storage!"; }else qDebug() << "Open error: " << this->storage.errorString(); CascFile mapDbc; mapDbc.setStorage(this->storage); mapDbc.setFileName("DBFilesClient/Map.dbc"); if(!mapDbc.open(CascFile::ReadOnly)){ qFatal("Unabel to open Map.dbc!"); qApp->quit(); return; } DBCReader reader(&mapDbc); reader.setFormat(DBCMap()); QList<QTreeWidgetItem*> treeItems; while(!reader.atEnd()){ QMap<QString, QVariant> entry = reader.nextRow(); qDebug() << entry["Directory"].toString(); if(entry["ParentMapId"].toInt() == -1){ QTreeWidgetItem* item = new QTreeWidgetItem(); item->setText(0, entry["ID"].toString()+" - "+entry["MapName"].toString()); item->setData(0, Qt::UserRole, entry); treeItems << item; }else{ bool fFound = false; foreach(QTreeWidgetItem* parentItem, treeItems){ if(parentItem->data(0, Qt::UserRole).toMap()["ID"].toInt() == entry["ParentMapId"].toInt()){ QTreeWidgetItem* item = new QTreeWidgetItem(); item->setText(0, entry["ID"].toString()+" - "+entry["MapName"].toString()); item->setData(0, Qt::UserRole, entry); parentItem->addChild(item); fFound = true; break; } } if(!fFound){ qWarning() << entry["MapName"].toString(); qWarning() << "Parent Map not found!"; QTreeWidgetItem* item = new QTreeWidgetItem(); item->setText(0, entry["ID"].toString()+" - "+entry["MapName"].toString()); item->setData(0, Qt::UserRole, entry); treeItems << item; } } } ui->mapTree->addTopLevelItems(treeItems); } }
bool StartDAT::open(const PG::UTIL::File& file, PercentIndicator* percent){ clear(); m_file = file; if(!m_file.exists() ){ PG_ERROR_STREAM("Target file '"<<file<<"' does not exist!"); m_file.clear(); return true; } readFileNames(); try{ PG::STREAM::InByteFile reader(m_file); if(!reader.isopen()) return true; const unsigned int file_size = reader.size(); const unsigned int number_of_files = reader.readUnsignedInt(); //test if this is a IMY file { const unsigned int v1 = reader.readUnsignedInt(); const unsigned int v2 = reader.readUnsignedInt(); if(v1 > v2){ m_isCompressed = true; }else{ m_isCompressed = false; } reader.seek(4); } const unsigned int header_size = (m_isCompressed)? 8+number_of_files*sizeof(int) : 4+number_of_files*sizeof(int); if(m_isCompressed) reader.skip(4); if(number_of_files > 9000){ PG_ERROR_STREAM("START.DAT is too big!"); return true; } //reader.skip(sizeof(int)); unsigned int lastOffset = reader.readUnsignedInt(); for(unsigned int i = 0; i < number_of_files; ++i){ fileInfo info; info.offset = lastOffset; if(i != number_of_files-1) lastOffset = reader.readUnsignedInt(); else lastOffset = file_size; if(lastOffset < info.offset){ PG_ERROR_STREAM("File offset order is wrong! ("<<lastOffset <<" < "<<info.offset<<") at: "<<reader.pos()); return true; } info.size = lastOffset-info.offset; if(info.offset < header_size){ PG_ERROR_STREAM("File offset is smaller then the header! ("<<info.offset <<" < "<<header_size<<")"); return true; } if((info.offset+info.size) > file_size){ PG_ERROR_STREAM("File is outside the range ("<< (info.offset+info.size) << " > " << file_size <<")!"); return true; } const unsigned int currentPos = reader.pos(); if( !m_isCompressed && i < m_namesTable.size() && !m_namesTable[i].empty() ){ info.name = m_namesTable[i]; reader.seek(info.offset); if(isTX2(reader)){ if(info.name.getFileExtension() != "TX2") info.name = info.name.getName()+".TX2"; info.fileType = fileInfo::TX2; }else if(info.name.getFileExtension() == "TX2") info.name = info.name.getName()+".NOT"; }else{ std::stringstream o; o<<"FILE"; o.fill('0'); o.width(4); o<<i<<"."; reader.seek(info.offset); if(isIMY(reader)){ o<<"IMY"; info.fileType = fileInfo::IMY; }else{ reader.seek(info.offset); if(isTX2(reader)){ o<<"TX2"; info.fileType = fileInfo::TX2; }else o<<"DAT"; } info.name = o.str(); } reader.seek(currentPos); m_fileInfos.push_back(info); } reader.close(); if(m_fileInfos.empty()){ PG_ERROR_STREAM("No files found inside!"); clear(); return true; } }catch (PG::UTIL::Exception& e) { PG_ERROR_STREAM("Couldn't read given PSPFS file '"<<file<<"': "<<e.what()); clear(); return true; }catch (...) { PG_ERROR_STREAM("Couldn't read given PSPFS file '"<<file<<"'!"); clear();; return true; } PG_INFO_STREAM("Opening done"); return false; }
DEF_TEST(Serialization, reporter) { // Test matrix serialization { SkMatrix matrix = SkMatrix::I(); TestObjectSerialization(&matrix, reporter); } // Test path serialization { SkPath path; TestObjectSerialization(&path, reporter); } // Test region serialization { SkRegion region; TestObjectSerialization(®ion, reporter); } // Test xfermode serialization { TestXfermodeSerialization(reporter); } // Test color filter serialization { TestColorFilterSerialization(reporter); } // Test string serialization { SkString string("string"); TestObjectSerializationNoAlign<SkString, false>(&string, reporter); TestObjectSerializationNoAlign<SkString, true>(&string, reporter); } // Test rrect serialization { // SkRRect does not initialize anything. // An uninitialized SkRRect can be serialized, // but will branch on uninitialized data when deserialized. SkRRect rrect; SkRect rect = SkRect::MakeXYWH(1, 2, 20, 30); SkVector corners[4] = { {1, 2}, {2, 3}, {3,4}, {4,5} }; rrect.setRectRadii(rect, corners); TestAlignment(&rrect, reporter); } // Test readByteArray { unsigned char data[kArraySize] = { 1, 2, 3 }; TestArraySerialization(data, reporter); } // Test readColorArray { SkColor data[kArraySize] = { SK_ColorBLACK, SK_ColorWHITE, SK_ColorRED }; TestArraySerialization(data, reporter); } // Test readIntArray { int32_t data[kArraySize] = { 1, 2, 4, 8 }; TestArraySerialization(data, reporter); } // Test readPointArray { SkPoint data[kArraySize] = { {6, 7}, {42, 128} }; TestArraySerialization(data, reporter); } // Test readScalarArray { SkScalar data[kArraySize] = { SK_Scalar1, SK_ScalarHalf, SK_ScalarMax }; TestArraySerialization(data, reporter); } // Test invalid deserializations { SkImageInfo info = SkImageInfo::MakeN32Premul(kBitmapSize, kBitmapSize); SkBitmap validBitmap; validBitmap.setInfo(info); // Create a bitmap with a really large height SkBitmap invalidBitmap; invalidBitmap.setInfo(info.makeWH(info.width(), 1000000000)); // The deserialization should succeed, and the rendering shouldn't crash, // even when the device fails to initialize, due to its size TestBitmapSerialization(validBitmap, invalidBitmap, true, reporter); } // Test simple SkPicture serialization { SkPictureRecorder recorder; draw_something(recorder.beginRecording(SkIntToScalar(kBitmapSize), SkIntToScalar(kBitmapSize), nullptr, 0)); sk_sp<SkPicture> pict(recorder.finishRecordingAsPicture()); // Serialize picture SkBinaryWriteBuffer writer; pict->flatten(writer); size_t size = writer.bytesWritten(); SkAutoTMalloc<unsigned char> data(size); writer.writeToMemory(static_cast<void*>(data.get())); // Deserialize picture SkValidatingReadBuffer reader(static_cast<void*>(data.get()), size); sk_sp<SkPicture> readPict(SkPicture::MakeFromBuffer(reader)); REPORTER_ASSERT(reporter, readPict.get()); } TestPictureTypefaceSerialization(reporter); // Test SkLightingShader/NormalMapSource serialization { const int kTexSize = 2; SkLights::Builder builder; builder.add(SkLights::Light(SkColor3f::Make(1.0f, 1.0f, 1.0f), SkVector3::Make(1.0f, 0.0f, 0.0f))); builder.add(SkLights::Light(SkColor3f::Make(0.2f, 0.2f, 0.2f))); sk_sp<SkLights> fLights = builder.finish(); SkBitmap diffuse = sk_tool_utils::create_checkerboard_bitmap( kTexSize, kTexSize, sk_tool_utils::color_to_565(0x0), sk_tool_utils::color_to_565(0xFF804020), 8); SkRect bitmapBounds = SkRect::MakeIWH(diffuse.width(), diffuse.height()); SkMatrix matrix; SkRect r = SkRect::MakeWH(SkIntToScalar(kTexSize), SkIntToScalar(kTexSize)); matrix.setRectToRect(bitmapBounds, r, SkMatrix::kFill_ScaleToFit); SkMatrix ctm; ctm.setRotate(45); SkBitmap normals; normals.allocN32Pixels(kTexSize, kTexSize); sk_tool_utils::create_frustum_normal_map(&normals, SkIRect::MakeWH(kTexSize, kTexSize)); sk_sp<SkShader> normalMap = SkMakeBitmapShader(normals, SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, &matrix, nullptr); sk_sp<SkNormalSource> normalSource = SkNormalSource::MakeFromNormalMap(std::move(normalMap), ctm); sk_sp<SkShader> lightingShader = SkLightingShader::Make(diffuse, fLights, &matrix, std::move(normalSource)); SkAutoTUnref<SkShader>(TestFlattenableSerialization(lightingShader.get(), true, reporter)); // TODO test equality? } }
bool NeuroMlReader::load(const std::string &path) { m_path = path; if(m_path.empty()) { cerr << "NeuroMlReader: Path is empty, cannot read file." << endl; return false; } m_cylinders.clear(); BoundingBox boundingBox; QString pathString = QString::fromStdString(path); QFile file(pathString); file.open(QFile::ReadOnly); if(!file.isOpen()) { cerr << "NeuroMlReader: Could not read file " << path << endl; return false; } QXmlStreamReader reader(&file); reader.readNext(); //Reading from the file QVector<Segment> segments; bool dummySegment = true; Segment segment; while (!reader.isEndDocument()) { if(reader.isStartElement()) { if(reader.name() == "segment") { if(!dummySegment) { if(!segment.hasProximal && !segment.hasParentID) { cerr << "WARNING: NeuroMlReader: Got segment without proximal or parent." << endl; } else if(!segment.hasDistal) { cerr << "WARNING: NeuroMlReader: Got segment without distal." << endl; } else { segments.append(segment); } } dummySegment = false; segment = Segment(); segment.id = reader.attributes().value("id").toInt(); if(reader.attributes().hasAttribute("parent")) { segment.parentID = reader.attributes().value("parent").toInt(); segment.hasParentID = true; } } if(reader.name() == "parent") { segment.parentID = reader.attributes().value("segment").toInt(); segment.hasParentID = true; } if(reader.name() == "proximal") { // qDebug() << reader.attributes().value("x") << reader.attributes().value("y") << reader.attributes().value("z"); segment.proximal = Point3D(reader.attributes().value("x").toDouble() * 1.0_um, reader.attributes().value("y").toDouble() * 1.0_um, reader.attributes().value("z").toDouble() * 1.0_um); segment.proximalWidth = reader.attributes().value("diameter").toDouble() * 1.0_um; segment.hasProximal = true; } if(reader.name() == "distal") { // qDebug() << reader.attributes().value("x") << reader.attributes().value("y") << reader.attributes().value("z") << reader.attributes().value("diameter"); segment.distal = Point3D(reader.attributes().value("x").toDouble() * 1.0_um, reader.attributes().value("y").toDouble() * 1.0_um, reader.attributes().value("z").toDouble() * 1.0_um); segment.distalWidth = reader.attributes().value("diameter").toDouble() * 1.0_um; segment.hasDistal = true; } } reader.readNext(); } segments.append(segment); for(Segment &segment : segments) { if(!segment.hasProximal && segment.hasParentID) { for(Segment &otherSegment : segments) { if(otherSegment.id == segment.parentID) { Segment &parent = otherSegment; segment.proximal = parent.distal; break; } } } if(segment.proximalWidth == 0.0_um) { segment.proximalWidth = segment.distalWidth; } } m_cylinders.clear(); for(const Segment &segment : segments) { CylinderFrustum cylinder(segment.proximal, segment.distal, segment.proximalWidth * 0.5, segment.distalWidth * 0.5); boundingBox = makeUnion(boundingBox, cylinder.start); boundingBox = makeUnion(boundingBox, cylinder.end); m_cylinders.push_back(cylinder); } m_boundingBox = boundingBox; return true; }