source: GTP/trunk/Lib/Vis/shared/EvalStats/EvalStats.cpp @ 675

// EvalStats.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"

#include <string>
#include <vector>
#include <istream>
#include <iostream>
#include <fstream>


using namespace std;

/** This is a small function which takes two log files and computes the
        difference in percent of the weighted render cost.
*/


struct RenderStats 
{
        float mRenderCost;
        float mAvgRenderCost;
};


typedef vector<RenderStats> StatsContainer;


enum {NO_TAG, RENDER_COST, AVG_RENDER_COST};


bool extractRenderStats(ifstream &file, StatsContainer &renderStats)
{
        if (!file.is_open())
                return false;
                
        string buf;

        int currentTag = NO_TAG;

        while (!(getline(file, buf)).eof())
        {
                //cout << "buf: " << buf << endl;

                if (buf[0] == '#')
                {
                        char entry[50]; 

                        sscanf(buf.c_str(), "#%s", entry);
                        
                        // new entry
                        if (strcmp(entry, "Pass") == 0)
                        {
                                //cout << "\nnew render stat " << endl;
                                renderStats.push_back(RenderStats());
                        }
                        else if (strcmp(entry, "TotalRenderCost") == 0)
                        {
                                currentTag = RENDER_COST;
                        }
                        else if (strcmp(entry, "AvgRenderCost") == 0)
                        {
                                currentTag = AVG_RENDER_COST;
                        }
                }
                else
                {
                        float val;
                        sscanf(buf.c_str(), "%f", &val);
                        
                        switch (currentTag)
                        {
                        case RENDER_COST:
                                //cout << "render cost: " << val << endl;
                renderStats.back().mRenderCost = val;
                                break;
                        case AVG_RENDER_COST:
                                //cout << "avg render cost: " << val << endl;
                                renderStats.back().mAvgRenderCost = val;
                                break;
                        default:
                                break;
                        }
                        
                        currentTag = NO_TAG;
                }
        }

        return true;
}



void ComputeStats(ofstream &statsOut, 
                                  const RenderStats &firstStats, 
                                  const RenderStats &currentStats, 
                                  const int index)
{
        float denom = firstStats.mRenderCost ? firstStats.mRenderCost : 0.000001f;
        float costRatio = currentStats.mRenderCost / denom;
                        
        denom = firstStats.mAvgRenderCost ? firstStats.mAvgRenderCost : 0.000001f;
        float avgCostRatio = currentStats.mAvgRenderCost / denom;

        statsOut << "#ViewCells\n" << index + 1 << endl
                         //<< "#TotalRenderCostGain\n" << 100.0f - costRatio * 100.0f << endl
                         //<< "#AvgRenderCostGain\n" << 100.0f - avgCostRatio * 100.0f << endl << endl;
                         << "#TotalRenderCostRatio\n" << costRatio << endl
                         << "#AvgRenderCostRatio\n" << avgCostRatio << endl << endl;
}


int ComputeNoViewCells(const StatsContainer &firstStats, 
                                           const StatsContainer &currentStats)
{
        const int n = min((int)firstStats.size(), (int)currentStats.size());

        const float renderCost = (int)currentStats[n - 1].mRenderCost;

        int i = 0;
        while ((i ++ < (int)firstStats.size()) && (renderCost > (int)firstStats[i].mRenderCost));
        
        return i;
}


int _tmain(int argc, _TCHAR* argv[])
{
        vector<StatsContainer> renderStats;
        
        if (argc < 3)
        {
                cerr << "arguments missing. Usage: input1 input2 ... intputn" << endl;
                exit(1);
        }

        vector<string> outFilenames;

        // read input files from command line
        for (int i = 1; i < argc; ++ i)
        {
                StatsContainer currentStats;
      
                ifstream file;
                file.open(argv[i]);

                // extract the render cost
                cout << "extracting render cost of file " << argv[i] << endl;
        
                if (extractRenderStats(file, currentStats))
                {
                        renderStats.push_back(currentStats);

                        // create output file name
                        string fn = argv[i];
                
                        string::size_type pos = fn.find(".log", 0);
                        fn.erase(pos, 4);
                        //sscanf(argv[i], "%s.log", fn);
                        string outFilename = string(fn) + string("-ratio.log");

                        outFilenames.push_back(outFilename);
                }
                else
                {
                        cout << "could not open file!" << endl;
                }
        }

        //statsOut << "rc1 size: " << (int)renderCosts1.size() << " " << (int)renderCosts2.size() << endl << endl;
        vector<StatsContainer>::const_iterator it = renderStats.begin(), it_end = renderStats.end();
        vector<string>::const_iterator sit, sit_end = outFilenames.end();

        sit = outFilenames.begin();
        
        // compare all values with this vector
        StatsContainer &firstStats = renderStats[0];

        // don't compare with itself
        //++ it;
        //++ sit;

        for (it; it != it_end; ++ it)
        {
                cout << "now writing output to file " << *sit << endl;
                ofstream statsOut;
                statsOut.open((*sit).c_str());

                // compute size of output vector
                const int n = min((int)firstStats.size(), (int)(*it).size());
        
                for (int i = 0; i < n; ++ i)
                {
                        ComputeStats(statsOut, firstStats[i], (*it)[i], i);
                }
                
                int vc = ComputeNoViewCells(firstStats, *it);
                cout << "need " << vc << " view cells to reach rendercost of method " << i << " with " << n << " view cells" << endl;

                statsOut.close();
                
                ++ sit;
        }

        return 0;
}