source: GTP/trunk/Lib/Vis/Preprocessing/src/QtInterface/QtGlRenderer.cpp @ 2743

#include "glInterface.h"
#include "QtGlRenderer.h"
#include "Mesh.h"
#include "OcclusionQuery.h"
#include "ViewCellsManager.h"
#include "SceneGraph.h"
#include "Pvs.h"
#include "Viewcell.h"
#include "Beam.h"
#include "KdTree.h"
#include "Environment.h"
#include "RssPreprocessor.h"
#include "RssTree.h"
#include "Trackball.h"
#include "QtPreprocessorThread.h"
#include "Material.h"
#include "IntersectableWrapper.h"
#include "LogWriter.h"
#include "RayCaster.h"
#include "ObjectPlacer.h"

#define TEASER 0
#define USE_CG 1

#define TEST_PVS_RENDERING 0

#if USE_CG
#include <Cg/cg.h>
#include <Cg/cgGL.h>
#endif

#include <QVBoxLayout>


using namespace std;


namespace GtpVisibilityPreprocessor 
{

  
class ViewCellsManager;

static CGcontext sCgContext = NULL;
static CGprogram sCgFragmentProgram = NULL;
static CGprofile sCgFragmentProfile;


QtGlRendererWidget *rendererWidget = NULL;
QtGlDebuggerWidget *debuggerWidget = NULL;



static SimpleRayContainer sViewPointsList;
static SimpleRayContainer::const_iterator sViewPointsListIt;
static int sCurrentSamples = 0;
static int sNextSamplesThreshold[] = {10000000, 50000000, 100000000, 250000000};
//static int sNextSamplesThreshold[] = {100000000, 200000000};
static int sNumReplays = 0;//4;
static int sCurrentSamplesThreshold = 0;


void processHits (GLint hits, GLuint buffer[])
{
   unsigned int i, j;
   GLuint names, *ptr;

   cout << "hits: " << hits << endl;;
   ptr = (GLuint *) buffer;

   for (i = 0; i < hits; i++) 
   {
           /*  for each hit  */
           names = *ptr;

           printf ("number of names for hit: %d\n", names); ptr ++;
           printf("z1: %g;", (float) *ptr / 0x7fffffff); ptr ++;
           printf("z2: %g\n", (float) *ptr / 0x7fffffff); ptr ++;
           printf ("the name is ");

           // for each name 
           for (j = 0; j < names; j++) 
                   printf ("%d ", *ptr); ptr++;

           printf ("\n");
   }
}


static inline bool ilt(Intersectable *obj1, Intersectable *obj2)
{
        return obj1->mId < obj2->mId;
}


inline static bool nearerThan(ViewCell *vc1, ViewCell *vc2)
{
        return vc1->GetDistance() > vc2->GetDistance();
}


#if USE_CG
static void handleCgError() 
{
    Debug << "Cg error: " << cgGetErrorString(cgGetError()) << endl;
    exit(1);
}
#endif


void QtGlRendererBuffer::MakeLive()
{
        QGLPixelBuffer::makeCurrent();
        //makeCurrent();
}


void QtGlRendererBuffer::DoneLive()
{
        QGLPixelBuffer::doneCurrent();
        //doneCurrent();
}
  

QtGlRendererBuffer::QtGlRendererBuffer(int w, int h,
                                                                           SceneGraph *sceneGraph,
                                                                           ViewCellsManager *viewcells,
                                                                           KdTree *tree):
QGLPixelBuffer(QSize(w, h), 
                           QGLFormat(QGL::StencilBuffer | 
                                                 QGL::DepthBuffer | 
                                                 QGL::DoubleBuffer |
                                                 QGL::Rgba)
                                                 ),
GlRendererBuffer(sceneGraph, viewcells, tree)
{
        //makeCurrent();
        MakeLive();
        glViewport(0, 0, w, h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(-1, 1, -1, 1, -99, 99);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

        InitGL();

        //doneCurrent();
        //DoneLive();
}


void QtGlRendererBuffer::RenderPvs(const ObjectPvs &pvs)
{
        EnableDrawArrays();
        
        // prepare pvs for rendering
        PreparePvs(pvs);

        if (mUseVbos)
                glBindBufferARB(GL_ARRAY_BUFFER_ARB, mVboId);

        int offset = (int)mObjects.size() * 3;
        char *arrayPtr = mUseVbos ? NULL : (char *)mData;

        glVertexPointer(3, GL_FLOAT, 0, (char *)arrayPtr);
        glNormalPointer(GL_FLOAT, 0, (char *)arrayPtr + offset * sizeof(Vector3));
        glDrawElements(GL_TRIANGLES, mIndexBufferSize, GL_UNSIGNED_INT, mIndices);
}


void GlRenderer::RenderVisTriangles()
{
        DisableDrawArrays();

        vector<VizStruct>::const_iterator oit, oit_end = GetPreprocessor()->visTriangles.end();
        int currentId = 0;
        //glEnable(GL_POINT_SMOOTH);
        for (oit = GetPreprocessor()->visTriangles.begin(); oit != oit_end; ++ oit)
        {
                VizStruct viz = *oit;
                TriangleIntersectable *triObj = viz.originalTriangle;

                glColor3f(RandomValue(0.3f, 1.0f), RandomValue(0.3f, 1.0f), RandomValue(0.3f, 1.0f));
                RenderIntersectable(triObj);

                glColor3f(1, 0, 0);
                glPointSize(1.0);
                
                glBegin(GL_POINTS);
                
                VertexContainer::const_iterator vit, vit_end = viz.enlargedTriangle.end();

                for (vit = viz.enlargedTriangle.begin(); vit != vit_end; ++ vit)
                {
                        Vector3 v = *vit;
                        glVertex3f(v.x, v.y, v.z);
                }

                glEnd();
        }
}


#if 0

void GlRenderer::RenderTrianglePvs()
{
        DisableDrawArrays();

        ObjectContainer::const_iterator oit, oit_end = GetPreprocessor()->mTrianglePvs.end();

        for (oit = GetPreprocessor()->mTrianglePvs.begin(); oit != oit_end; ++ oit)
        {
                TriangleIntersectable *triObj = static_cast<TriangleIntersectable *>(*oit);
                glColor3f(RandomValue(0.3f, 1.0f), RandomValue(0.3f, 1.0f), RandomValue(0.3f, 1.0f));
                if (mUseFalseColors) SetupFalseColor(triObj->mId);

                RenderIntersectable(triObj);
        }
}

#else

void GlRenderer::RenderTrianglePvs()
{
        if (GetPreprocessor()->mTrianglePvs.empty())
                return;

        EnableDrawArrays();

        if (mUseVbos)
                glBindBufferARB(GL_ARRAY_BUFFER_ARB, mVboId);

        unsigned int bufferSize = GetPreprocessor()->mTrianglePvs.size() * 3;
        unsigned int *indices = new unsigned int[bufferSize];

        for (unsigned int i = 0; i < GetPreprocessor()->mTrianglePvs.size(); ++ i)
        {
                const int id = GetPreprocessor()->mTrianglePvs[i]->GetId() * 3;

                indices[i * 3 + 0] = id + 0;
                indices[i * 3 + 1] = id + 1;
                indices[i * 3 + 2] = id + 2;
        }

        size_t offset = mObjects.size() * 3;
        char *arrayPtr = mUseVbos ? NULL : (char *)mData;
        
        glVertexPointer(3, GL_FLOAT, 0, (char *)arrayPtr);
        glNormalPointer(GL_FLOAT, 0, (char *)arrayPtr + offset * sizeof(Vector3));
        
        glDrawElements(GL_TRIANGLES, bufferSize, GL_UNSIGNED_INT, indices);

        DisableDrawArrays();
        delete [] indices;
}

#endif

// reimplemented here so that we can snap the error windows
float QtGlRendererBuffer::GetPixelError(int &pvsSize, int currentPass)
{
        MakeLive();

        if (0)
        {
                cout << "stencil: " << format().stencil() << endl;
                cout << "depth: " << format().depth() << endl;
                cout << "rgba: " << format().rgba() << endl;
                cout << "double: " << format().doubleBuffer() << endl;
                cout << "depth: " << format().depth() << endl;
                cout << "gl:" << format().hasOpenGL() << endl;
                cout << "dir:" << format().directRendering() << endl;
        }

        ++ mCurrentFrame;

        float pErrorPixels = -1.0f;

        mUseFalseColors = false;
        unsigned int pixelCount = 0;

        
        ViewCell *viewcell = mViewCellsManager->GetViewCell(mViewPoint);

        if (viewcell == NULL)
                return -1.0f;

        bool evaluateFilter;
        Environment::GetSingleton()->GetBoolValue("Preprocessor.evaluateFilter", evaluateFilter);

        ObjectPvs pvs;

        if (!evaluateFilter) 
                pvs = viewcell->GetPvs();
        else 
                mViewCellsManager->ApplyFilter2(viewcell, false, mViewCellsManager->GetFilterWidth(), pvs);

        pvsSize = pvs.GetSize();
        
        // hack: assume that view cell empty
        if (pvsSize == 0)
                return 0.0f;

        //mTopView = false;
        SetupProjection(GetWidth(), GetHeight());
        SetupCamera();

        // use shading
        if (mSnapErrorFrames)
        {
                glEnable(GL_NORMALIZE);

                // mat_specular and mat_shininess are NOT default values
                GLfloat mat_ambient[] = {0.5f, 0.5f, 0.5f, 1.0f};
                GLfloat mat_diffuse[] = {1.0f, 1.0f, 1.0f, 1.0f};
                GLfloat mat_specular[] = {0.3f, 0.3f, 0.3f, 1.0f};
                GLfloat mat_shininess[] = {8.0f};

                glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
                glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
                glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
                glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
                
                GLfloat light_ambient[] = {0.3, 0.3, 0.3, 1.0};
                GLfloat light_diffuse[] = {0.6, 0.6, 0.6, 1.0};
                GLfloat light_specular[] = {0.6, 0.6, 0.6, 1.0};

                glEnable(GL_LIGHTING);
                GLfloat light_position[] =  {0.f, 0.f, 0.f, 1.0f};

                // lights in arena
                glEnable(GL_LIGHT0); 

                // a light
                glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
                glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
                glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
                glLightfv (GL_LIGHT0, GL_POSITION, light_position);
                
                glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
                glEnable(GL_COLOR_MATERIAL);

                GLfloat lmodel_ambient[] = {0.5f, 0.5f, 0.5, 1.0f};
                //glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);

                glShadeModel(GL_SMOOTH);
        }

        glDisable(GL_ALPHA_TEST);
                
        glClearDepth(1.0f);

        glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

        //glColor3f(0.6f, 0.6f, 0.6f);
        glColor3f(0, 1, 0);

        glDepthFunc(GL_LESS);
        glDepthMask(GL_TRUE);
        glEnable(GL_DEPTH_TEST);
        
        if (mDetectEmptyViewSpace) 
                glEnable(GL_CULL_FACE);
        else
                glDisable(GL_CULL_FACE);
        
        glFrontFace(GL_CCW);
        glCullFace(GL_BACK);

        glStencilFunc(GL_EQUAL, 0x0, 0x1);
        glStencilOp(GL_KEEP, GL_KEEP, GL_INCR); 
        glDisable(GL_STENCIL_TEST); 

        KdNode::NewMail2();
        
        DisableDrawArrays();
        
        //mUseFalseColors = true;
        // hack for gvs
        RenderTrianglePvs();
        // render pvs once
        //RenderPvs(pvs);

        //glColorMask(GL_TRUE, GL_FALSE, GL_FALSE, GL_FALSE);
        //glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE);
        glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);

        //glEnable(GL_STENCIL_TEST); 

        // errors in red
        glColor3f(1, 0, 0);


        // render scene, record differences
        OcclusionQuery *query = mOcclusionQueries[0];

        KdNode::NewMail2();
        
        query->BeginQuery();

        // current frame has to be increased at each rendering pass
        ++ mCurrentFrame;

        RenderScene();
        glFlush();

        query->EndQuery();
        
        glDisable(GL_STENCIL_TEST); 
        
        pixelCount = query->GetQueryResult();

        pErrorPixels = (float)pixelCount / (GetWidth() * GetHeight());

        const int pixelThres = 0;

        // some error happened
        if (1)//pixelCount > pixelThres) 
        {
                cout << "f " << mFrame << " id " << viewcell->GetId() << " pvs " << pvsSize 
                         << " e " << pixelCount << " vp " << mViewPoint << " vd " << mViewDirection << endl;
        
                if (mSnapErrorFrames) 
                {
                        glReadBuffer(GL_BACK);
                        //glReadBuffer(GL_FRONT);

                        //////////////
                        //-- output error visualization

                        char filename[256];
                        //sprintf(filename, "error-frame-%04d-%05d.bmp", pass, mFrame);
                        //sprintf(filename, "error-frame-%05d-%0.5f.png", mFrame, pErrorPixels);
                        sprintf_s(filename, "error-frame-%05d-%05d-%08d.png", viewcell->GetId(), mFrame, pixelCount);

                        QImage im = toImage();
                        string str = mSnapPrefix + filename;
                        QString qstr(str.c_str());

                        im.save(qstr, "PNG");

                        if (1)
                        {
                                ///////////
                                //-- output computed pvs

                                mUseFalseColors = false;
                                //mUseFalseColors = true;
                                glPushAttrib(GL_CURRENT_BIT);
                                glColor3f(0, 1, 0);

                                glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
                                glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

                                KdNode::NewMail2();

                                ++ mCurrentFrame;

                                // render pvs once
                                //RenderPvs(pvs);
                                //EnableDrawArrays();
                                //glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
                                // prepare pvs for rendering
                                //PreparePvs(pvs);
                                //_RenderColoredPvs(pvs);
                                //glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
                                // hack for gvs visualization
                                //RenderTrianglePvs();
                                RenderVisTriangles();

                                glFlush();

                                mUseFalseColors = false;

                                im = toImage();
                                sprintf_s(filename, "error-frame-%05d-%05d-%08d-pvs.png", viewcell->GetId(), mFrame, pixelCount);
                                str = mSnapPrefix + filename;
                                qstr = str.c_str();
                                im.save(qstr, "PNG");

                                glPopAttrib();
                        }
                }
        }

        glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);

