source: trunk/VUT/GtpVisibilityPreprocessor/src/ViewCell.h @ 547

#ifndef _ViewCell_H__
#define _ViewCell_H__

#include "Mesh.h"
#include "Containers.h"
#include "Ray.h"
#include "Statistics.h"
//namespace GtpVisibilityPreprocessor {

struct Triangle3;

class BspInterior;
class BspPvs;
class BspLeaf;
class VspKdTree;
class VspKdLeaf;
class KdLeaf;

/** Statistics for a view cell partition.
*/

class ViewCellsStatistics: public StatisticsBase
{
public:

        /// number of view cells
        int viewCells;

        /// size of the PVS
        int pvs;

        /// largest PVS of all view cells
        int maxPvs;

        /// smallest PVS of all view cells
        int minPvs;

        /// view cells with empty PVS
        int emptyPvs;

        /// number of leaves covering the view space
        int leaves;

        /// largest number of leaves covered by one view cell
        int maxLeaves;

    // Constructor
        ViewCellsStatistics()
        {
                Reset();
        }

        double AvgLeaves() const {return (double)leaves / (double)viewCells;};
        double AvgPvs() const {return (double)pvs / (double)viewCells;};

        void Reset()
        {
                viewCells = 0;
                pvs = 0;
                maxPvs = 0;

                minPvs = 999999;
                emptyPvs = 0;
                leaves = 0;
                maxLeaves = 0;
        }

        void Print(ostream &app) const;

        friend ostream &operator<<(ostream &s, const ViewCellsStatistics &stat)
        {
                stat.Print(s);
                return s;
        }
};

/**
        View cell with an optional mesh representation
*/
class ViewCell: public MeshInstance
{
public:
        ViewCell();

        /** Constructor taking a mesh representing the shape of the viewcell.
        */
        ViewCell(Mesh *mesh);

        /** Default destructor.
        */
        virtual ~ViewCell() {}
        /** Returns Pvs.
        */
        const ObjectPvs &GetPvs() const;
        ObjectPvs &GetPvs();

        int Type() const;

        /** Adds a passing ray to the passing ray container.
        */
        void AddPassingRay(const Ray &ray, const int contributions);

        /** Returns volume of the view cell.
        */
        float GetVolume() const;

        /** Returns area of the view cell.
        */
        float GetArea() const;

        /** Sets the volume of the view cell.
        */
        void SetVolume(float volume);
        
        /** Sets the area of the view cell.
        */
        void SetArea(float area);

        /** Updates the view cell statstics for this particular view cell.
        */
        virtual void UpdateViewCellsStats(ViewCellsStatistics &vcStat);

        /// Ray set description of the rays passing through this node.
        PassingRaySet mPassingRays;

        /// Rays piercing this view cell.
        RayContainer mPiercingRays;

        /** Sets the mesh for this view cell.
        */
        void SetMesh(Mesh *mesh);

        void SetValid(const bool valid);
        bool GetValid() const;

protected:

        /// the potentially visible objects
        ObjectPvs mPvs;

        float mVolume;
        float mArea;


        bool mValid;
};

/**
        View cell belonging to a hierarchy.
*/
template<typename T>
class HierarchyViewCell: public ViewCell
{
public:
        HierarchyViewCell<T>(): mLeaves(0) {}
        HierarchyViewCell<T>(Mesh *mesh):
                ViewCell(mesh), mLeaves(0) {}

        void UpdateViewCellsStats(ViewCellsStatistics &vcStat)
        {
                ViewCell::UpdateViewCellsStats(vcStat);

                if ((int)mLeaves.size() > vcStat.maxLeaves)
                        vcStat.maxLeaves = (int)mLeaves.size();
                vcStat.leaves += (int)mLeaves.size();
        }

        /// Leaves of the hierarchy which are part of this view cell.
        std::vector<T> mLeaves;
};


typedef HierarchyViewCell<BspLeaf *> BspViewCell;
typedef HierarchyViewCell<KdLeaf *> KdViewCell;
typedef HierarchyViewCell<VspKdLeaf *> VspKdViewCell;


#endif