Example #1
0
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
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;
}
Example #2
0
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
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;
}
Example #3
0
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;
}
Example #4
0
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(); 
}
Example #5
0
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);
      }
   }



}
Example #6
0
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();
}
Example #7
0
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;
} 
Example #9
0
bool jointData::read(yarp::os::ConnectionReader& connection) {
  yarp::os::idl::WireReader reader(connection);
  if (!reader.readListHeader(22)) return false;
  return read(reader);
}
Example #10
0
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;
}
Example #11
0
/**
 * \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]
Example #12
0
	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()};
	}
Example #13
0
	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};
	}
Example #14
0
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;
}
Example #15
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;
    }
}
Example #17
0
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());
    }
}
Example #18
0
// 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));
}
Example #19
0
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);
}
Example #20
0
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);
   }
}
Example #21
0
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;
}
Example #22
0
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(&region, 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?

    }
}
Example #23
0
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;
}