        //DoneLive();

        return pErrorPixels;
}

int
QtGlRendererBuffer::ComputePvs(ObjectContainer &objects, 
                                                           ObjectContainer &pvs) const
{
        int pvsSize = 0;
        QImage image = toImage();

        Intersectable::NewMail();

        std::stable_sort(objects.begin(), objects.end(), ilt);

        MeshInstance dummy(NULL);

        Intersectable *obj = NULL;

        for (int x = 0; x < image.width(); ++ x)
        {
                for (int y = 0; y < image.height(); ++ y)
                {
                        QRgb pix = image.pixel(x, y);
                        const int id = GetId(qRed(pix), qGreen(pix), qBlue(pix));

                        dummy.SetId(id);

                        ObjectContainer::iterator oit =
                                lower_bound(objects.begin(), objects.end(), &dummy, ilt);

                        if (//(oit != oit.end()) && 
                                ((*oit)->GetId() == id) && 
                                !obj->Mailed())
                        {
                                obj = *oit;
                                obj->Mail();
                                ++ pvsSize;
                                pvs.push_back(obj);
                        }
                }
        }

        return pvsSize;
}


void QtGlRendererWidget::InitGL()
{
        GlRenderer::InitGL();

        //glEnable(GL_FOG);
        //glFogi(GL_FOG_MODE, GL_EXP);
        //glFogf(GL_FOG_DENSITY, .2f);
        glFogi(GL_FOG_MODE, GL_LINEAR);
        glFogf(GL_FOG_START, 50.f);
        glFogf(GL_FOG_END, 500.f);

        
        // mat_specular and mat_shininess are NOT default values
        GLfloat mat_ambient[] = {0.5f, 0.5f, 0.5f, 1.0f};
        GLfloat mat_diffuse[] = {1.0f, 1.0f, 1.0f, 1.0f};
        GLfloat mat_specular[] = {0.3f, 0.3f, 0.3f, 1.0f};
        GLfloat mat_shininess[] = {1.0f};

        glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
        glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
        glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
        glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);


        glEnable(GL_LIGHTING);

        // a light      
        GLfloat light_ambient[] = {0.3, 0.3, 0.3, 1.0};
    GLfloat light_diffuse[] = {0.6, 0.6, 0.6, 1.0};
    GLfloat light_specular[] = {1.0, 1.0, 1.0, 1.0};
    GLfloat light_position[] =  {0.f, .0f, 0.f, 1.0f};
    //GLfloat light_position[] =  {600.0f, 250.0f, -500.f, 1.0f};
    //GLfloat light_position[] = {278.0f, 548.8f,279.0f, 1.0f};



        glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
        glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
        glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);

        glLightfv(GL_LIGHT0, GL_POSITION, light_position);
        
        //glDisable(GL_LIGHT0);
        glEnable(GL_LIGHT0);

        glLightfv(GL_LIGHT1, GL_AMBIENT, light_ambient);
        glLightfv(GL_LIGHT1, GL_DIFFUSE, light_diffuse);
        glLightfv(GL_LIGHT1, GL_SPECULAR, light_specular);

        // set position of the light2
        GLfloat infinite_light2[] = {  -0.3, 1.5, 1.0, 0.0  };
        glLightfv (GL_LIGHT1, GL_POSITION, infinite_light2);
        //glEnable(GL_LIGHT1);

        GLfloat lmodel_ambient[] = {0.3f, 0.3f, 0.3f, 1.0f};
        glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
        
        glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
        //glColorMaterial(GL_FRONT_AND_BACK, GL_SPECULAR);
        glEnable(GL_COLOR_MATERIAL);

        glShadeModel(GL_SMOOTH);
}


void
QtGlRendererWidget::SetupCameraProjection(const int w, const int h, const float angle)
{
        if (!mTopView) {
                int ww = w;
                int hh = h;
                glViewport(0, 0, ww, hh);
                glMatrixMode(GL_PROJECTION);
                glLoadIdentity();
                gluPerspective(angle, ww/(float)hh, 0.1, 2.0 * Magnitude(mSceneGraph->GetBox().Diagonal()));
                glMatrixMode(GL_MODELVIEW);
        } else {
                int ww = w;
                int hh = h;
                glViewport(0, 0, ww, hh);
                glMatrixMode(GL_PROJECTION);
                glLoadIdentity();
                gluPerspective(50.0, ww / (float)hh, 0.1, 20.0 * Magnitude(mSceneGraph->GetBox().Diagonal()));
                glMatrixMode(GL_MODELVIEW);
        }
}


bool QtGlRendererWidget::PvsChanged(ViewCell *viewCell) const
{
        if (viewCell != mPvsCache.mViewCell)
                return true;

        if (viewCell->GetPvs().GetSize() != mPvsCache.mUnfilteredPvsSize)
                return true;

        return false;
}


void QtGlRendererWidget::_RenderPvs()
{
        EnableDrawArrays();

        if (mUseVbos)
                glBindBufferARB(GL_ARRAY_BUFFER_ARB, mVboId);

        mUseFalseColors = false;

        int offset = (int)mObjects.size() * 3;
        char *arrayPtr = mUseVbos ? NULL : (char *)mData;

        glVertexPointer(3, GL_FLOAT, 0, (char *)arrayPtr);
        glNormalPointer(GL_FLOAT, 0, (char *)arrayPtr + offset * sizeof(Vector3));
        glDrawElements(GL_TRIANGLES, mIndexBufferSize, GL_UNSIGNED_INT, mIndices);

        // handle dynamic objects in pvss
        DynamicObjectsContainer::const_iterator dit, dit_end = mDynamicPvsObjects.end();

        //cout << "dynamic objects in pvs " << mDynamicPvsObjects.size() << endl;;
#if 0
        for (dit = mDynamicPvsObjects.begin(); dit != dit_end; ++ dit)
                _RenderDynamicObject(*dit);
#endif
        //glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

        // show placed dynamic objects as wireframe
        Preprocessor *p = GetPreprocessor();
        dit_end = p->mDynamicObjects.end();

        int i = 0;
        for (dit = p->mDynamicObjects.begin(); dit != dit_end; ++ dit, ++ i)
        {
                if (i == mCurrentDynamicObjectIdx)
                        glColor3f(1, 0, 1);
                else glColor3f(0.6f, 0.6f, 0.6f);

                _RenderDynamicObject(*dit);
        }
        
        //glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}


void QtGlRendererWidget::PreparePvs(const ObjectPvs &pvs)
{
        int indexBufferSize = 0;
        
        // hack: mail not working with multiple threads
        KdNode::NewMail2();

        mPvsSize = pvs.GetSize();

        mDynamicPvsObjects.clear();

        ObjectPvsIterator it = pvs.GetIterator();

        while (it.HasMoreEntries()) 
        {
                Intersectable *obj = it.Next();

                switch (obj->Type())
                {
                case Intersectable::KD_INTERSECTABLE:
                        {
                                KdNode *node = static_cast<KdIntersectable *>(obj)->GetItem();
                                _UpdatePvsIndices(node, indexBufferSize);
                        }
                        break;

                case Intersectable::SCENEGRAPHLEAF_INTERSECTABLE:
                        mDynamicPvsObjects.push_back(static_cast<SceneGraphLeafIntersectable *>(obj)->GetItem());
                        break;
                default:
                        cerr << "PreparePvs: type " << Intersectable::GetTypeName(obj) << " not handled yet" << endl;
                }
        }

        mIndexBufferSize = indexBufferSize;
}


void QtGlRendererWidget::VisualizePvs()
{
        if (mUseVbos) 
                glBindBufferARB(GL_ARRAY_BUFFER_ARB, mVboId);

        ++ mCurrentFrame;

        EnableDrawArrays();
                
        if (mDetectEmptyViewSpace) 
                glEnable(GL_CULL_FACE);
        else
                glDisable(GL_CULL_FACE);

        ViewCell *viewcell = NULL;
        viewcell = mViewCellsManager->GetViewCell(mViewPoint, true);

        if (viewcell) 
        {
                // copy the pvs so that it can be filtered ...
                if (PvsChanged(viewcell)) 
                {
                        mPvsCache.Reset();
                        mPvsCache.mViewCell = viewcell;
                        mPvsCache.mUnfilteredPvsSize = viewcell->GetPvs().GetSize();

                        if (mUseSpatialFilter) 
                        {
                                //mMutex.lock();
                                // mSpatialFilter size is in range 0.001 - 0.1
                                mViewCellsManager->ApplyFilter2(viewcell,
                                        mUseFilter,
                                        100.0f * mSpatialFilterSize,
                                        mPvsCache.mPvs,         
                                        &mPvsCache.filteredBoxes);
                                //mPvsCache.mPvs = pvs;
                                //mMutex.unlock();
                                //cout << "pvs size: " << mPvsCache.mPvs.GetSize() << endl;
                        }
                        else
                        {
                                mPvsCache.mPvs = viewcell->GetPvs();
                        }
                        
                        // update the indices for rendering
                        PreparePvs(mPvsCache.mPvs);
                        emit PvsUpdated();

                        mCurrentPvsCost = mPvsCache.mPvs.EvalPvsCost();
                }

                // Render PVS
                if (mUseSpatialFilter && mRenderBoxes) 
                {
                        for (size_t i=0; i < mPvsCache.filteredBoxes.size(); ++ i)
                        {
                                RenderBox(mPvsCache.filteredBoxes[i]);
                        }
                } 
                else 
                {
                        if (!mRenderVisibilityEstimates && !mUseRandomColorPerPvsObject)
                                _RenderPvs();
                        else
                                _RenderColoredPvs(mPvsCache.mPvs);
                }

                if (mRenderFilter) 
                {
                        bool oldWireFrame = mWireFrame;
                        mWireFrame = true;
                        RenderIntersectable(viewcell);
                        
                        mWireFrame = oldWireFrame;
                }
        } 
        else 
        {
                RenderScene();
        }

        //cout << "vp: " << mViewPoint << " vd: " << mViewDirection << endl;
}

float
QtGlRendererWidget::RenderErrors()
{
        float pErrorPixels = -1.0f;

        SetupCamera();
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

        glPushAttrib(GL_ENABLE_BIT);

        glStencilFunc(GL_EQUAL, 0x0, 0x1);
        glStencilOp(GL_KEEP, GL_KEEP, GL_INCR); 

#if TEASER
        glColor3f(0.0f, 0.8f, 0.0f);
#else
        glColor3f(0.6f, 0.6f, 0.6f);
#endif
        
        // Render PVS
        VisualizePvs();

        glEnable(GL_STENCIL_TEST); 
        glDisable(GL_LIGHTING);

        SetupCamera();

        mUseForcedColors = true;

        glColor3f(1.0f, 0.0f, 0.0f);

        OcclusionQuery *query = mOcclusionQueries[0];
        query->BeginQuery();

        RenderScene();

        mUseForcedColors = false;

        query->EndQuery();

        glDisable(GL_STENCIL_TEST);
        glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);

        glPopAttrib();

        // reenable other state
        //  int wait=0;
        //  while (!query.ResultAvailable()) {
        //      wait++;
        //  }

        int pixelCount = query->GetQueryResult();
        pErrorPixels = (float)pixelCount / (GetWidth() * GetHeight());
        
        if (0) cout << "error pixels=" << pixelCount << endl;

        mRenderError = pErrorPixels;

        return pErrorPixels;
}


