source: trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellsManager.h @ 490

#ifndef _ViewCellsManager_H__
#define _ViewCellsManager_H__

#include "Ray.h"
#include "VssRay.h"
#include "Containers.h"
#include "ViewCell.h"

class ViewCell;
class Intersectable;
class RenderSimulator;
class Renderer;
class Mesh;
struct Triangle3;
class SimulationStatistics;
class BspTree;
class KdTree;
class VspKdTree;
class VspBspTree;
class KdNode;
class KdLeaf;
class VspKdTree;
class AxisAlignedBox3;
class BspLeaf;
class ViewCellsStatistics;
class Exporter;
struct BspRay;

/**
        Manages different higher order operations on the view cells.
*/
class ViewCellsManager
{

public:
  struct PvsStatistics {
        int minPvs;
        int maxPvs;
        float avgPvs;
        int viewcells;
  };
  
  /// view cell container types
  enum {BSP, KD, VSP_KD, VSP_BSP};
  
        /** Constructor taking the maximal number of samples used for construction
        */
        ViewCellsManager(const int constructionSamples);

        ViewCellsManager();

        virtual ~ViewCellsManager();

        /** Constructs view cell container with a given number of samples.
        */
        virtual int Construct(const ObjectContainer &objects, 
                                                  const VssRayContainer &rays) = 0;

        /** Computes sample contributions of the rays to the view cells PVS.
        
                @param rays bundle of rays used to find intersections with view cells and 
                adding the contribution
                @param castRays true if ray should be cast to gain the information, false if rays
                already hold the view cells intersection information and need not be recast.
                @param sampleContributions returns the number of sample contributions
                @param contributingSamples returns the number of contributingSamples
        */
        void  ComputeSampleContributions(const VssRayContainer &rays);


        /** Computes sample contribution of a simgle ray to the view cells PVS.
                @param ray finds intersections with view cells and holds the contribution
                @param castRay true if ray should be cast to gain the information, false if ray
                is already holding the information and need not be recast.
          
                @returns number of sample contributions
        */
        virtual void ComputeSampleContributions(VssRay &ray);
  
        /** Prints out statistics of the view cells.
        */
        virtual void PrintStatistics(ostream &s) const;

        /** Post processes view cells givemŽa number of rays.
        */
        virtual int PostProcess(const ObjectContainer &objects, 
                                                        const VssRayContainer &rays) = 0;

        /** Show visualization of the view cells.
        */
        virtual void Visualize(const ObjectContainer &objects,
                                                   const VssRayContainer &sampleRays) = 0;

        /** type of the view cell container.
        */
        virtual int GetType() const = 0;

        /** Load the input viewcells. The input viewcells should be given as a collection
                of meshes. Each mesh is assume to form a bounded polyhedron defining the interior of
                the viewcell. The method then builds a BSP tree of these view cells.
                
                @param filename file to load
                @return true on success
    */
    bool LoadViewCells(const string filename);

        /** Constructs view cell from base triangle. The ViewCell is extruded along the normal vector.
                @param the base triangle
                @param the height of the newly created view cell
        */
        ViewCell *ExtrudeViewCell(const Triangle3 &baseTri, const float height) const;

        /** Merges two view cells.
                @note the piercing rays of the front and back will be ordered   
                @returns new view cell based on the merging.
        */
        ViewCell *MergeViewCells(ViewCell &front, ViewCell &back) const;
        
        /** Generates view cell of type specified by this manager
        */
        virtual ViewCell *GenerateViewCell(Mesh *mesh = NULL) const;

        /** Adds a new view cell to the list of predefined view cells.
        */
        void AddViewCell(ViewCell *viewCell);

        /** Derive view cells from objects.
        */
        void DeriveViewCells(const ObjectContainer &objects, 
                                                 ViewCellContainer &viewCells, 
                                                 const int maxViewCells) const;

        /** Sets maximal number of samples used for the 
                construction of the view cells.
        */
        void SetVisualizationSamples(const int visSamples);

        /** Sets maximal number of samples used for the visualization of the view cells.
        */
        void SetConstructionSamples(const int constructionSamples);

        /** Sets maximal number of samples used for the post processing of the view cells.
        */
        void SetPostProcessSamples(const int postProcessingSamples);

        /** See set.
        */
        int GetVisualizationSamples() const;

        /** See set.
        */
        int GetConstructionSamples() const;

        /** See set.
        */
        int GetPostProcessSamples() const;

        /** Returns true if view cells wer already constructed.
        */
        virtual bool ViewCellsConstructed() const = 0;

        /** cast line segment to get a list of unique viewcells which are intersected
                by this line segment 
        */
  
        virtual int CastLineSegment(const Vector3 &origin,
                                                          const Vector3 &termination,
                                                          ViewCellContainer &viewcells
                                                          ) = 0;

        virtual void GetPvsStatistics(PvsStatistics &stat);

        virtual void PrintPvsStatistics(ostream &s);

        /** Returns probability that view point lies in one view cell.
        */
        virtual float GetProbability(ViewCell *viewCell) = 0;

