source: GTP/trunk/Lib/Vis/Preprocessing/src/RandomViewCellsHandler.cpp @ 2686

#include "RandomViewCellsHandler.h"
#include "ViewCellsManager.h"
#include "ViewCellsParser.h"
#include "Preprocessor.h"
#include "GlRenderer.h"


namespace GtpVisibilityPreprocessor {


RandomViewCellsHandler::RandomViewCellsHandler(ViewCellsManager *vc): mViewCellsManager(vc)
{
}


RandomViewCellsHandler::~RandomViewCellsHandler()
{
        CLEAR_CONTAINER(mViewCellPointsList);
}


bool RandomViewCellsHandler::ExportRandomViewCells(const string &filename,
                                                                                         const vector<ViewCellPoints *> &viewCells)
{
        std::ofstream outStream;
        outStream.open(filename.c_str());

        vector<ViewCellPoints *>::const_iterator vit, vit_end = viewCells.end();
    
        for (vit = viewCells.begin(); vit != vit_end; ++ vit)
        {
                ViewCell *vc = (*vit)->first;

                outStream << "v " << vc->GetId() << endl;

                SimpleRayContainer viewPoints;
        
                SimpleRayContainer::const_iterator pit, pit_end = (*vit)->second.end();

                for (pit = (*vit)->second.begin(); pit != pit_end; ++ pit)
                {
                        const Vector3 pt = (*pit).mOrigin;
                        const Vector3 dir = (*pit).mDirection;

                        outStream << "p " << pt.x  << " " << pt.y  << " " << pt.z 
                                      << " "  << dir.x << " " << dir.y << " " << dir.z << endl;
                }
        }

        return true;
}


bool RandomViewCellsHandler::GenerateRandomViewCells(ViewCellPointsList &viewCells,
                                                                                                         const int nViewCells,
                                                                                                         const int nViewPoints)
{
        ViewCellContainer rViewCells;

        cout << "generating " << nViewCells << " random view cells" << endl;
        ///GenerateRandomViewCells(rViewCells, nViewCells);

        //cout << "finished" << endl;

        //for (int i = 0; i < viewCells.size(); ++ i)
        //      cout << "vc " << i << ": " << viewCells[i]->GetId() << endl;

        cout << "generating " << nViewPoints << " view points per view cell" << endl;
            
        int generatedViewCells = 0;
        int i = 0;
    while (generatedViewCells < nViewCells)
        {
                ++ i;
                
                const int idx = (int)RandomValue(0.0f, (float)mViewCellsManager->GetViewCells().size() - 0.5f);
                        
                ViewCell *viewCell = mViewCellsManager->GetViewCell(idx);
                
                cout << "testing view cell: " << viewCell->GetId() << endl;

                if (!viewCell->Mailed())
                {
                        viewCell->Mail();

                        SimpleRayContainer viewPoints;
                        
                        // generate random view points
                        if (IsValidViewSpace(viewCell) && 
                                GenerateViewPoints(viewCell, nViewPoints, viewPoints))
                        {
                                Debug << "vc: " << viewCell->GetId() << endl;

                                ViewCellPoints *vcPts = new ViewCellPoints();
                                viewCells.push_back(vcPts);

                                // valid view cell found
                                vcPts->first = viewCell;

                                // generate view points
                                ++ generatedViewCells;

                                SimpleRayContainer::const_iterator pit, pit_end = viewPoints.end();

                                for (pit = viewPoints.begin(); pit != pit_end; ++ pit)
                                {
                                        Debug << "vp: " << (*pit) << endl;
                                        vcPts->second.push_back(*pit);  
                                }
                                cout << "view cell " << generatedViewCells << " generated: " << viewCell->GetId() << endl;      
                        }
                        else
                        {
                                cout << "error: invalid view cell " << generatedViewCells << " with id " << viewCell->GetId() << endl;  
                        }
                }

                if (i > nViewCells * 1000000) // safety
                {
                        cout << "big error" << endl;
                        break;
                }
                cout << "processd view cells " << generatedViewCells << " of " << nViewCells << endl << endl;
        }

        return true;
}


bool RandomViewCellsHandler::ImportViewCellsList(const string &filename, 
                                                                                                 vector<ViewCellPoints *> &viewCells)
{
        ifstream inStream(filename.c_str());
        if (!inStream.is_open())
                return false;

        ViewCellPoints *currentViewCell = NULL;

        AxisAlignedBox3 bbox = mViewCellsManager->GetViewSpaceBox();

        string buf;
        while (!(getline(inStream, buf)).eof())
        {
                switch (buf[0])
                {
                case 'v':
                        {
                                int id;
                                sscanf(buf.c_str(), "v %d", &id);
                        
                                currentViewCell = new ViewCellPoints();
                                currentViewCell->first = mViewCellsManager->GetViewCellById(id);
                                        
                                viewCells.push_back(currentViewCell);

                                break;
                        }
                case 'p':
                        {
                                Vector3 pt, dir;
                                sscanf(buf.c_str(), "p %f %f %f %f %f %f", &pt.x, &pt.y, &pt.z, &dir.x, &dir.y, &dir.z);
                                
                                if (0)
                                {
                                        // add new point to view space box
                                        if (!bbox.IsInside(pt))
                                                bbox.Include(pt);
                                }
                                else
                                {
                                        // other variant: clamp to box
                                        bbox.ClampToBox(pt);
                                }

                                SimpleRay ray(pt, dir, 0, 1);

                                // no view cell specified => create dummy view cell
                                if (!currentViewCell)
                                {
                                        currentViewCell = new ViewCellPoints();
                                        viewCells.push_back(currentViewCell);
                                        currentViewCell->first = NULL;
                                }

                                currentViewCell->second.push_back(ray);

                                break;
                        }
                default:
                        break;
                }
        }

        // set updated view space box containing all view points
        mViewCellsManager->SetViewSpaceBox(bbox);

        return true;
}


bool RandomViewCellsHandler::ImportViewCellsList(const string &filename)
{
        return ImportViewCellsList(filename, mViewCellPointsList);
}


bool RandomViewCellsHandler::GenerateViewPoints(ViewCell *viewCell, 
                                                                                  const int numViewPoints,
                                                                                  SimpleRayContainer &viewPoints)
{
        bool success = true;
        int generatedPts = 0;
        int i = 0;

        cout << "generating view points for view cell " << viewCell->GetId() << endl;

        while (generatedPts < numViewPoints)
        {
                SimpleRay pt;

                if (GenerateViewPoint(viewCell, pt))
                {
                        ++ generatedPts;
                        cout << "generated view point " << generatedPts << endl;
                        viewPoints.push_back(pt);
                }

                // savety criterium
                if (++ i > numViewPoints * 3)
                {
                        return false;
                }
        }
        
        cout << "view point generation finished" << endl;

        return true;
}


bool RandomViewCellsHandler::ExportRandomViewCells(const string &filename)
{
        // export ten view cells with 100 random view points inside each
  const int numViewCells = 100;
  //  const int numViewPoints = 10;
  const int numViewPoints = 100;

        GenerateRandomViewCells(mViewCellPointsList, numViewCells, numViewPoints);

        //cout << "exporting random view cells" << endl;
        return ExportRandomViewCells(filename,  mViewCellPointsList);
}


bool RandomViewCellsHandler::GenerateViewPoint(ViewCell *viewCell, 
                                                                                           SimpleRay &ray)
{
        // do not use this function since it could return different 
        // viewpoints for different executions of the algorithm

        int tries = 0;
        Vector3 viewPoint, direction;
        const int maxTries = 10;

        while (1) 
        {
                // hack
                if (!viewCell->GetMesh())
                        mViewCellsManager->CreateMesh(viewCell);

        Mesh *mesh = viewCell->GetMesh();
                AxisAlignedBox3 box = mesh->mBox;
                
                Vector3 pVector = Vector3(Random(1.0f),
                                                                  Random(1.0f),
                                                                  Random(1.0f));

                viewPoint =  box.GetPoint(pVector);
        
                const Vector3 dVector = Vector3(2 * M_PI * Random(1.0f), M_PI * Random(1.0f), 0.0f);
                direction = Normalize(Vector3(sin(dVector.x), 0.0f, cos(dVector.x)));

                ViewCell *v = mViewCellsManager->GetViewCell(viewPoint);

                GlRendererBuffer *renderer = mViewCellsManager->GetPreprocessor()->GetRenderer();

                if (v && v->GetValid())
                {
                        renderer->SetViewPoint(viewPoint);
                        renderer->SetViewDirection(direction);
                
                        if (renderer->ValidViewPoint())
                        {
                                cout << "view point valid " << viewPoint << " " << direction << endl;
                                break;
                        }
                        
                }

                if (++ tries > maxTries)
                {
                        cerr << "error: no view point computed" << endl;
                        return false;
                }
        }

        ray = SimpleRay(viewPoint, direction, 0, 1);
        //cout << "view point generated: " << viewPoint << " " << direction << endl;

        return true;
}


bool RandomViewCellsHandler::IsValidViewSpace(ViewCell *vc)
{
        SimpleRay simpleRay;
        //check if view point can be generated
        return GenerateViewPoint(vc, simpleRay);
}


bool RandomViewCellsHandler::GenerateRandomViewCells(ViewCellContainer &viewCells, 
                                                                                                         const int numViewCells)
{
        int generatedViewCells = 0;
        //HaltonSequence halton;
        //float r[1];

        ViewCell::NewMail();

        while (generatedViewCells < numViewCells)
        {
                // savety criterium
                const int tries = 100000 + generatedViewCells;
                int i = 0;

                // generate next view cell
                while (1)
                {
                        //halton.GetNext(1, r);
                        //const int idx = (int)(r[0] * mViewCells.size() - 1.0f);
                        const int idx = (int)RandomValue(0.0f, (float)mViewCellsManager->GetViewCells().size() - 0.5f);
                        
                        ViewCell *viewCell = mViewCellsManager->GetViewCell(idx);

                        if (!viewCell->Mailed())
                        {
                                viewCell->Mail();

                                // check for valid view space
                                if (IsValidViewSpace(viewCell))
                                {
                                        // valid view cell found
                                        viewCells.push_back(viewCell);

                        ++ generatedViewCells;
                                        //cout << "view cell " << generatedViewCells << " generated: " << viewCell->GetId() << endl;    
                                        break;
                                }
                                else
                                {
                                        cout << "error: invalid view cell " << generatedViewCells << " with id " << viewCell->GetId() << endl;  
                                }
                        }

                        if (++ i == tries) // no new view cell fond
                        {
                                cerr << "big error! no view cell found" << endl;
                                return false;
                        }               
                }                       
        }

        return true;
}


ViewCellPointsList *RandomViewCellsHandler::GetViewCellPointsList()
{
        return &mViewCellPointsList;
}

}