void QtGlRendererWidget::timerEvent(QTimerEvent *timerEvent) 
{
        if (mReplayMode && (timerEvent->timerId() == mReplayTimerId))
        {
                if (sViewPointsListIt == sViewPointsList.end())
                {
                        cout << "stopping replay" << endl;
                        mReplayMode = false;
                        GetPreprocessor()->mSynchronize = false;
                }
                else
                {
                        SimpleRay sray = *sViewPointsListIt;

                        mViewPoint = sray.mOrigin;
                        mViewDirection = sray.mDirection;

                        ++ sViewPointsListIt;
                }

                updateGL();

                // output the current frame buffer
                if (mExportFrameBuffer)
                {
                        const int dist = sViewPointsListIt - sViewPointsList.begin();

                        char filename[200];
                        sprintf(filename, "error-frame-%04d-%05d.bmp", sCurrentSamples, dist);
                        //QPixmap img = renderPixmap(0, 0, true);
                        QImage im = grabFrameBuffer();

                        string str = mSnapPrefix + filename;
                        QString qstr(str.c_str());

                        //im.save(qstr, "PNG");
                        // use bmp for lossless storage (for video)
                        im.save(qstr, "BMP");
                }
        }
        else if (timerEvent->timerId() == mUpdateTimerId)
                // update pvss from time to time
                update();

        // grab frame buffer after a certain number of samples
        if (!mReplayMode && 
                (sCurrentSamplesThreshold < sNumReplays) && 
                ((GetPreprocessor()->mCurrentSamples > sNextSamplesThreshold[sCurrentSamplesThreshold])))
        {
                ++ sCurrentSamplesThreshold;
                cout << "replaying at total samples: " << GetPreprocessor()->mCurrentSamples << endl;
                ReplayViewPoints();
        }

}


void QtGlRendererWidget::mousePressEvent(QMouseEvent *e)
{
        int x = e->pos().x();
        int y = e->pos().y();

        mousePoint.x = x;
        mousePoint.y = y;

        if (e->button() == Qt::RightButton)
        {
                if (mPlacer->GetCurrentObject())
                {
                        Vector3 pt = Unproject(x, y);

                        mPlacer->PlaceObject(pt);
                        SceneGraphLeaf *leaf = mPlacer->GetCurrentObject();

                        // hack: should just pass a IntersectableGroup as a whole
                        // instead we duplicate the object container and create a new
                        // leaf
                        SceneGraphLeaf *newObj = new SceneGraphLeaf(*leaf);

                        // make current object
                        // the object is added at the end of the vector
                        mCurrentDynamicObjectIdx = (int)GetPreprocessor()->mDynamicObjects.size();

                        GetPreprocessor()->RegisterDynamicObject(newObj);
                }
        }
}


void QtGlRendererWidget::mouseReleaseEvent(QMouseEvent *e)
{
        int x = e->pos().x();
        int y = e->pos().y();

        mousePoint.x = x;
        mousePoint.y = y;

        if (e->modifiers() & Qt::ShiftModifier) 
        {
                const Vector3 pt = Unproject(x, y);

                int idx = FindDynamicObject(x, y);
                
                if (idx >= 0)
                {
                        mCurrentDynamicObjectIdx = idx;
                }
        }
}

void
QtGlRendererWidget::mouseMoveEvent(QMouseEvent *e)
{
        if (mReplayMode)
                return;

        float MOVE_SENSITIVITY = Magnitude(mSceneGraph->GetBox().Diagonal())*1e-3;
        float TURN_SENSITIVITY = 0.1f;
        float TILT_SENSITIVITY = 32.0 ;
        float TURN_ANGLE= M_PI / 36.0 ;

        int x = e->pos().x();
        int y = e->pos().y();

        int diffx = -(mousePoint.x - x);
        int diffy = -(mousePoint.y - y);

        const float t = 1.0f;
        if (e->modifiers() & Qt::ControlModifier) 
        {
                mViewPoint.y += (y-mousePoint.y)*MOVE_SENSITIVITY / 2.0;
                mViewPoint.x += (x-mousePoint.x)*MOVE_SENSITIVITY / 2.0;
        }
        else if (e->modifiers() & Qt::AltModifier)
        {
                if (mCurrentDynamicObjectIdx >= 0)
                {
                        Matrix4x4 tm;

                        SceneGraphLeaf *l =
                          mViewCellsManager->GetPreprocessor()->mDynamicObjects[mCurrentDynamicObjectIdx];

                        switch (mTrafoType)
                        {
                        case 0:
                                {
                                  if (e->modifiers() & Qt::ShiftModifier) {
                                        const Vector3 transl(0, diffy, 0);
                                        tm = TranslationMatrix(transl);
                                  
                                  } else {
                                        const Vector3 transl(diffx, 0, diffy);
                                        tm = TranslationMatrix(transl);
                                  }
                                }
                                break;
                        case 1:
                                {
                                        float scalef = 1.0f + 0.01f * (diffx + diffy);
                                        if (scalef < 0.9) scalef = 0.9f;
                                        else if (scalef > 1.1f) scalef = 1.1f;
                                        tm = ScaleMatrix(scalef, scalef, scalef);
                                }
                                break;
                        case 2:
                                {
                                        // tm = RotationXMatrix(diffx) * RotationYMatrix(diffy);
                                        tm = RotationYMatrix(diffx);
                                }
                                break;
                        default:
                                cerr << "not implemented" << endl;
                        }
                        
                        l->ApplyTransform(tm);

                        updateGL();
                }
        }
        else
        {
                mViewPoint += mViewDirection*((mousePoint.y - y)*MOVE_SENSITIVITY);
                float adiff = TURN_ANGLE*(x - mousePoint.x)*-TURN_SENSITIVITY;
                float angle = atan2(mViewDirection.x, mViewDirection.z);
                mViewDirection.x = sin(angle + adiff);
                mViewDirection.z = cos(angle + adiff);
        }

        mousePoint.x = x;
        mousePoint.y = y;

        updateGL();
}


void
QtGlRendererWidget::resizeGL(int w, int h)
{
        SetupCameraProjection(w, h);
        updateGL();
}


void QtGlRendererWidget::paintGL()
{
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        SetupCameraProjection(width(), height());
        SetupCamera();

        if (mRenderErrors) 
                RenderErrors();
        else 
        {
                glColor3f(0.6f, 0.6f, 0.6f);

                if (mWireFrame)
                        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
                else
                        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

                VisualizePvs();

                glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
        }

        if (mShowRays) 
                RenderRays(mViewCellsManager->mVizBuffer.GetRays(), mRayVisualizationMethod, mShowDistribution, 1);
        
        RenderInfo();

        ++ mFrame;
        //      cout<<"vp="<<mViewPoint<<" vd="<<mViewDirection<<endl;
}


void
QtGlRendererWidget::SetupCamera()
{
        if (!mTopView)
                GlRenderer::SetupCamera();
        else 
        {
                if (0) 
                {
                        float dist = Magnitude(mSceneGraph->GetBox().Diagonal())*0.05;
                        Vector3 pos = mViewPoint - dist*Vector3(mViewDirection.x,
                                -1,
                                mViewDirection.y);

                        Vector3 target = mViewPoint + dist*mViewDirection;
                        Vector3 up(0,1,0);

                        glLoadIdentity();
                        gluLookAt(pos.x, pos.y, pos.z,
                                target.x, target.y, target.z,
                                up.x, up.y, up.z);
                } 
                else 
                {
                        float dist = Magnitude(mSceneGraph->GetBox().Diagonal()) * mTopDistance;
                        Vector3 pos = mViewPoint  + dist * Vector3(0,   1, 0);

                        Vector3 target = mViewPoint;
                        Vector3 up(mViewDirection.x, 0, mViewDirection.z);

                        glLoadIdentity();
                        gluLookAt(pos.x, pos.y, pos.z,
                                target.x, target.y, target.z,
                                up.x, up.y, up.z);

                }
        }

}


void
QtGlRendererWidget::keyPressEvent(QKeyEvent *e)
{
        switch (e->key()) 
        {
        case Qt::Key_E:
                mRenderErrors = !mRenderErrors;
                updateGL();
                break;
        case Qt::Key_R:
                mUseRandomColorPerPvsObject = !mUseRandomColorPerPvsObject;
                updateGL();
                break;
        case Qt::Key_W:
                mWireFrame = !mWireFrame;
                updateGL();
                break;
        case Qt::Key_T:
                mTopView = !mTopView;
                SetupCameraProjection(width(), height());
                updateGL();
                break;
        case Qt::Key_V:
                mRenderViewCells = !mRenderViewCells;
                updateGL();
                break;
        case Qt::Key_P:
                // set random viewpoint
                mViewCellsManager->GetViewPoint(mViewPoint);
                updateGL();
                break;
        case Qt::Key_S: 
                {
                        // set view poitn and direction
                        QString text;
                        bool ok;
                        text.sprintf("%f %f %f", mViewPoint.x, mViewPoint.y, mViewPoint.z);
                        text = QInputDialog::getText(this,
                                "Enter a view point",
                                "",
                                QLineEdit::Normal,
                                text,
                                &ok);

                        if (!ok)
                                break;

                        if (sscanf_s(text.toAscii(), "%f %f %f", &mViewPoint.x, &mViewPoint.y, &mViewPoint.z) == 3) 
                        {
                                text.sprintf("%f %f %f", mViewDirection.x, mViewDirection.y, mViewDirection.z);
                                text = QInputDialog::getText(this,
                                        "Enter a direction",
                                        "",
                                        QLineEdit::Normal,
                                        text,
                                        &ok);
                                if (!ok)
                                        break;
                                if (sscanf_s(text.toAscii(), "%f %f %f", &mViewDirection.x,
                                        &mViewDirection.y, &mViewDirection.z) == 3) {
                                                updateGL();
                                }
                                break;
                        }

                }
        default:
                cerr << "unknown key" << endl;
                e->ignore();
                break;
        }
}



