コード例 #1
0
ファイル: TimeBench.hpp プロジェクト: Loopush/Loopop
	/*
	 * Prints the probe with the specified name. There
	 * are certain conditions that this method wont print
	 * anything:
	 *
	 * 1) No such probe exists.
	 * 2) The probe has not been closed.
	 */
	void printProbe(string s)
	{
		TimeProbe* tp;

		if (probes[s] == 0)
			return;
		tp = probes[s];

		if (tp->getStatus() != TimeProbe::CLOSED)
			return;

		timeval* t1 = tp->getStart();
		timeval* t2 = tp->getEnd();

		if (t1->tv_usec > t2->tv_usec)
		{
			t2->tv_usec += 1000000;
			t2->tv_sec--;
		}

		timeval lapsed;
		lapsed.tv_usec = t2->tv_usec - t1->tv_usec;
		lapsed.tv_sec = (int) (t2->tv_sec - t1->tv_sec);
		cout << s << ": ";
		printf("Time elapsed: %d.%06dsec\n", (int) lapsed.tv_sec,(int) lapsed.tv_usec);

	}
コード例 #2
0
ファイル: TimeBench.hpp プロジェクト: Loopush/Loopop
	/**
	 * Open the probe with the specified name and measures
	 * the time value at that point in the program's path
	 * of execution.
	 *
	 * If a probe for that name already exists, this method
	 * does nothing.
	 */
	void openProbe(string s)
	{
		TimeProbe* tp;

		if (probes[s] == 0)
		{
			tp = new TimeProbe();
			probes[s] = tp;
		}
		else
		{
			tp = probes[s];
		}
		if (tp->getStatus() != TimeProbe::INACTIVE)
			return;

		tp->setStatus(TimeProbe::OPEN);

		timeval* tv = new timeval();
		struct timezone tz;

		gettimeofday(tv, &tz);
		tp->setStart(tv);

	}
コード例 #3
0
ファイル: QueryResult.cpp プロジェクト: Web5design/firtex2
void QueryResult::init(const FieldSelector& selector, 
                       const IndexReaderPtr& pIndexReader,
                       const QueryHits& hits)
{
    StoredFieldsReaderPtr pStoredFieldsReader = pIndexReader->createStoredFieldsReader();
    if (pStoredFieldsReader.isNull())
    {
        return;
    }

    TimeProbe probe;
    probe.start();

    m_docs.reserve(hits.size());
    setTracer(hits.getTracer());

    setTotalHits(hits.getTotalHits());

    QueryHits::Iterator it = hits.iterator();
    while (it.hasNext())
    {
        const QueryHits::HitDoc& hitDoc = it.next();
        
        ResultDocPtr pResDoc(new ResultDoc(hitDoc.getDocId(), 
                        hitDoc.getScore(), selector.size()));
        addDoc(pResDoc);

        pStoredFieldsReader->getDocument(selector, *pResDoc);
    }

    probe.stop();
    FX_QUERY_TRACE(INFO, getTracer(), "fetch field time [%d] ms",
                   (int32_t)probe.elapsed() / 1000);
}
コード例 #4
0
void IndexBuilderAppRunner::buildIndex()
{
    try
    {
        cout << _T("Begin build index, config file: ") << m_sConfFile << endl;
        TimeProbe p;
        p.start();
        ProgressObserverPtr pOb(new ConsoleProgressObserver(1000));
        FX_NS(collection)::Collection::buildIndex(m_sConfFile, pOb);
        p.stop();
        cout << _T("Build index success! finished in ") << p.elapsedSeconds() 
             << _T(" s.") << endl;
    }
    catch(const FirteXException& fe)
    {
        cout << _T("Build index FAILED: ") << fe.what() << endl;
    }
}
コード例 #5
0
ファイル: TimeBench.hpp プロジェクト: Loopush/Loopop
	/**
	 * Closes the probe for the given name. If the probe
	 * is not open or if the probe is already closed this
	 * method does nothing.
	 */
	void closeProbe(string s)
	{

		TimeProbe* tp;
		if (probes[s] == 0)
			return;

		tp = probes[s];

		if (tp->getStatus() != TimeProbe::OPEN)
			return;

		timeval* tv = new timeval();
		struct timezone tz;
		gettimeofday(tv, NULL);
		tp->setEnd(tv);

		tp->setStatus(TimeProbe::CLOSED);

	}
