source: trunk/VUT/GtpVisibility/include/VisibilityInfo.h @ 316

#ifndef _VisibilityInfo_H__
#define _VisibilityInfo_H__

#include <vector>

#include "VisibilityMesh.h"
#include "HierarchyInterface.h"

namespace GtpVisibility {
 
/** Class storing visibility information.
*/
template<typename T>
class VisibilityInfo
{
public:
        VisibilityInfo(T source, const int visiblePixels, const int projectedPixels);

        /** set source of the info. 
        */
        void SetSource(T source);
        /** get source of the info. 
        */
        T GetSource() const;

        int GetVisiblePixels() const;
        int GetProjectedPixels() const;

        void SetVisiblePixels(int vis);
        void SetProjectedPixels(int vis);
        
        /** Computes ratio of visible to projected pixels. */
        float ComputeRelativeVisibility();

        /** Adds visibility to current visibility information.
        */
        void AddVisibility(const VisibilityInfo<T> &info);
        /** Adds visibility to current visibility information.
        */
        void AddVisibility(const int visiblePixels, const int projectedPixels);

protected:
        /** number of visible pixels. 
        */
    int mVisiblePixels;
        /** number of projected pixels 
        */
        int mProjectedPixels;

        T mSource;
};

//-----------------------------------------------------------------------
template <typename T>
T VisibilityInfo<T>::GetSource() const
{
        return mSource;
}

//-----------------------------------------------------------------------
template <typename T>
void VisibilityInfo<T>::SetSource(T source)
{
        return mSource;
}

//-----------------------------------------------------------------------
template <typename T>
VisibilityInfo<T>::VisibilityInfo(T source, const int visiblePixels, const int projectedPixels): 
mSource(source), mProjectedPixels(projectedPixels), mVisiblePixels(visiblePixels) 
{
}

//-----------------------------------------------------------------------
template <typename T>
int VisibilityInfo<T>::GetVisiblePixels() const 
{
        return mVisiblePixels;
}
//-----------------------------------------------------------------------
template <typename T>
int VisibilityInfo<T>::GetProjectedPixels() const 
{
        return mProjectedPixels;
}
//-----------------------------------------------------------------------
template <typename T>
void VisibilityInfo<T>::SetVisiblePixels(int vis) 
{
        mVisiblePixels = vis;
}
//-----------------------------------------------------------------------
template <typename T>
void VisibilityInfo<T>::SetProjectedPixels(int vis) 
{
        mProjectedPixels = vis;
}
//-----------------------------------------------------------------------
template <typename T>
float VisibilityInfo<T>::ComputeRelativeVisibility() 
{ 
        if (!mProjectedPixels) 
                return 0;

        return (float)mVisiblePixels / (float)mProjectedPixels; 
}
//-----------------------------------------------------------------------
template <typename T>
void VisibilityInfo<T>::AddVisibility(const VisibilityInfo<T> &info)
{
        mVisiblePixels += info.GetVisiblePixels();
        mProjectedPixels += info.GetProjectedPixels();
}

//-----------------------------------------------------------------------
template <typename T>
void VisibilityInfo<T>::AddVisibility(const int visiblePixels, const int projectedPixels)
{
        mVisiblePixels += visiblePixels;
        mProjectedPixels += projectedPixels;
}

typedef VisibilityInfo<Patch *> PatchInfo;
typedef VisibilityInfo<Mesh *> MeshInfo;
typedef VisibilityInfo<HierarchyNode *> NodeInfo;


template<class T>
struct InfoContainer
{
        typedef std::vector<VisibilityInfo<T> > Type;
};

typedef std::vector<PatchInfo> PatchInfoContainer;
typedef std::vector<MeshInfo> MeshInfoContainer;
typedef std::vector<NodeInfo> NodeInfoContainer;

} // namespace GtpVisibility

#endif