QtGlRendererWidget::QtGlRendererWidget(
                                                                           SceneGraph *sceneGraph,
                                                                           ViewCellsManager *viewcells,
                                                                           KdTree *tree,
                                                                           QWidget * parent,
                                                                           const QGLWidget * shareWidget,
                                                                           Qt::WFlags f):
GlRendererWidget(sceneGraph, viewcells, tree), 
QGLWidget(QGLFormat(QGL::SampleBuffers), parent, shareWidget, f)
{
        mPreprocessorThread = NULL;
        mTopView = false;
        mRenderViewCells = false;
        mTopDistance = 1.0f;
        mCutViewCells = false;
        mCutScene = false;
        mRenderErrors = false;
        mRenderBoxes = false;
        mRenderFilter = true;
        mRenderVisibilityEstimates = false;
        //mRenderVisibilityEstimates = true;

        mWireFrame = false;
        mComputeGVS = false;
        mUseRandomColorPerPvsObject = false;
        //mUseRandomColorPerPvsObject = true;

        mHideByCost = false;
        mUseTransparency = false;

        mTransferFunction = 1.0f;
        mIndexBufferSize = 0;

        const int delay = 250; // in milliseconds
        mUpdateTimerId = startTimer(delay);
        mReplayTimerId = startTimer(1); // use fastest replay rate

        bool tmp;

        Environment::GetSingleton()->GetBoolValue("Preprocessor.applyVisibilityFilter", tmp );
        mUseFilter = tmp;

        Environment::GetSingleton()->GetBoolValue("Preprocessor.applyVisibilitySpatialFilter", tmp );
        mUseSpatialFilter = tmp;

        mShowRenderCost = false;
        mShowPvsSizes = false;
        mShowComparison = false;
        mShowPiercingRays = false;
        mShowWeightedRays = false;
        mUseStandardColors = false;
        mShowWeightedCost = true;

        mShowDistanceWeightedPvs = true;
        mShowDistanceWeightedTriangles = false;
        mShowWeightedTriangles = false;
        mShowDistribution = 15;

        mSpatialFilterSize = 0.01;
        mPvsSize = 0;
        mRayVisualizationMethod = 0;
        mTrafoType = 0;

        mRenderError = 0.0f;

        mShowRays = false;
        mReplayMode = false;

        mPlacer = new ObjectPlacer();

        mCurrentDynamicObjectIdx = -1;

        // export frame buffer during walkthrough
        //mExportFrameBuffer = true;
        mExportFrameBuffer = false;

        const int sceneCut = 339;
        SetSceneCut(sceneCut);
        mControlWidget = new QtRendererControlWidget(NULL);

        connect(mControlWidget, SIGNAL(SetViewCellGranularity(int)), this, SLOT(SetViewCellGranularity(int)));
        connect(mControlWidget, SIGNAL(SetTransferFunction(int)), this, SLOT(SetTransferFunction(int)));

        connect(mControlWidget, SIGNAL(UpdateAllPvs()), this, SLOT(UpdateAllPvs()));
        connect(mControlWidget, SIGNAL(ComputeVisibility()), this, SLOT(ComputeVisibility()));
        connect(mControlWidget, SIGNAL(StopComputation()), this, SLOT(StopComputation()));
        connect(mControlWidget, SIGNAL(SetRandomViewPoint()), this,     SLOT(SetRandomViewPoint()));
        connect(mControlWidget, SIGNAL(StoreStatistics(void)), this, SLOT(StoreStatistics(void)));
        connect(mControlWidget, SIGNAL(ComputeGVS(void)), this, SLOT(ComputeGVS(void)));
        connect(mControlWidget, SIGNAL(ReplayViewPoints(void)), this, SLOT(ReplayViewPoints(void)));
        connect(mControlWidget, SIGNAL(NextObject(void)), this, SLOT(NextObject(void)));

        connect(mControlWidget, SIGNAL(SetSceneCut(int)), this, SLOT(SetSceneCut(int)));
        connect(mControlWidget, SIGNAL(SetTopDistance(int)), this, SLOT(SetTopDistance(int)));
        connect(mControlWidget, SIGNAL(SetMaxRenderCost(int)), this, SLOT(SetMaxRenderCost(int)));
        connect(mControlWidget, SIGNAL(SetTransparency(int)), this, SLOT(SetTransparency(int)));

        connect(mControlWidget, SIGNAL(SetVisibilityFilterSize(int)), this, SLOT(SetVisibilityFilterSize(int)));
        connect(mControlWidget, SIGNAL(SetSpatialFilterSize(int)), this, SLOT(SetSpatialFilterSize(int)));
        connect(mControlWidget, SIGNAL(SetHidingCost(int)), this, SLOT(SetHidingCost(int)));

        connect(mControlWidget, SIGNAL(SetShowViewCells(bool)), this, SLOT(SetShowViewCells(bool)));
        connect(mControlWidget, SIGNAL(SetShowRenderCost(bool)), this, SLOT(SetShowRenderCost(bool)));
        connect(mControlWidget, SIGNAL(SetUseTransparency(bool)), this, SLOT(SetUseTransparency(bool)));
        connect(mControlWidget, SIGNAL(SetShowPvsSizes(bool)), this, SLOT(SetShowPvsSizes(bool)));
        connect(mControlWidget, SIGNAL(SetShowComparison(bool)), this, SLOT(SetShowComparison(bool)));
        connect(mControlWidget, SIGNAL(SetTopView(bool)), this, SLOT(SetTopView(bool)));
        connect(mControlWidget, SIGNAL(SetCutViewCells(bool)), this, SLOT(SetCutViewCells(bool)));
        connect(mControlWidget, SIGNAL(SetHideByCost(bool)), this, SLOT(SetHideByCost(bool)));
        connect(mControlWidget, SIGNAL(SetCutScene(bool)), this, SLOT(SetCutScene(bool)));
        connect(mControlWidget, SIGNAL(SetRenderErrors(bool)), this, SLOT(SetRenderErrors(bool)));
        connect(mControlWidget, SIGNAL(SetRenderBoxes(bool)), this, SLOT(SetRenderBoxes(bool)));
        connect(mControlWidget, SIGNAL(SetRenderFilter(bool)), this, SLOT(SetRenderFilter(bool)));
        connect(mControlWidget, SIGNAL(SetRenderVisibilityEstimates(bool)), this, SLOT(SetRenderVisibilityEstimates(bool)));
        connect(mControlWidget, SIGNAL(SetUseFilter(bool)), this, SLOT(SetUseFilter(bool)));
        connect(mControlWidget, SIGNAL(SetUseSpatialFilter(bool)), this, SLOT(SetUseSpatialFilter(bool)));
        connect(mControlWidget, SIGNAL(SetShowPiercingRays(bool)), this, SLOT(SetShowPiercingRays(bool)));
        connect(mControlWidget, SIGNAL(SetShowWireFrame(bool)), this, SLOT(SetShowWireFrame(bool)));
        connect(mControlWidget, SIGNAL(SetShowWeightedRays(bool)), this, SLOT(SetShowWeightedRays(bool)));
        connect(mControlWidget, SIGNAL(SetShowWeightedCost(bool)), this, SLOT(SetShowWeightedCost(bool)));

        connect(mControlWidget, SIGNAL(SetShowDistanceWeightedTriangles(bool)), this, SLOT(SetShowDistanceWeightedTriangles(bool)));
        connect(mControlWidget, SIGNAL(SetShowDistanceWeightedPvs(bool)), this, SLOT(SetShowDistanceWeightedPvs(bool)));
        connect(mControlWidget, SIGNAL(SetShowWeightedTriangles(bool)), this, SLOT(SetShowWeightedTriangles(bool)));

        connect(mControlWidget, SIGNAL(UseConstColorForRayViz(bool)), this, SLOT(UseConstColorForRayViz(bool)));
        connect(mControlWidget, SIGNAL(UseRayLengthForRayViz(bool)), this, SLOT(UseRayLengthForRayViz(bool)));
        connect(mControlWidget, SIGNAL(SetShowContribution(bool)), this, SLOT(SetShowContribution(bool)));
        connect(mControlWidget, SIGNAL(SetShowDistribution(bool)), this, SLOT(SetShowDistribution(bool)));

        connect(mControlWidget, SIGNAL(SetShowDistribution1(bool)), this, SLOT(SetShowDistribution1(bool)));
        connect(mControlWidget, SIGNAL(SetShowDistribution2(bool)), this, SLOT(SetShowDistribution2(bool)));
        connect(mControlWidget, SIGNAL(SetShowDistribution3(bool)), this, SLOT(SetShowDistribution3(bool)));
        connect(mControlWidget, SIGNAL(SetShowDistribution4(bool)), this, SLOT(SetShowDistribution4(bool)));

        connect(mControlWidget, SIGNAL(SetShowRays(bool)), this, SLOT(SetShowRays(bool)));

#if 1
        connect(mControlWidget, SIGNAL(SetTranslation(bool)), this, SLOT(SetTranslation(bool)));
        connect(mControlWidget, SIGNAL(SetRotation(bool)), this, SLOT(SetRotation(bool)));
        connect(mControlWidget, SIGNAL(SetScale(bool)), this, SLOT(SetScale(bool)));
#endif
        connect(mControlWidget, SIGNAL(UpdateDynamicObjects()), this, SLOT(UpdateDynamicObjects()));
        connect(mControlWidget, SIGNAL(DeleteDynamicObject()), this, SLOT(DeleteDynamicObject()));

        setWindowTitle("PVS Visualization");
// view cell cut: 300
        mMaxRenderCost = 500;
        mMaxRenderCost = 762;

        // setting the main window size here
        //resize(800, 600);
        //resize(400, 300);
                resize(512, 320);
        mControlWidget->show();

        LoadObjects();
}

void
QtGlRendererWidget::UpdateAllPvs()
{
        // $$ does not work so far:(
        mViewCellsManager->UpdatePvsForEvaluation();
        //      mViewCellsManager->FinalizeViewCells(false);
}

void
QtGlRendererWidget::ComputeVisibility()
{
        cerr<<"Compute Visibility called!\n"<<endl;
        if (!mPreprocessorThread->isRunning())
                mPreprocessorThread->RunThread();
}

void
QtGlRendererWidget::StopComputation()
{
        cerr<<"stop computation called!\n"<<endl;
        GetPreprocessor()->mStopComputation = true;
}

void
QtGlRendererWidget::SetRandomViewPoint()
{
        cerr<<"setting random view point!\n"<<endl;
        mViewCellsManager->GetViewPoint(mViewPoint);
        updateGL();
}


void QtGlRendererWidget::StoreStatistics()
{
        cerr<<"storing statistics!\n"<<endl;
        const int currentSamples = mViewCellsManager->GetPreprocessor()->mCurrentSamples;

        cout<<"**********************************************" << endl;
        cout << "reached " << currentSamples << " samples " << " => writing file" << endl;
                
        LogWriter writer;
        writer.SetFilename("compare.log");
        writer.Write(currentSamples, mViewCellsManager->GetViewCells());
        cout << "finished writing file" << endl;
        mCompareInfo.clear();
        updateGL();
}


