source: GTP/trunk/Lib/Vis/Preprocessing/src/RenderSampler.cpp @ 1004

#include "Environment.h"
#include "RenderSampler.h"
#include "GlRenderer.h"

namespace GtpVisibilityPreprocessor {


RenderSampler::RenderSampler():Preprocessor()
{
  Environment::GetSingleton()->GetIntValue("RenderSampler.samples", mSamples);
  cout << "number of render samples: " << mSamples << endl;
}

bool
RenderSampler::ComputeVisibility()
{
        long startTime = GetTime();
        
        int histoMaxVal = 0;
        int histoIntervals = 0;
        int threshold;
        bool useOcclusionQueries;

    Environment::GetSingleton()->GetIntValue("Preprocessor.histogram.maxValue", histoMaxVal);
        Environment::GetSingleton()->GetIntValue("Preprocessor.histogram.intervals", histoIntervals);
        Environment::GetSingleton()->GetIntValue("RenderSampler.visibleThreshold", threshold);
        Environment::GetSingleton()->GetBoolValue("RenderSampler.useOcclusionQueries", useOcclusionQueries);

        Debug << "************* render sampler ****************" << endl;
        Debug << "threshold: " << threshold << endl;
        const int intervals = histoIntervals;

        cout << "starting sampling of render cost ... ";

        vector<RenderCostSample> samples(mSamples);
  
        if (renderer)
        {
                renderer->SampleRenderCost(mSamples, samples, useOcclusionQueries, threshold);
        }

        cout << "finished in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;


        //-- Evaluate results   

        //-- compute histogram from the samples
        int avgPvs = 0;
        int maxPvs = 0;

        vector<int> histogram(intervals);
  

        // initialise histogram
        for (int i = 0; i < intervals; ++ i)
        {
                histogram[i] = 0;
        }

        // store maximal pvs
        for (int i = 0; i < mSamples; ++ i) 
        {
                if (samples[i].mVisibleObjects > maxPvs)
                {
                        maxPvs = samples[i].mVisibleObjects;
                }

                avgPvs += samples[i].mVisibleObjects;
        }

        // sometimes need need to unifiy maximum pvs to compare with other method's histograms
        // => choose histoMaxPvs accordingly (higher than all pvss) ( but smaller than highest possible pvs?)

        const int maxVal = max(histoMaxVal, maxPvs);
        //const int maxVal = min(max(histoMaxVal, maxPvs), mObjects.size());

        for (int i = 0; i < mSamples; ++ i) 
        {
                const int bin = (samples[i].mVisibleObjects * intervals) / maxVal;
                //const int bin = samples[i].mVisibleObjects;

                ++ histogram[bin];
        }


        //-- output the histogram

        const string filename("fromPointHisto.log");
        std::ofstream outstream;
        outstream.open(filename.c_str());


        Debug << "****************************************" << endl;
        Debug << "From point queries: " << endl;

        for (int i = 0; i < intervals; ++ i) 
        {
                outstream << "#Pass\n" << i << endl;
                outstream << "#Pvs\n" << (float)(i * maxVal) / (float)intervals << endl;

                // HACK: #point samples substitute for volume
                outstream << "#VolumeDif\n" << (float)histogram[i] / (float)mSamples << endl;
                //cout << histogram[i] << endl;
        }

        outstream.close();

        avgPvs /= mSamples;
                
        Debug << "max pvs: " << maxPvs << endl;
        Debug << "avg pvs: " << avgPvs << endl;
  
        return true;
}



}