        /** Returns render cost of a single view cell given the render cost of an object.
        */
        virtual float GetRendercost(ViewCell *viewCell, float objRendercost) const = 0;

        /** Returns vector of loaded / generated view cells.
        */
        ViewCellContainer &GetViewCells();

        /** Helper function used to split ray sets uniformly 
                into one that is currently used and the other that 
                is saved for later processing.
                @param sourceRays the input ray set
                @param maxSize the maximal number of rays that will be used
                @param usedRays returns the used ray set
                @param savedRays if not null, returns the saved ray set
        */
        void GetRaySets(const VssRayContainer &sourceRays,
                                        const int maxSize,
                                        VssRayContainer &usedRays, 
                                        VssRayContainer *savedRays = NULL) const;
        
        /** Returns accumulated area of all view cells.
        */
        float GetAccVcArea();

        /** Returns area of one view cell.
        */
        virtual float GetArea(ViewCell *viewCell) const;

        /** Returns volume of view cells.
        */
        virtual float GetVolume(ViewCell *viewCell) const;

        virtual AxisAlignedBox3 GetSceneBbox() const = 0;

        /** Sets the current renderer mainly for view cells statistics.
        */
        void SetRenderer(Renderer *renderer);

        /** Computes a (random) view point in the valid view space.
                @returns true if valid view point was found
        */
        virtual bool GetViewPoint(Vector3 &viewPoint) const;

        /** Returns true if this view point is in the valid view space.
        */
        virtual bool ViewPointValid(const Vector3 &viewPoint) const;

        /** Sets a view space boundary.
        */
        void SetViewSpaceBox(const AxisAlignedBox3 &box);


protected:

        void ParseEnvironment();

        /** Recollects view cells and resets statistics.
        */
        void ResetViewCells();
        
        /** Collects the view cells in the view cell container.
        */
        virtual void CollectViewCells() = 0;
        
        /** Evaluates view cells statistics and stores it in
                mViewCellsStatistics.
        */
        void EvaluateViewCellsStats();


        //-- helper functions for view cell visualization

        /** Exports the view cell partition.
        */
        void ExportViewCells(Exporter *exporter) const;

        /** Sets exporter color.
        */
        virtual void ExportColor(Exporter *exporter, ViewCell *vc) const = 0;

        /** Exports view cell geometry.
        */
        virtual void ExportVcGeometry(Exporter *exporter, ViewCell *vc) const = 0;

        /// the view cell corresponding to space ouside the valid view space
        //ViewCell *mOutOfBoundsCell;

        /// Renders the view cells.
        Renderer *mRenderer;

        /// Loaded view cells
        ViewCellContainer mViewCells;

        /// maximum number of samples taken for construction of the view cells
        int mConstructionSamples;
        int mPostProcessSamples;
        int mVisualizationSamples;

        //-- thresholds used for view cells merge
        int mMinPvsDif;
        int mMinPvs;
        int mMaxPvs;

        float mTotalAreaValid;
        float mTotalArea;

        ViewCellsStatistics mViewCellsStats;
        /// the scene bounding box
        AxisAlignedBox3 mSceneBox;

        //-- visualization options
        
        /// color code for view cells
        int mColorCode;
        bool mExportGeometry;
        bool mExportRays;
};



/**
        Manages different higher order operations on the view cells.
*/
class BspViewCellsManager: public ViewCellsManager
{

public:
        /** Constructor taking the bsp tree and the number of samples
                used to construct the bsp tree.
        */
        BspViewCellsManager(BspTree *tree, int constructionSamples);

        ~BspViewCellsManager();

        int Construct(const ObjectContainer &objects, 
                                  const VssRayContainer &rays);


        int PostProcess(const ObjectContainer &objects, 
                                        const VssRayContainer &rays);

        void Visualize(const ObjectContainer &objects,
                                   const VssRayContainer &sampleRays);

        int GetType() const;
        
        ViewCell *GenerateViewCell(Mesh *mesh = NULL) const;

        bool ViewCellsConstructed() const;

        //void PrintStatistics(ostream &s) const;

        int CastLineSegment(const Vector3 &origin,
                                                const Vector3 &termination,
                                                ViewCellContainer &viewcells);
        
        float GetProbability(ViewCell *viewCell);
        float GetRendercost(ViewCell *viewCell, float objRendercost) const;

        AxisAlignedBox3 GetSceneBbox() const;

protected:

        void CollectViewCells();

        /** Merges view cells front and back leaf view cell.
        */
        bool MergeBspLeafViewCells(BspLeaf *front, BspLeaf *back) const;

        /** Returns true if front and back leaf should be merged.
        */
        bool ShouldMerge(BspLeaf *front, BspLeaf *back) const;

        void ConstructBspRays(const VssRayContainer &rays,
                                                  const int numSamples);

        void ExportColor(Exporter *exporter, ViewCell *vc) const;
        void ExportVcGeometry(Exporter *exporter, ViewCell *vc) const;

        /// the BSP tree.
        BspTree *mBspTree;
        
        vector<BspRay *> mBspRays;

private:

        /** Exports visualization of the BSP splits.
        */
        void ExportSplits(const ObjectContainer &objects);