void QtGlRendererWidget::LoadObjects()
{
        AxisAlignedBox3 sceneBox = mViewCellsManager->GetViewSpaceBox();
        
        //float x = 20.0f; float y = 20.0f; float z = 80.0f;
        float x = 20.0f; float y = 20.0f; float z = 20.0f;

        AxisAlignedBox3 box(Vector3(0.5f * x, 0, -0.5f * z), Vector3(-0.5f * x, y, 0.5f * z));
        //AxisAlignedBox3 box(Vector3(0.5f * x, 0, 0), Vector3(-0.5f * x, y, z));

//      box.Scale(Vector3(0.02f, 0.1f, 0.1f));

        box.Translate(-box.Min());

        SceneGraphLeaf *leaf = GetPreprocessor()->GenerateBoxGeometry(box);
        mPlacer->AddObject(leaf);
        
        LoadObject("../data/teapot.bn");
        LoadObject("../data/bunny.bn");
        LoadObject("../data/horse.bn");
}


void QtGlRendererWidget::NextObject()
{
        mPlacer->NextObject();
}


void QtGlRendererWidget::LoadObject(const string &filename)
{
        cout << "Loading model " << filename << endl;

        SceneGraphLeaf *leaf = 
                mViewCellsManager->GetPreprocessor()->LoadDynamicGeometry(filename);

        if (leaf)
        {
                mPlacer->AddObject(leaf);
                cout << "Loading finished" << endl;
        }
        else
                cerr << "Loading failed" << endl;
        
    //updateGL();
}


QtGlRendererWidget::~QtGlRendererWidget() 
{ 
        delete mPlacer; 
}


void
QtGlRendererWidget::RenderRenderCost()
{
        static vector<float> costFunction;
        static float maxCost = -1;
        if (costFunction.size()==0) {
                ViewCellsTree *tree = mViewCellsManager->GetViewCellsTree();
                if (tree) {
                        tree->GetCostFunction(costFunction);
                        maxCost = -1;
                        for (int i=0;  i < costFunction.size(); i++) {
                                //                cout<<i<<":"<<costFunction[i]<<" ";
                                // update cost function to an absolute value based on the total geometry count
                                costFunction[i] *= mSceneGraph->GetSize();
                                if (costFunction[i] > maxCost)
                                        maxCost = costFunction[i];
                        }
                }
        }


        int currentPos = (int)mViewCellsManager->GetViewCells().size();
        float currentCost= -1;

        if (currentPos < costFunction.size())
                currentCost = costFunction[currentPos];
#if 1   
        cout<<"costFunction.size()="<<(int)costFunction.size()<<endl;
        cout<<"CP="<<currentPos<<endl;
        cout<<"MC="<<maxCost<<endl;
        cout<<"CC="<<currentCost<<endl;
#endif
        if (costFunction.size()) {
                float scaley = 1.0f/log10(maxCost);
                float scalex = 1.0f/(float)costFunction.size();

                glDisable(GL_DEPTH_TEST);
                // init ortographic projection
                glMatrixMode(GL_PROJECTION);

                glPushMatrix();

                glLoadIdentity();
                gluOrtho2D(0, 1.0f, 0, 1.0f);

                glTranslatef(0.1f, 0.1f, 0.0f);
                glScalef(0.8f, 0.8f, 1.0f);
                glMatrixMode(GL_MODELVIEW);
                glLoadIdentity();

                glColor3f(1.0f,0,0);
                glBegin(GL_LINE_STRIP);
                //        glVertex3f(0,0,0);

                for (int i=0;  i < costFunction.size(); i++) {
                        float x =  i*scalex;
                        float y = log10(costFunction[i])*scaley;
                        glVertex3f(x,y,0.0f);
                }
                glEnd();

                glColor3f(1.0f,0,0);
                glBegin(GL_LINES);
                float x =  currentPos*scalex;
                glVertex3f(x,0.0,0.0f);
                glVertex3f(x,1.0f,0.0f);
                glEnd();

                glColor3f(0.0f,0,0);
                // show a grid
                glBegin(GL_LINE_LOOP);
                glVertex3f(0,0,0.0f);
                glVertex3f(1,0,0.0f);
                glVertex3f(1,1,0.0f);
                glVertex3f(0,1,0.0f);
                glEnd();

                glBegin(GL_LINES);
                for (int i=0;  i < costFunction.size(); i += 1000) {
                        float x =  i*scalex;
                        glVertex3f(x,0.0,0.0f);
                        glVertex3f(x,1.0f,0.0f);
                }

                for (int i=0;  pow(10.0f, i) < maxCost; i+=1) {
                        float y = i*scaley;
                        //              QString s;
                        //              s.sprintf("%d", (int)pow(10,i));
                        //              renderText(width()/2+5, y*height(), s);
                        glVertex3f(0.0f, y, 0.0f);
                        glVertex3f(1.0f, y, 0.0f);
                }

                glEnd();


                // restore the projection matrix
                glMatrixMode(GL_PROJECTION);
                glPopMatrix();
                glMatrixMode(GL_MODELVIEW);
                glEnable(GL_DEPTH_TEST);

        }



}

void
QtGlRendererWidget::RenderInfo()
{

        QString s;

        int vc = 0;
        if (mViewCellsManager)
                vc = (int)mViewCellsManager->GetViewCells().size();

        int filter = 0;
        if (mViewCellsManager)
                filter = mViewCellsManager->GetMaxFilterSize();

#if 0 //REMOVE_TEMPORARY
        s.sprintf("frame:%04d viewpoint:(%4.1f,%4.1f,%4.1f) dir:(%4.1f,%4.1f,%4.1f)",
                mFrame,
                mViewPoint.x,
                mViewPoint.y,
                mViewPoint.z,
                mViewDirection.x,
                mViewDirection.y,
                mViewDirection.z
                );

        renderText(20, 20, s);

        s.sprintf("viewcells:%04d filter:%04d pvs:%04d error:%5.5f %",
                vc,
                filter,
                mPvsSize,
                mRenderError * 100.0f);

        renderText(20, 40, s);
#endif

        glDisable(GL_LIGHTING);
        //qglColor(QColor(0, 255, 0));
        glColor3f(0, 1, 0);
        QFont font40; font40.setPointSize(25);
        //s.sprintf("PVS: %04d", mPvsSize);
        //renderText(20, 40, s, font40);
        
        //s.sprintf("RAW TRI: %07d", mViewCellsManager->GetPreprocessor()->mGenericStats);
        //renderText(290, 40, s, font40);
        //s.sprintf("PVS TRI: %07d", mViewCellsManager->GetPreprocessor()->mGenericStats2);
        //renderText(290, 70, s, font40);

        s.sprintf("PVS TRI: %08d", (int)mCurrentPvsCost);
        //renderText(290, 70, s, font40);
        renderText(200, 40, s, font40);
#if 0
        s.sprintf("error: %3.3f %", mRenderError * 100.0f);
        renderText(20, 40, s, font40);
#endif
        //renderText(290, 70, s, font40);
        glEnable(GL_LIGHTING);

}


void
QtGlRendererWidget::SetViewCellGranularity(int number)
{
        if (mViewCellsManager)
        {
                //      mViewCellsManager->SetMaxFilterSize(number);

                // $$ tmp off
                mViewCellsManager->CollectViewCells(number);

                // $$ does not work so far:(
                //      mViewCellsManager->UpdatePvsForEvaluation();
                //      mViewCellsManager->FinalizeViewCells(false);
        }
        updateGL();
}

void
QtGlRendererWidget::SetVisibilityFilterSize(int number)
{
        if (mViewCellsManager) 
                mViewCellsManager->SetMaxFilterSize(number);

        mPvsCache.Reset();
        updateGL();
}

void
QtGlRendererWidget::SetSpatialFilterSize(int number)
{
        mSpatialFilterSize = 1e-3*number;
        mPvsCache.Reset();
        updateGL();
}

void
QtGlRendererWidget::SetSceneCut(int number)
{
        // assume the cut plane can only be aligned with xz plane
        // shift it along y according to number, which is percentage of the bounding
        // box position
        if (mViewCellsManager) 
        {
                const float f = number / 1000.0f;
                AxisAlignedBox3 box = mViewCellsManager->GetViewSpaceBox();
                Vector3 p = (1.0f - f) * box.Min() + f * box.Max();
                mSceneCutPlane.mNormal = Vector3(0, -1, 0);
                mSceneCutPlane.mD = -DotProd(mSceneCutPlane.mNormal, p);

                cout << "cut view cells at " << number << endl;
                updateGL();
        }
}

void
QtGlRendererWidget::SetHidingCost(int number)
{
        mHidingCost = (float)number / 1000.0f;
}


void
QtGlRendererWidget::SetTopDistance(int number)
{
        mTopDistance = number / 1000.0f;
        updateGL();
}


void
QtGlRendererWidget::SetMaxRenderCost(int number)
{
        mMaxRenderCost = number * 1000.0f;
        cout << "max render cost at " << number << endl;
        updateGL();
}

void QtGlRendererWidget::SetTransparency(int number)
{
        mTransparency = number / 1000.0f;
        updateGL();
}


float QtGlRendererWidget::ComputeRenderCost(ViewCell *vc)
{
        
#ifdef USE_VERBOSE_PVS
        // $matt temp
        return vc->GetPvs().mStats.mWeightedTriangles;

        if (mShowDistanceWeightedPvs)
        {
                return vc->GetPvs().mStats.mDistanceWeightedPvs;
        }
        else if (mShowDistanceWeightedTriangles)
        {
                return vc->GetPvs().mStats.mDistanceWeightedTriangles;
        }
        else //if (mShowWeightedTriangles)
        {
                return vc->GetPvs().mStats.mWeightedTriangles;
        }
#else
        return 0.0f;
#endif
}


void QtGlRendererWidget::ComputeMaxValues(const ViewCellContainer &viewCells,
                                                                                  int &maxPvs, 
                                                                                  int &maxPiercingRays, 
                                                                                  float &maxRelativeRays, 
                                                                                  float &maxCost)
{
        maxPvs = -1;
        maxPiercingRays = 1; // not zero for savety
        maxRelativeRays = Limits::Small; // not zero for savety
        maxCost = Limits::Small;

        for (size_t i = 0; i < viewCells.size(); ++ i) 
        {
                ViewCell *vc = viewCells[i];

                if (mShowPvsSizes) // pvs size
                {
                        //const int p = vc->GetPvs().CountObjectsInPvs();
                        const int p = vc->GetPvs().GetSize();
                        if (p > maxPvs)
                                maxPvs = p;
                }
                else if (mShowPiercingRays) // relative number of rays
                {
                        const int piercingRays = vc->GetNumPiercingRays();

                        if (piercingRays > maxPiercingRays)
                                maxPiercingRays = piercingRays;
                } 
                else if (mShowWeightedRays)
                {
                        const int piercingRays = vc->GetNumPiercingRays();

                        const float relativeArea = 
                                vc->GetBox().SurfaceArea() / mViewCellsManager->GetViewSpaceBox().SurfaceArea();

                        if ((float)piercingRays / relativeArea > maxRelativeRays)
                                maxRelativeRays = (float)piercingRays / relativeArea;
                }
                else if (mShowWeightedCost)
                {
                        const float rCost = ComputeRenderCost(vc);
                        mViewCellsManager->UpdateScalarPvsCost(vc, rCost);

                        if (rCost > maxCost)
                                maxCost = rCost;
                }
        }
}


