source: GTP/trunk/Lib/Vis/Preprocessing/src/RssPreprocessor.h @ 1737

#ifndef _RssPreprocessor_H__
#define _RssPreprocessor_H__

#include <fstream>
using namespace std;

#include "Preprocessor.h"
#include "VssRay.h"

namespace GtpVisibilityPreprocessor {


class RssTree;
class RssTreeLeaf;

  class SamplingDistribution {
  public:
        SamplingDistribution() {}
        SamplingDistribution(const int t):mType(t) {}
        int mType;
        int mRays;
        float mContribution;
        float mTime;
  };
  
/** Sampling based visibility preprocessing. The implementation is 
        based on heuristical sampling of view space 
*/
class RssPreprocessor : public Preprocessor {
  
public:
  vector<SamplingDistribution> mDistributions;
  int mSamplesPerPass;
  int mRssSamplesPerPass;
  int mInitialSamples;
  int mRssSamples;
  bool mUseImportanceSampling;

  bool mExportPvs;
  bool mExportRssTree;
  bool mExportRays;
  int mExportNumRays;

  bool mUseViewcells;
  bool mUpdateSubdivision;

  bool mObjectBasedSampling;
  bool mDirectionalSampling;
  
  //AxisAlignedBox3 *mViewSpaceBox;

  
  ofstream mStats;
  RssTree *mRssTree;

  // rays cast during the processing
  VssRayContainer mVssRays;
        
   /// if initial samples should be loaded from file
  bool mLoadInitialSamples;
  /// if initial samples should be stored in file
  bool mStoreInitialSamples;

  RssPreprocessor();
  ~RssPreprocessor();

  virtual bool ComputeVisibility();

#if 0 // matt:: moved up into preprocessor
  int
  CastRay(
                  Vector3 &viewPoint,
                  Vector3 &direction,
                  const float probability,
                  VssRayContainer &vssRays
                  );
#endif          
  virtual bool BuildBspTree() { return false; }
  

  bool
  ExportRays(const char *filename,
                         const VssRayContainer &vssRays,
                         const int number
                         );

  bool
  ExportRayAnimation(const char *filename,
                                         const vector<VssRayContainer> &vssRays
                                         );

  void
  ExportObjectRays(VssRayContainer &rays,
                                   const int objectId);
        
  int
  GenerateImportanceRays(RssTree *vssTree,
                                                 const int desiredSamples,
                                                 SimpleRayContainer &rays
                                                 );


  bool
  ExportRssTreeLeaf(char *filename,
                                        RssTree *tree,
                                        RssTreeLeaf *leaf);

  void
  ExportRssTreeLeaves(RssTree *tree, const int number);
        

  bool
  ExportRssTree(char *filename,
                                RssTree *tree,
                                const Vector3 &dir
                                );


  float
  GetAvgPvsSize(RssTree *tree,
                                const vector<AxisAlignedBox3> &viewcells
                                );
  

  void
  ExportPvs(char *filename,
                        RssTree *rssTree
                        );


  void
  ComputeRenderError();

  /** Redefininition of the get sample rays method from the preprocessor */
  bool
  GenerateRays(
                           const int number,
                           const int sampleType,
                           SimpleRayContainer &rays
                           );

};


};

#endif