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

#ifndef _ViewCellsManager_H__
#define _ViewCellsManager_H__

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

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

/**
        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,
                                                  AxisAlignedBox3 *sceneBbox = NULL) = 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 = 0;

        /** 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) = 0;

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

protected:
        

        /** Initialises the render time simulator.
        */
        void InitRenderSimulator();
        /////////////////////

        
        /// the view cell corresponding to unbounded space
        ViewCell *mUnbounded;

        /// Simulates rendering
        RenderSimulator *mRenderSimulator;

        /// 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;
};



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

public:

        BspViewCellsManager(BspTree *tree, int constructionSamples);

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


        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;

        ~BspViewCellsManager();

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

protected:

        /** 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;

        /// the BSP tree.
        BspTree *mBspTree;


private:


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

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

};

/**
        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,
                                  AxisAlignedBox3 *sceneBbox);

  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.
        */
        virtual void PrintStatistics(ostream &s) const;

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

protected:

         KdNode *GetNodeForPvs(KdLeaf *leaf);


         /// 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);

        ~VspKdViewCellsManager();

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


        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);

protected:

        /// 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,
                                  AxisAlignedBox3 *sceneBbox);


        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);


protected:

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

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

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


private:


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

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

};

#endif