void QtGlRendererWidget::RenderViewCells()
{
        mUseFalseColors = true;
        //glPushAttrib(GL_CURRENT_BIT | GL_ENABLE_BIT | GL_POLYGON_BIT);

        glEnable(GL_CULL_FACE);
        glCullFace(GL_FRONT);
        //glDisable(GL_CULL_FACE);

        if (mCutViewCells) 
        {
                double eq[4];
                eq[0] = mSceneCutPlane.mNormal.x;
                eq[1] = mSceneCutPlane.mNormal.y;
                eq[2] = mSceneCutPlane.mNormal.z;
                eq[3] = mSceneCutPlane.mD;

                glClipPlane(GL_CLIP_PLANE0, eq);
                glEnable(GL_CLIP_PLANE0);
        }

        ViewCellContainer &viewcells = mViewCellsManager->GetViewCells();
        
        int maxPvs, maxPiercingRays;
        float maxRelativeRays, maxCost;

        ComputeMaxValues(viewcells, maxPvs, maxPiercingRays, maxRelativeRays, maxCost);
        static int currentMaxCost = 0;

        if (maxCost > currentMaxCost + 100000)
        {
                currentMaxCost = maxCost;
                cout << "maxCost: " << maxCost << endl;
        }

        // set the max render cost to fixed value
        maxCost = mMaxRenderCost;

        // transparency 
        if (!mUseTransparency)
        {
                glEnable(GL_DEPTH_TEST);
                glDisable(GL_BLEND);
        }
        else
        {
                glDisable(GL_DEPTH_TEST);
                glEnable(GL_BLEND);

                glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
                //glBlendFunc(GL_SRC_ALPHA, GL_ONE);

                for (int i = 0; i < viewcells.size(); ++ i) 
                {
                        ViewCell *vc = viewcells[i];

                        const float dist = SqrDistance(mDummyViewPoint, vc->GetBox().Center());
                        vc->SetDistance(dist);
                }

                sort(viewcells.begin(), viewcells.end(), nearerThan);
        }

                
        // default rendering
        //if (!mShowPvsSizes && !mShowPiercingRays && !mShowWeightedRays && !mShowWeightedCost && !mShowComparison)
        if (mUseStandardColors)
        {
                for (int i = 0; i < viewcells.size(); ++ i) 
                {
                        ViewCell *vc = viewcells[i];
                        RgbColor c;

                        //if (!mShowPvsSizes && !mShowPiercingRays)
                        c = vc->GetColor();
                        
                        glColor3f(c.r, c.g, c.b);

                        if (!mHideByCost || (mHidingCost < (vc->GetNumPiercingRays() / (float)maxPiercingRays))) 
                        {
                RenderViewCell(vc);
                        }
                }
        }
        else // using specialised colors
        {
                if (!mShowComparison)
                        AssignImportanceByRelativeValue(viewcells, maxPvs, maxPiercingRays, maxRelativeRays, maxCost);
                else
                {
                        if (mCompareInfo.empty())
                        {
                                LogReader reader;
                                reader.SetFilename("compare.log");
                                int samples;
                                reader.Read(samples, mCompareInfo);
                        }

                        AssignColorByComparison(viewcells, mCompareInfo);
                }

                glEnable(GL_DEPTH_TEST);        
        }
        
        glEnable(GL_CULL_FACE);
        glDisable(GL_CULL_FACE);

        glDisable(GL_CLIP_PLANE0);

        mUseFalseColors = false;
        //mWireFrame = false;

        glPopAttrib();
}


void QtGlRendererWidget::AssignImportanceByRelativeValue(const ViewCellContainer &viewCells,
                                                                                                                 int &maxPvs, 
                                                                                                                 int &maxPiercingRays, 
                                                                                                                 float &maxRelativeRays, 
                                                                                                                 float &maxRcCost)
{
        for (size_t i = 0; i < viewCells.size(); ++ i) 
        {
                RgbColor c;
                ViewCell *vc = viewCells[i];

                float importance;

                if (mShowPiercingRays)
                {
                        importance = mTransferFunction *
                                ((float)vc->GetNumPiercingRays() / (float)maxPiercingRays);
                }
                else if (mShowWeightedRays) // relative number of rays
                {
                        float relativeArea = vc->GetBox().SurfaceArea() / mViewCellsManager->GetViewSpaceBox().SurfaceArea();

                        if (relativeArea < Limits::Small)
                                relativeArea = Limits::Small;

                        importance = mTransferFunction * ((float)vc->GetNumPiercingRays() / relativeArea) / maxRelativeRays;
                }
                else if (mShowPvsSizes) // pvs size
                {
                        importance = mTransferFunction *
                                ((float)vc->GetPvs().GetSize() / (float)maxPvs);
                } // weighted render cost
                else if (mShowWeightedCost)
                {
                        const float rcCost = mTransferFunction * ComputeRenderCost(vc);
                        importance = rcCost / maxRcCost;
                }
                
                if (importance > 1.0f) importance = 1.0f;
                // c = RgbColor(importance, 1.0f - importance, 0.0f);
                c = RainbowColorMapping(importance);

                glColor4f(c.r, c.g, c.b, 1.0f - mTransparency);

                if (!mHideByCost || (mHidingCost < importance)) 
                {
                        RenderViewCell(vc);
                }
        }
}


void QtGlRendererWidget::AssignColorByComparison(const ViewCellContainer &viewcells,
                                                                                                 //const ViewCellInfoContainer &infos1, 
                                                                                                 const ViewCellInfoContainer &compareInfo)
{
        if (viewcells.size() > compareInfo.size())
        {
                cerr << "loaded size (" << (int)compareInfo.size() 
                         << ") does not fit to view cells size (" << (int)viewcells.size() << ")" << endl;
                return;
        }

        //const float maxRatio = 1.0f;
        const float maxRatio = 2.0f;
        const float minRatio = 0.0f;

        const float scale = 1.0f / (maxRatio - minRatio);

        for (size_t i = 0; i < viewcells.size(); ++ i) 
        {
                RgbColor c;
                ViewCell *vc = viewcells[i];

                //ViewCellInfo vc1Info = infos1[i];
                ViewCellInfo vc2Info = compareInfo[i];

                //const float vcRatio = vc->GetNumPiercingRays() / vc2Info.mPiercingRays + Limits::Small;
                float vcRatio = 1.0f;//maxRatio;
                
                if (vc2Info.mPvsSize > Limits::Small) 
                        vcRatio = (float)vc->GetPvs().GetSize() / vc2Info.mPvsSize;

                // truncate here
                if (vcRatio > maxRatio) vcRatio = 1.0f;

                const float importance = (vcRatio - minRatio) * scale;
        
                if (0 && (i < 20))
                {
                        cout << "pvs1: " << vc->GetPvs().GetSize() << " pvs2: " 
                                 << compareInfo[i].mPvsSize << " importance: " << importance << endl;
                }

                // c = RgbColor(importance, 1.0f - importance, 0.0f);
                c = RainbowColorMapping(importance);

                glColor4f(c.r, c.g, c.b, 1.0f);

                if (1)//!mHideByCost || (mHidingCost < importance)) 
                {
                        RenderViewCell(vc);
                }
        }
}



/**********************************************************************/
/*              QtRendererControlWidget implementation                */
/**********************************************************************/


QGroupBox *QtRendererControlWidget::CreateVisualizationPanel(QWidget *parent)
{
        QRadioButton *rb1, *rb2, *rb3, *rb4, *rb5;
        
        rb1 = new QRadioButton("random colors", parent);
        rb1->setText("random");
        connect(rb1, SIGNAL(toggled(bool)), SIGNAL(SetShowWireFrame(bool)));

        // Create a check box to be in the group box
        rb2 = new QRadioButton("piercing rays", parent);
        rb2->setText("piercing rays");
        //vl->addWidget(rb1);
        connect(rb2, SIGNAL(toggled(bool)), SIGNAL(SetShowPiercingRays(bool)));

        rb3 = new QRadioButton("pvs size", parent);
        rb3->setText("pvs size");
        connect(rb3, SIGNAL(toggled(bool)), SIGNAL(SetShowPvsSizes(bool)));
        
        rb4 = new QRadioButton("weighted rays", parent);
        rb4->setText("weighted rays");
        connect(rb4, SIGNAL(toggled(bool)), SIGNAL(SetShowWeightedRays(bool)));
        
        rb5 = new QRadioButton("pvs cost", parent);
        rb5->setText("pvs cost");
        connect(rb5, SIGNAL(toggled(bool)), SIGNAL(SetShowWeightedCost(bool)));

        QGroupBox *groupBox = new QGroupBox("PVS Visualization");

        QVBoxLayout *vbox2 = new QVBoxLayout;
    
        vbox2->addWidget(rb1);
        vbox2->addWidget(rb2);
        vbox2->addWidget(rb3);
        vbox2->addWidget(rb4);
        vbox2->addWidget(rb5);
        
        rb5->setChecked(true);

        vbox2->addStretch(1);
        groupBox->setLayout(vbox2);

        return groupBox;
}


QGroupBox *QtRendererControlWidget::CreateTrafoPanel(QWidget *parent)
{
        QRadioButton *rb1, *rb2, *rb3;
        
        rb1 = new QRadioButton("translation", parent);
        rb1->setText("translation");
        connect(rb1, SIGNAL(toggled(bool)), SIGNAL(SetTranslation(bool)));

        // Create a check box to be in the group box
        rb2 = new QRadioButton("scale", parent);
        rb2->setText("scale");
        //vl->addWidget(rb1);
        connect(rb2, SIGNAL(toggled(bool)), SIGNAL(SetScale(bool)));

        rb3 = new QRadioButton("rotation", parent);
        rb3->setText("rotation");
        connect(rb3, SIGNAL(toggled(bool)), SIGNAL(SetRotation(bool)));
    
        QVBoxLayout *vbox2 = new QVBoxLayout;
        QGroupBox *groupBox = new QGroupBox("Dynamic Obojects");

        vbox2->addWidget(rb1);
        vbox2->addWidget(rb2);
        vbox2->addWidget(rb3);
        
        rb1->setChecked(true);

        vbox2->addStretch(1);


        QPushButton *button = new QPushButton("Update", groupBox);
        vbox2->addWidget(button);
        connect(button, SIGNAL(clicked()), SIGNAL(UpdateDynamicObjects()));
        
        button = new QPushButton("Delete", groupBox);
        vbox2->addWidget(button);
        connect(button, SIGNAL(clicked()), SIGNAL(DeleteDynamicObject()));
        
        button = new QPushButton("Next object", groupBox);
        vbox2->layout()->addWidget(button);
        connect(button, SIGNAL(clicked()), SIGNAL(NextObject()));

        groupBox->setLayout(vbox2);
        
        return groupBox;
}


QGroupBox *QtRendererControlWidget::CreateRenderCostPanel(QWidget *parent)
{
        QRadioButton *rb1, *rb2, *rb3;
        
        // Create a check box to be in the group box
        rb1 = new QRadioButton("triangles", parent);
        rb1->setText("triangles");
        connect(rb1, SIGNAL(toggled(bool)), SIGNAL(SetShowWeightedTriangles(bool)));

        rb2 = new QRadioButton("distance weighted pvs", parent);
        rb2->setText("distance weighted");
        connect(rb2, SIGNAL(toggled(bool)), SIGNAL(SetShowDistanceWeightedPvs(bool)));

        rb3 = new QRadioButton("distance weighted triangles", parent);
        rb3->setText("distance weighted triangles");
        connect(rb3, SIGNAL(toggled(bool)), SIGNAL(SetShowDistanceWeightedTriangles(bool)));

        QGroupBox *groupBox = new QGroupBox("Render cost options");
        QVBoxLayout *vbox2 = new QVBoxLayout;
    
        vbox2->addWidget(rb1);
        vbox2->addWidget(rb2);
        vbox2->addWidget(rb3);
        
        rb1->setChecked(true);

        vbox2->addStretch(1);
        groupBox->setLayout(vbox2);

        return groupBox;
}