        /** Exports visualization of the BSP PVS.
        */
        void ExportBspPvs(const ObjectContainer &objects);

};

/**
        Manages different higher order operations on the KD type view cells.
*/
class KdViewCellsManager: public ViewCellsManager
{

public:

        KdViewCellsManager(KdTree *tree);

        int Construct(const ObjectContainer &objects, 
                                  const VssRayContainer &rays);

        int CastLineSegment(const Vector3 &origin,
                                                const Vector3 &termination,
                                                ViewCellContainer &viewcells);

        int PostProcess(const ObjectContainer &objects, 
                                        const VssRayContainer &rays);

        void Visualize(const ObjectContainer &objects,
                                   const VssRayContainer &sampleRays);

        int GetType() const;

        bool ViewCellsConstructed() const;


        /** Prints out statistics of this approach.
        */
        //void PrintStatistics(ostream &s) const;

        float GetProbability(ViewCell *viewCell);
        float GetRendercost(ViewCell *viewCell, float objRendercost) const;
        
        AxisAlignedBox3 GetSceneBbox() const;

protected:

        void CollectViewCells();
        KdNode *GetNodeForPvs(KdLeaf *leaf);

        void ExportColor(Exporter *exporter, ViewCell *vc) const;
        void ExportVcGeometry(Exporter *exporter, ViewCell *vc) const;

        /// the BSP tree.
        KdTree *mKdTree;

        /// depth of the KD tree nodes with represent the view cells
        int mKdPvsDepth;
};

/**
        Manages different higher order operations on the view cells 
        for vsp kd tree view cells.
*/
class VspKdViewCellsManager: public ViewCellsManager
{

public:

        VspKdViewCellsManager(VspKdTree *vspKdTree, int constructionSamples);

        int Construct(const ObjectContainer &objects, 
                                  const VssRayContainer &rays);


        int PostProcess(const ObjectContainer &objects, 
                                        const VssRayContainer &rays);

        void Visualize(const ObjectContainer &objects,
                                   const VssRayContainer &sampleRays);

        int GetType() const;
        
        bool ViewCellsConstructed() const;

        //virtual void PrintStatistics(ostream &s) const;

        ViewCell *GenerateViewCell(Mesh *mesh) const;


    int CastLineSegment(const Vector3 &origin,
                                                const Vector3 &termination,
                                                ViewCellContainer &viewcells);

        float GetProbability(ViewCell *viewCell);
        float GetRendercost(ViewCell *viewCell, float objRendercost) const;

        AxisAlignedBox3 GetSceneBbox() const;

protected:

        void ExportLeaves(const ObjectContainer &objects,
                                          const VssRayContainer &sampleRays);

        void CollectViewCells();

        void ExportColor(Exporter *exporter, ViewCell *vc) const;
        void ExportVcGeometry(Exporter *exporter, ViewCell *vc) const;


        /// the BSP tree.
        VspKdTree *mVspKdTree;
};



/**
        Manages different higher order operations on the view cells.
*/
class VspBspViewCellsManager: public ViewCellsManager
{

public:

        VspBspViewCellsManager(VspBspTree *tree, int constructionSamples);
        ~VspBspViewCellsManager();

        int Construct(const ObjectContainer &objects, 
                                  const VssRayContainer &rays);

        int PostProcess(const ObjectContainer &objects, 
                                        const VssRayContainer &rays);

        void Visualize(const ObjectContainer &objects,
                                   const VssRayContainer &sampleRays);

        int GetType() const;
        
        ViewCell *GenerateViewCell(Mesh *mesh = NULL) const;

        bool ViewCellsConstructed() const;

        //void PrintStatistics(ostream &s) const;
        
        int CastLineSegment(const Vector3 &origin,
                                                const Vector3 &termination,
                                                ViewCellContainer &viewcells);

        float GetProbability(ViewCell *viewCell);
        float GetRendercost(ViewCell *viewCell, float objRendercost) const;
        
        AxisAlignedBox3 GetSceneBbox() const;

        bool GetViewPoint(Vector3 &viewPoint) const;

        bool ViewPointValid(const Vector3 &viewPoint) const;

protected:
        /** DEPRECATED
        */
        int MergeViewCells(const VssRayContainer &rays) const;

        /** Returns true if front and back leaf should be merged.
        */
        bool ShouldMerge(BspLeaf *front, BspLeaf *back) const;

        void CollectViewCells();

        /** Returns maximal depth difference of view cell 
                leaves in tree.
        */
        int GetMaxTreeDiff(ViewCell *vc) const;
        

        void ExportColor(Exporter *exporter, ViewCell *vc) const;
        void ExportVcGeometry(Exporter *exporter, ViewCell *vc) const;


        /// the view space partition BSP tree.
        VspBspTree *mVspBspTree;

private:

        /** Exports visualization of the BSP splits.
        */
        void ExportSplits(const ObjectContainer &objects, 
                                          const VssRayContainer &rays);

        /** Exports visualization of the BSP PVS.
        */
        void ExportBspPvs(const ObjectContainer &objects,
                                          const VssRayContainer &rays);

};

#endif