コード例 #6
0
void LexiconBuilderAppRunner::buildLexicon()
{
    try
    {
        cout << "Begin build lexicon, source file: " << m_sSourceFile << endl
             << ", target file: " << m_sTargetFile << endl;

        TimeProbe p;
        DoubleArrayTrie trie(100000);
        trie.buildFromFile(m_sSourceFile);
        trie.save(m_sTargetFile);

        cout << _T("Build lexicon success! finished in ") << p.elapsedSeconds()
             << _T(" s.") << endl;
    }
    catch(const FirteXException& fe)
    {
        cout << _T("Build lexicon FAILED: ") << fe.what() << endl;
    }
}
コード例 #7
0
void GibbsTrackingFilter< ItkQBallImageType >::GenerateData()
{
    TimeProbe preClock; preClock.Start();
    // check if input is qball or tensor image and generate qball if necessary
    if (m_QBallImage.IsNull() && m_TensorImage.IsNotNull())
    {
        TensorImageToQBallImageFilter<float,float>::Pointer filter = TensorImageToQBallImageFilter<float,float>::New();
        filter->SetInput( m_TensorImage );
        filter->Update();
        m_QBallImage = filter->GetOutput();
    }
    else if (m_DuplicateImage) // generate local working copy of QBall image (if not disabled)
    {
        typedef itk::ImageDuplicator< ItkQBallImageType > DuplicateFilterType;
        typename DuplicateFilterType::Pointer duplicator = DuplicateFilterType::New();
        duplicator->SetInputImage( m_QBallImage );
        duplicator->Update();
        m_QBallImage = duplicator->GetOutput();
    }

    // perform mean subtraction on odfs
    typedef ImageRegionIterator< ItkQBallImageType > InputIteratorType;
    InputIteratorType it(m_QBallImage, m_QBallImage->GetLargestPossibleRegion() );
    it.GoToBegin();
    while (!it.IsAtEnd())
    {
        itk::OrientationDistributionFunction<float, QBALL_ODFSIZE> odf(it.Get().GetDataPointer());
        float mean = odf.GetMeanValue();
        odf -= mean;
        it.Set(odf.GetDataPointer());
        ++it;
    }

    // check if mask image is given if it needs resampling
    PrepareMaskImage();

    // load parameter file
    LoadParameters();

    // prepare parameters
    float minSpacing;
    if(m_QBallImage->GetSpacing()[0]<m_QBallImage->GetSpacing()[1] && m_QBallImage->GetSpacing()[0]<m_QBallImage->GetSpacing()[2])
        minSpacing = m_QBallImage->GetSpacing()[0];
    else if (m_QBallImage->GetSpacing()[1] < m_QBallImage->GetSpacing()[2])
        minSpacing = m_QBallImage->GetSpacing()[1];
    else
        minSpacing = m_QBallImage->GetSpacing()[2];

    if(m_ParticleLength == 0)
        m_ParticleLength = 1.5*minSpacing;
    if(m_ParticleWidth == 0)
        m_ParticleWidth = 0.5*minSpacing;

    if(m_ParticleWeight == 0)
        EstimateParticleWeight();

    float alpha = log(m_EndTemperature/m_StartTemperature);
    m_Steps = m_Iterations/10000;
    if (m_Steps<10)
        m_Steps = 10;
    if (m_Steps>m_Iterations)
    {
        MITK_INFO << "GibbsTrackingFilter: not enough iterations!";
        m_AbortTracking = true;
    }
    if (m_CurvatureThreshold < mitk::eps)
        m_CurvatureThreshold = 0;
    unsigned long singleIts = (unsigned long)((1.0*m_Iterations) / (1.0*m_Steps));

    // seed random generators
    Statistics::MersenneTwisterRandomVariateGenerator::Pointer randGen = Statistics::MersenneTwisterRandomVariateGenerator::New();
    if (m_RandomSeed>-1)
        randGen->SetSeed(m_RandomSeed);
    else
        randGen->SetSeed();

    // load sphere interpolator to evaluate the ODFs
    SphereInterpolator* interpolator = new SphereInterpolator(m_LutPath);

    // handle lookup table not found cases
    if( !interpolator->IsInValidState() )
    {
      m_IsInValidState = false;
      m_AbortTracking = true;
      m_BuildFibers = false;
      mitkThrow() << "Unable to load lookup tables.";
    }
    // initialize the actual tracking components (ParticleGrid, Metropolis Hastings Sampler and Energy Computer)
    ParticleGrid* particleGrid;
    GibbsEnergyComputer* encomp;
    MetropolisHastingsSampler* sampler;
    try{
        particleGrid = new ParticleGrid(m_MaskImage, m_ParticleLength, m_ParticleGridCellCapacity);
        encomp = new GibbsEnergyComputer(m_QBallImage, m_MaskImage, particleGrid, interpolator, randGen);
        encomp->SetParameters(m_ParticleWeight,m_ParticleWidth,m_ConnectionPotential*m_ParticleLength*m_ParticleLength,m_CurvatureThreshold,m_InexBalance,m_ParticlePotential);
        sampler = new MetropolisHastingsSampler(particleGrid, encomp, randGen, m_CurvatureThreshold);
    }
    catch(...)
    {
        MITK_ERROR  << "Particle grid allocation failed. Not enough memory? Try to increase the particle length.";
        m_IsInValidState = false;
        m_AbortTracking = true;
        m_BuildFibers = false;
        return;
    }

    MITK_INFO << "----------------------------------------";
    MITK_INFO << "Iterations: " << m_Iterations;
    MITK_INFO << "Steps: " << m_Steps;
    MITK_INFO << "Particle length: " << m_ParticleLength;
    MITK_INFO << "Particle width: " << m_ParticleWidth;
    MITK_INFO << "Particle weight: " << m_ParticleWeight;
    MITK_INFO << "Start temperature: " << m_StartTemperature;
    MITK_INFO << "End temperature: " << m_EndTemperature;
    MITK_INFO << "In/Ex balance: " << m_InexBalance;
    MITK_INFO << "Min. fiber length: " << m_MinFiberLength;
    MITK_INFO << "Curvature threshold: " << m_CurvatureThreshold;
    MITK_INFO << "Random seed: " << m_RandomSeed;
    MITK_INFO << "----------------------------------------";

    // main loop
    preClock.Stop();
    TimeProbe clock; clock.Start();
    m_NumAcceptedFibers = 0;
    unsigned long counter = 1;

    boost::progress_display disp(m_Steps*singleIts);
    if (!m_AbortTracking)
    for( m_CurrentStep = 1; m_CurrentStep <= m_Steps; m_CurrentStep++ )
    {
        // update temperatur for simulated annealing process
        float temperature = m_StartTemperature * exp(alpha*(((1.0)*m_CurrentStep)/((1.0)*m_Steps)));
        sampler->SetTemperature(temperature);

        for (unsigned long i=0; i<singleIts; i++)
        {
            ++disp;
            if (m_AbortTracking)
                break;

            sampler->MakeProposal();

            if (m_BuildFibers || (i==singleIts-1 && m_CurrentStep==m_Steps))
            {
                m_ProposalAcceptance = (float)sampler->GetNumAcceptedProposals()/counter;
                m_NumParticles = particleGrid->m_NumParticles;
                m_NumConnections = particleGrid->m_NumConnections;

                FiberBuilder fiberBuilder(particleGrid, m_MaskImage);
                m_FiberPolyData = fiberBuilder.iterate(m_MinFiberLength);
                m_NumAcceptedFibers = m_FiberPolyData->GetNumberOfLines();
                m_BuildFibers = false;
            }
            counter++;
        }

        m_ProposalAcceptance = (float)sampler->GetNumAcceptedProposals()/counter;
        m_NumParticles = particleGrid->m_NumParticles;
        m_NumConnections = particleGrid->m_NumConnections;

        if (m_AbortTracking)
            break;
    }
    if (m_AbortTracking)
    {
        FiberBuilder fiberBuilder(particleGrid, m_MaskImage);
        m_FiberPolyData = fiberBuilder.iterate(m_MinFiberLength);
        m_NumAcceptedFibers = m_FiberPolyData->GetNumberOfLines();
    }
    clock.Stop();

    delete sampler;
    delete encomp;
    delete interpolator;
    delete particleGrid;
    m_AbortTracking = true;
    m_BuildFibers = false;

    int h = clock.GetTotal()/3600;
    int m = ((int)clock.GetTotal()%3600)/60;
    int s = (int)clock.GetTotal()%60;
    MITK_INFO << "GibbsTrackingFilter: finished gibbs tracking in " << h << "h, " << m << "m and " << s << "s";
    m = (int)preClock.GetTotal()/60;
    s = (int)preClock.GetTotal()%60;
    MITK_INFO << "GibbsTrackingFilter: preparation of the data took " << m << "m and " << s << "s";
    MITK_INFO << "GibbsTrackingFilter: " << m_NumAcceptedFibers << " fibers accepted";

//    sampler->PrintProposalTimes();

    SaveParameters();
}
コード例 #8
0
void HTTPSearchService::handleQuery(const Statement& state,
                                EvHttpRequestContext* pCtx) const
{
    IndexReaderPtr pIndexReader = m_searchRes.getIndexReader();
    FIRTEX_ASSERT2(pIndexReader.isNotNull());

    try
    {
        TimeProbe probe;
        probe.start();

        QueryParser parser(pIndexReader->getAnalyzerMapper(),
                           m_searchRes.getDefaultField());

        IndexSearcher searcher(pIndexReader);
        QueryHitsPtr pHits = searcher.search(state, parser);

        QueryResult result;

        if (pHits.isNotNull())
        {
            FieldSelectClausePtr pFieldClause = state.getFieldSelectClause();
            QueryClausePtr pQueryClause = state.getQueryClause();
            if (pFieldClause.isNotNull() && pQueryClause.isNotNull())
            {
                QueryPtr pQuery = parser.parse(pQueryClause->getQueryString());
                FIRTEX_ASSERT2(pQuery.isNotNull());

                FieldSelector selector(pIndexReader->getDocSchema());
                
                for (size_t i = 0; i < pFieldClause->getFieldCount(); ++i)
                {
                    const FieldSelectClause::SnippetParam& param = pFieldClause->getField(i);
                    FieldFilterPtr pFieldFilter;
                    if (param.snippet)
                    {
                        SnippetGenerator* pSnippetGen = new SnippetGenerator();
                        pFieldFilter.reset(pSnippetGen);
                        
                        if (!pSnippetGen->init(pQuery, parser.getAnalyzerMapper(), param.field,
                                        param.preTag, param.postTag, param.separator))
                        {
                            FX_LOG(ERROR, "Init snippet generator for field: [%s] FAILED", param.field.c_str());
                            sendErrorMessage("Init snippet generator for field: " + 
                                    param.field + " FAILED", pCtx);
                            return;
                        }                        
                    }

                    if (!selector.addField(param.field, pFieldFilter))
                    {
                        FX_LOG(ERROR, "Invalid field: [%s]", param.field.c_str());
                    }
                }
                result.init(selector, pIndexReader, *pHits);
            }
            else
            {
                result.init(pIndexReader, *pHits);
            }
        }

        probe.stop();
        result.setTimeCost(probe.elapsed() / 1000);
        FX_QUERY_TRACE(INFO, result.getTracer(), "search phase time [%d]",
                       (int32_t)result.getTimeCost());

        stringstream ss;
        XMLResultFormatter formatter;
        formatter.format(result, ss);
        sendResponse(ss.str(), pCtx);
    }
    catch(const FirteXException& e)
    {
        FX_LOG(ERROR, "Handle request FAILED: [%s], reason: [%s]",
               pCtx->getQuery().c_str(), e.what().c_str());
        sendErrorMessage("Handle request failed", pCtx);
    }
}