QGroupBox *QtRendererControlWidget::CreateRayVisualizationPanel(QWidget *parent)
{
        QRadioButton *rb1, *rb2, *rb3, *rb4;
        
        // Create a check box to be in the group box
        rb1 = new QRadioButton("const color", parent);
        rb1->setText("const color");
        //vl->addWidget(rb1);
        connect(rb1, SIGNAL(toggled(bool)), SIGNAL(UseConstColorForRayViz(bool)));

        rb2 = new QRadioButton("ray length", parent);
        rb2->setText("ray length");
        connect(rb2, SIGNAL(toggled(bool)), SIGNAL(UseRayLengthForRayViz(bool)));
        
        rb3 = new QRadioButton("contribution", parent);
        rb3->setText("contribution");
        connect(rb3, SIGNAL(toggled(bool)), SIGNAL(SetShowContribution(bool)));
        
        rb4 = new QRadioButton("distribution", parent);
        rb4->setText("distribution");
        connect(rb4, SIGNAL(toggled(bool)), SIGNAL(SetShowDistribution(bool)));


        ///////////////////////////

        QGroupBox *groupBox = new QGroupBox("Ray visualization");
        QVBoxLayout *vbox2 = new QVBoxLayout;
    
        vbox2->addWidget(rb1);
        vbox2->addWidget(rb2);
        vbox2->addWidget(rb3);
        vbox2->addWidget(rb4);
        
        rb1->setChecked(true);


        QCheckBox *cb = new QCheckBox("Distribution 1", parent);
        vbox2->addWidget(cb);
        cb->setChecked(true);
        connect(cb, SIGNAL(toggled(bool)), SIGNAL(SetShowDistribution1(bool)));

        cb = new QCheckBox("Distribution 2", parent);
        vbox2->addWidget(cb);
        cb->setChecked(true);
        connect(cb, SIGNAL(toggled(bool)), SIGNAL(SetShowDistribution2(bool)));

        cb = new QCheckBox("Distribution 3", parent);
        vbox2->addWidget(cb);
        cb->setChecked(true);
        connect(cb, SIGNAL(toggled(bool)), SIGNAL(SetShowDistribution3(bool)));
        
        cb = new QCheckBox("Distribution 4", parent);
        vbox2->addWidget(cb);
        cb->setChecked(true);
        connect(cb, SIGNAL(toggled(bool)), SIGNAL(SetShowDistribution4(bool)));

        vbox2->addStretch(1);
        groupBox->setLayout(vbox2);

        return groupBox;
}


QtRendererControlWidget::QtRendererControlWidget(QWidget * parent, Qt::WFlags f):
QWidget(parent, f)
{

        QVBoxLayout *vl = new QVBoxLayout;
        setLayout(vl);
        
        //QWidget *vbox;

        //vbox = new QGroupBox("Render Controls", this);
        //layout()->addWidget(vbox);
        //vl = new QVBoxLayout;
        //vbox->setLayout(vl);

        QLabel *label;
        QSlider *slider;
        QPushButton *button;

#if 0//REMOVE_TEMPORARY

        label = new QLabel("Granularity");
        //vbox->layout()->addWidget(label);
        vl->addWidget(label);

        slider = new QSlider(Qt::Horizontal);
        vl->addWidget(slider);
        slider->show();
        slider->setRange(1, 10000);
        slider->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
        slider->setValue(200);

        connect(slider, SIGNAL(valueChanged(int)), SIGNAL(SetViewCellGranularity(int)));

        ///////////////////////////

        label = new QLabel("Transfer function");
        vl->addWidget(label);

        slider = new QSlider(Qt::Horizontal);
        vl->addWidget(slider);
        slider->show();
        slider->setRange(1, 10000);
        slider->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
        slider->setValue(100);


        connect(slider, SIGNAL(valueChanged(int)), SIGNAL(SetTransferFunction(int)));

        ////////////////////////////////////////7

        button = new QPushButton("Update all PVSs");
        vl->addWidget(button);
        connect(button, SIGNAL(clicked()), SLOT(UpdateAllPvs()));

        ////////////////////////////////////////77777

        label = new QLabel("Filter size");
        vl->addWidget(label);

        slider = new QSlider(Qt::Horizontal);
        vl->addWidget(slider);
        slider->show();
        slider->setRange(1, 100);
        slider->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
        slider->setValue(3);

        connect(slider, SIGNAL(valueChanged(int)), SIGNAL(SetVisibilityFilterSize(int)));

#endif


        
        ///////////////////////////////////


        QWidget *hbox = new QWidget();
        vl->addWidget(hbox);
        QHBoxLayout *hlayout = new QHBoxLayout;
        hbox->setLayout(hlayout);

        QCheckBox *cb = new QCheckBox("Show viewcells", hbox);
        hlayout->addWidget(cb);
        cb->setChecked(false);
        connect(cb, SIGNAL(toggled(bool)), SIGNAL(SetShowViewCells(bool)));
        
        cb = new QCheckBox("Render errors", hbox);
        hlayout->layout()->addWidget(cb);
        cb->setChecked(false);
        connect(cb, SIGNAL(toggled(bool)), SIGNAL(SetRenderErrors(bool)));

#if 0
        cb = new QCheckBox("Render cost curve", hbox);
        hlayout->addWidget(cb);
        cb->setChecked(false);
        connect(cb, SIGNAL(toggled(bool)), SIGNAL(SetShowRenderCost(bool)));
#endif
        cb = new QCheckBox("Show rays", hbox);
        hlayout->addWidget(cb);
        cb->setChecked(false);
        connect(cb, SIGNAL(toggled(bool)), SIGNAL(SetShowRays(bool)));
#if 0   
        cb = new QCheckBox("Show Comparison", hbox);
        hlayout->addWidget(cb);
        cb->setChecked(false);
        connect(cb, SIGNAL(toggled(bool)), SIGNAL(SetShowComparison(bool)));
#endif

        //////////////////

        QHBoxLayout *vh = new QHBoxLayout;

        QGroupBox *myBox = new QGroupBox("Visualization");

        myBox->setLayout(vh);
        vl->addWidget(myBox, 0, 0);

        QGroupBox *groupBox = CreateVisualizationPanel(hbox);
        vh->addWidget(groupBox, 0, 0);


        QGroupBox *groupBox2 = CreateRenderCostPanel(hbox);
        vh->addWidget(groupBox2, 0, 0);
#if 0   
        QGroupBox *groupBox3 = CreateRayVisualizationPanel(hbox);
        vh->addWidget(groupBox3, 0, 0);
#endif

#if 1
        QGroupBox *groupBox4 = CreateTrafoPanel(hbox);
        vh->addWidget(groupBox4, 0, 0);
#endif

        //////////////////////////////////

        bool tmp = false;
        const int range = 1000;

        //vbox->resize(800,150);
        QWidget *vbox;

        vbox = new QGroupBox("Rendering", this);
        layout()->addWidget(vbox);

        vl = new QVBoxLayout;
        vbox->setLayout(vl);


        cb = new QCheckBox("Cut view cells", vbox);
        vbox->layout()->addWidget(cb);
        cb->setChecked(false);
        connect(cb, SIGNAL(toggled(bool)), SIGNAL(SetCutViewCells(bool)));


        slider = new QSlider(Qt::Horizontal, vbox);
        vbox->layout()->addWidget(slider);
        slider->show();
        slider->setRange(0, 1000);
        slider->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
        slider->setValue(1000);

        connect(slider, SIGNAL(valueChanged(int)), SIGNAL(SetSceneCut(int)));

#if 0
        cb = new QCheckBox("Use spatial filter", vbox);
        vbox->layout()->addWidget(cb);
        Environment::GetSingleton()->GetBoolValue("Preprocessor.applyVisibilitySpatialFilter", tmp);
        cb->setChecked(tmp);
        connect(cb, SIGNAL(toggled(bool)), SIGNAL(SetUseSpatialFilter(bool)));


        label = new QLabel("Spatial Filter size");
        vbox->layout()->addWidget(label);
        
        slider = new QSlider(Qt::Horizontal, vbox);
        vbox->layout()->addWidget(slider);
        slider->show();
        slider->setRange(1, 100);
        slider->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
        slider->setValue(10);

        connect(slider, SIGNAL(valueChanged(int)), SIGNAL(SetSpatialFilterSize(int)));
#endif
        ////////////////////////////

        
        cb = new QCheckBox("Hide view cells by render cost ", vbox);
        vbox->layout()->addWidget(cb);
        cb->setChecked(false);
        connect(cb, SIGNAL(toggled(bool)), SIGNAL(SetHideByCost(bool)));

        label = new QLabel("Hide by cost");
        vbox->layout()->addWidget(label);

        // the render cost visualization
        slider = new QSlider(Qt::Horizontal, vbox);
        vbox->layout()->addWidget(slider);
        slider->show();
        slider->setRange(0, range);
        slider->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
        slider->setValue(0);
        connect(slider, SIGNAL(valueChanged(int)), SIGNAL(SetHidingCost(int)));

        ///////////////////////////////////////////
#if 0
        cb = new QCheckBox("Top View", vbox);
        vbox->layout()->addWidget(cb);
        cb->setChecked(false);
        connect(cb, SIGNAL(toggled(bool)), SIGNAL(SetTopView(bool)));


        label = new QLabel("Top distance");
        vbox->layout()->addWidget(label);
        
        slider = new QSlider(Qt::Horizontal, vbox);
        vbox->layout()->addWidget(slider);
        slider->show();
        slider->setRange(1, 1000);
        slider->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
        slider->setValue(500);

        connect(slider, SIGNAL(valueChanged(int)), SIGNAL(SetTopDistance(int)));
        
#endif
        label = new QLabel("Max render cost");
        vbox->layout()->addWidget(label);
        
        slider = new QSlider(Qt::Horizontal, vbox);
        vbox->layout()->addWidget(slider);
        slider->show();
        slider->setRange(1, 1000);
        slider->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
        
        slider->setValue(500);


        connect(slider, SIGNAL(valueChanged(int)), SIGNAL(SetMaxRenderCost(int)));
        


        ///////////////////////////////////////////
#if REMOVE_TEMPORARY
        cb = new QCheckBox("Transparency", vbox);
        vbox->layout()->addWidget(cb);
        cb->setChecked(false);
        connect(cb, SIGNAL(toggled(bool)), SIGNAL(SetUseTransparency(bool)));

        label = new QLabel("Use transparency");
        vbox->layout()->addWidget(label);

        // the render cost visualization
        slider = new QSlider(Qt::Horizontal, vbox);
        vbox->layout()->addWidget(slider);
        slider->show();
        slider->setRange(0, range);
        slider->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
        slider->setValue(0);
        connect(slider, SIGNAL(valueChanged(int)), SIGNAL(SetTransparency(int)));
#endif
        

        //////////////////////////////

#if REMOVE_TEMPORARY

        cb = new QCheckBox("Cut scene", vbox);
        vbox->layout()->addWidget(cb);
        cb->setChecked(false);
        connect(cb, SIGNAL(toggled(bool)), SIGNAL(SetCutScene(bool)));

        cb = new QCheckBox("Render boxes", vbox);
        vbox->layout()->addWidget(cb);
        cb->setChecked(false);
        connect(cb, SIGNAL(toggled(bool)), SIGNAL(SetRenderBoxes(bool)));

        cb = new QCheckBox("Render visibility estimates", vbox);
        vbox->layout()->addWidget(cb);
        cb->setChecked(false);
        connect(cb, SIGNAL(toggled(bool)), SIGNAL(SetRenderVisibilityEstimates(bool)));
#endif

#if REMOVE_TEMPORARY

        cb = new QCheckBox("Use filter", vbox);
        vbox->layout()->addWidget(cb);
        Environment::GetSingleton()->GetBoolValue("Preprocessor.applyVisibilityFilter", tmp);
        cb->setChecked(tmp);
        connect(cb, SIGNAL(toggled(bool)), SIGNAL(SetUseFilter(bool)));
#endif

#if REMOVE_TEMPORARY
        
        cb = new QCheckBox("Render filter", vbox);
        vbox->layout()->addWidget(cb);
        cb->setChecked(true);
        connect(cb, SIGNAL(toggled(bool)), SIGNAL(SetRenderFilter(bool)));

        /*vbox = new QGroupBox("PVS Errors", this);
        layout()->addWidget(vbox);

        vl = new QVBoxLayout;
        vbox->setLayout(vl);

        button = new QPushButton("Compute Visibility", vbox);
        vbox->layout()->addWidget(button);
        connect(button, SIGNAL(clicked()), SLOT(ComputeVisibility()));

        button = new QPushButton("Stop Computation", vbox);
        vbox->layout()->addWidget(button);
        connect(button, SIGNAL(clicked()), SLOT(StopComputation()));

        button = new QPushButton("Set Random View Point", vbox);
        vbox->layout()->addWidget(button);
        connect(button, SIGNAL(clicked()), SLOT(SetRandomViewPoint()));*/

        button = new QPushButton("Store statistics", vbox);
        vbox->layout()->addWidget(button);
        connect(button, SIGNAL(clicked()), SIGNAL(StoreStatistics()));

#endif

#if 0
        
        button = new QPushButton("Compute GVS", vbox);
        vbox->layout()->addWidget(button);
        connect(button, SIGNAL(clicked()), SIGNAL(ComputeGVS()));
#endif
        
        button = new QPushButton("Replay view points", vbox);
        vbox->layout()->addWidget(button);
        connect(button, SIGNAL(clicked()), SIGNAL(ReplayViewPoints()));


        /*cb = new QCheckBox("Stats", vbox);
        vbox->layout()->addWidget(cb);
        cb->setChecked(false);
        connect(cb, SIGNAL(toggled(bool)), SIGNAL(StoreStatistics()));*/

        if (0) 
        {
                vbox = new QGroupBox("PVS Errors", this);
                layout()->addWidget(vbox);

                vl = new QVBoxLayout;
                vbox->setLayout(vl);

                mPvsErrorWidget = new QListWidget(vbox);
                vbox->layout()->addWidget(mPvsErrorWidget);

                connect(mPvsErrorWidget,
                        SIGNAL(doubleClicked(const QModelIndex &)),
                        this,
                        SLOT(PvsErrorClicked(const QModelIndex &)));

                button = new QPushButton("Next Error Frame", vbox);
                vbox->layout()->addWidget(button);
                connect(button, SIGNAL(clicked(void)), SLOT(FocusNextPvsErrorFrame(void)));
        }
        
        //connect(button, SIGNAL(clicked(void)), SLOT(StoreStatistics(void)));
        
        //////////////////////////////////////////


        setWindowTitle("Preprocessor Control Widget");
        adjustSize();
}




void
QtRendererControlWidget::FocusNextPvsErrorFrame(void)
{}

void
QtRendererControlWidget::UpdatePvsErrorItem(int row,
                                                                                        GlRendererBuffer::PvsErrorEntry &pvsErrorEntry)
{
#if 0
        QListWidgetItem *i = mPvsErrorWidget->item(row);
        QString s;
        s.sprintf("%5.5f", pvsErrorEntry.mError);
        if (i) {
                i->setText(s);
        } else {
                new QListWidgetItem(s, mPvsErrorWidget);
        }
        mPvsErrorWidget->update();
#endif
}




/*********************************************************************/
/*                   QtGlDebuggerWidget implementation               */
/*********************************************************************/


QtGlDebuggerWidget::QtGlDebuggerWidget(QtGlRendererBuffer *buf, QWidget *parent)
: QGLWidget(QGLFormat(QGL::SampleBuffers), parent), mRenderBuffer(buf)
{
        // create the pbuffer
        //pbuffer = new QGLPixelBuffer(QSize(512, 512), format(), this);
        //mUpdateTimerId = startTimer(20);
        setWindowTitle(("OpenGL pbuffers"));
}


QtGlDebuggerWidget::~QtGlDebuggerWidget()
{
        mRenderBuffer->releaseFromDynamicTexture();
        glDeleteTextures(1, &dynamicTexture);

        DEL_PTR(mRenderBuffer);
}


void QtGlDebuggerWidget::initializeGL()
{
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();

        glFrustum(-1, 1, -1, 1, 10, 100);
        glTranslatef(-0.5f, -0.5f, -0.5f);
        glTranslatef(0.0f, 0.0f, -15.0f);
        glMatrixMode(GL_MODELVIEW);

        glEnable(GL_CULL_FACE);
        initCommon();
        initPbuffer();

}


void QtGlDebuggerWidget::resizeGL(int w, int h)
{
        glViewport(0, 0, w, h);
}


void QtGlDebuggerWidget::paintGL()
{
        // draw a spinning cube into the pbuffer..
        mRenderBuffer->makeCurrent();

        BeamSampleStatistics stats;
        mRenderBuffer->SampleBeamContributions(mSourceObject, mBeam, mSamples, stats);

        glFlush();

        // rendering directly to a texture is not supported on X11, unfortunately
        mRenderBuffer->updateDynamicTexture(dynamicTexture);

        // and use the pbuffer contents as a texture when rendering the
        // background and the bouncing cubes
        makeCurrent();
        glBindTexture(GL_TEXTURE_2D, dynamicTexture);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        // draw the background
        glMatrixMode(GL_MODELVIEW);
        glPushMatrix();
        glLoadIdentity();
        glMatrixMode(GL_PROJECTION);
        glPushMatrix();
        glLoadIdentity();

        glPopMatrix();
        glMatrixMode(GL_MODELVIEW);
        glPopMatrix();
}


void QtGlDebuggerWidget::initPbuffer()
{
        // set up the pbuffer context
        mRenderBuffer->makeCurrent();
        // generate a texture that has the same size/format as the pbuffer
        dynamicTexture = mRenderBuffer->generateDynamicTexture();
        // bind the dynamic texture to the pbuffer - this is a no-op under X11
        mRenderBuffer->bindToDynamicTexture(dynamicTexture);
        //makeCurrent();
}


void QtGlDebuggerWidget::initCommon()
{
        glEnable(GL_TEXTURE_2D);
        glEnable(GL_DEPTH_TEST);

        glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
}



void QtGlRendererWidget::UpdateDynamicObjects()
{
        preprocessor->ScheduleUpdateDynamicObjects();  
}


void QtGlRendererWidget::ReplayViewPoints()
{
        ViewCellPointsList *vcPoints = mViewCellsManager->GetViewCellPointsList();

        ViewCellPointsList::const_iterator vit, vit_end = vcPoints->end();

        sViewPointsList.clear();

        for (vit = vcPoints->begin(); vit != vit_end; ++ vit) 
        {
                ViewCellPoints *vp = *vit;

                SimpleRayContainer::const_iterator rit, rit_end = vp->second.end();
        
                for (rit = vp->second.begin(); rit != rit_end; ++ rit)
                {
                        sViewPointsList.push_back(*rit);
                }
        }

        if (!sViewPointsList.empty())
        {
                cout << "replaying " << (int)sViewPointsList.size() << " view points " << endl;
                
                mReplayMode = true;
                
                if (mExportFrameBuffer)
                        GetPreprocessor()->mSynchronize = true;

                sCurrentSamples = GetPreprocessor()->mCurrentSamples;
                sViewPointsListIt = sViewPointsList.begin();
        }
        else
                cerr << "view points list empty" << endl;
                
}



Vector3 QtGlRendererWidget::Unproject(int x, int y)
{
        // swap y coordinate
        y = GetHeight() - y;

        // HACK: should come from camera!
        double projection[16]; 
        glGetDoublev(GL_PROJECTION_MATRIX, projection); 
        double modelview[16];
        glGetDoublev(GL_MODELVIEW_MATRIX, modelview); 

        const int viewport[4] = {0,0, GetWidth(), GetHeight()};

        RenderScene();

        float z;
        glReadPixels(x, y, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &z);
        
        GLdouble rx, ry, rz;
        gluUnProject(x, y, z, modelview, projection, viewport, &rx, &ry, &rz);

        return Vector3(rx, ry, rz);
}


int QtGlRendererWidget::FindDynamicObject(float x, float y) 
{ 
        if (GetPreprocessor()->mDynamicObjects.empty())
                return -1;

        makeCurrent();
        
        // this is the same as in every OpenGL picking example 
        const int maxSize = 512; 
        
        // see below for an explanation on the buffer content 
        GLuint buffer[maxSize]; 
        glSelectBuffer(maxSize, buffer); 
        
        // enter select mode 
        glRenderMode(GL_SELECT); 
        glInitNames(); 
        glPushName(0); 
        
        glMatrixMode(GL_PROJECTION); 
        glPushMatrix(); 
        glLoadIdentity(); 

        glViewport(0, 0, width(), height());

        GLint viewport[4];
        glGetIntegerv(GL_VIEWPORT, viewport); 

        const float w = 1.0f;

        //gluPickMatrix(x, y, 1000.0, 1000.0, viewport);
        gluPickMatrix((GLdouble)x, (GLdouble)(viewport[3] - y), w, w, viewport); 

        GLfloat aspect = (GLfloat) width() / height(); 
        gluPerspective(70.0f, aspect, 0.1f, 2.0f * Magnitude(mSceneGraph->GetBox().Diagonal()));
        
        glMatrixMode(GL_MODELVIEW);
        glPushMatrix(); 
        glLoadIdentity();
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        
        
        SetupCamera();

        for (GLuint i = 0; i < GetPreprocessor()->mDynamicObjects.size(); ++ i)
        {
                glLoadName(i);
                _RenderDynamicObject(GetPreprocessor()->mDynamicObjects[i]);
        }

        glFlush();
        glPopMatrix();

        glMatrixMode(GL_PROJECTION); 
        glPopMatrix();

        int hits = glRenderMode(GL_RENDER);

        // finally release the rendering context again 
        if (!hits) 
        { 
                cout << "no object picked" << endl;
                return -1; 
        } 

        //processHits(hits, buffer);
        
        // Each hit takes 4 items in the buffer. 
        // The first item is the number of names on the name stack when the hit occured. 
        // The second item is the minimum z value of all the verticies that intersected
        // the viewing area at the time of the hit. The third item is the maximum z value 
        // of all the vertices that intersected the viewing area at the time of the hit 
        // and the last item is the content of the name stack at the time of the hit 
        // (name of the object). We are only interested in the object name 
        // (number of the surface). 
        // return the name of the clicked surface 
        return buffer[3]; 
}


void QtGlRendererWidget::DeleteDynamicObject()
{
        Preprocessor *p = GetPreprocessor();

        if ((mCurrentDynamicObjectIdx < 0) ||
                (mCurrentDynamicObjectIdx >= p->mDynamicObjects.size()))
                return;

        cout << "deleting object" << endl;

        SceneGraphLeaf *l = p->mDynamicObjects[mCurrentDynamicObjectIdx];

        // tell the preprocessor that an object was deleted
        p->ObjectRemoved(l);

        swap(p->mDynamicObjects[mCurrentDynamicObjectIdx], p->mDynamicObjects.back());
        p->mDynamicObjects.pop_back();

        delete l;

        mCurrentDynamicObjectIdx = -1;
}       

}