source: GTP/trunk/Lib/Vis/Preprocessing/src/SamplingStrategy.h @ 1883

#ifndef _SamplingStategy_H__
#define _SamplingStategy_H__

#include <vector>
using namespace std;

#include "Halton.h"

namespace GtpVisibilityPreprocessor {


class Preprocessor;
struct SimpleRay;
class SimpleRayContainer;
class VssRayContainer;

/** This class generates a specific sampling strategy.
*/
class SamplingStrategy
{
public:

        /** Sample rays of particular type
        */
        enum 
        {
          DUMMY_DISTRIBUTION = 0,
          DIRECTION_BASED_DISTRIBUTION,
                OBJECT_BASED_DISTRIBUTION,
                DIRECTION_BOX_BASED_DISTRIBUTION,
                SPATIAL_BOX_BASED_DISTRIBUTION,
                VSS_BASED_DISTRIBUTION,
                RSS_BASED_DISTRIBUTION,
                RSS_SILHOUETTE_BASED_DISTRIBUTION,
                OBJECT_DIRECTION_BASED_DISTRIBUTION,
                OBJECTS_INTERIOR_DISTRIBUTION,
                REVERSE_OBJECT_BASED_DISTRIBUTION,
                VIEWCELL_BORDER_BASED_DISTRIBUTION,
                VIEWSPACE_BORDER_BASED_DISTRIBUTION,
                REVERSE_VIEWSPACE_BORDER_BASED_DISTRIBUTION,
          GLOBAL_LINES_DISTRIBUTION,
          GVS
        };

        /** Default constructor
        */
        SamplingStrategy(const Preprocessor &preprocessor);

        virtual ~SamplingStrategy();

        /** Each strategy has to implement this function.
        @returns true if generated valid sample.
        */

        virtual int GenerateSamples(const int number, SimpleRayContainer &rays);

private:

        virtual bool GenerateSample(SimpleRay &ray) = 0;

public:
        /// variables usefull for mixed distribution sampling
        int mType;
        int mRays;
        float mContribution;
        float mTime;
        float mRatio;

  int mTotalRays;
  float mTotalContribution;
protected:

        const Preprocessor &mPreprocessor;

};


class ObjectBasedDistribution: public SamplingStrategy
{
 public:
  HaltonSequence mHalton;
  
  ObjectBasedDistribution(const Preprocessor &preprocessor):
        SamplingStrategy(preprocessor) {
        mType = OBJECT_BASED_DISTRIBUTION;
  }

private:
  virtual bool GenerateSample(SimpleRay &ray);
};


class ReverseObjectBasedDistribution: public SamplingStrategy
{
 public:
        
         ReverseObjectBasedDistribution(const Preprocessor &preprocessor):
           SamplingStrategy(preprocessor) {
           mType = REVERSE_OBJECT_BASED_DISTRIBUTION;
         }

private:
  virtual bool GenerateSample(SimpleRay &ray);
};


class ObjectDirectionBasedDistribution: public SamplingStrategy
{
  HaltonSequence mHalton;
  
public:
         ObjectDirectionBasedDistribution(const Preprocessor &preprocessor):
         SamplingStrategy(preprocessor) {
           mType = OBJECT_DIRECTION_BASED_DISTRIBUTION;
         }
private:
        virtual bool GenerateSample(SimpleRay &ray);
};


class DirectionBasedDistribution: public SamplingStrategy
{
 public:
  DirectionBasedDistribution(const Preprocessor &preprocessor):
        SamplingStrategy(preprocessor){
        mType = DIRECTION_BASED_DISTRIBUTION;
  }
private:
  virtual bool GenerateSample(SimpleRay &ray);
};


class DirectionBoxBasedDistribution: public SamplingStrategy
{
 public:
         DirectionBoxBasedDistribution(const Preprocessor &preprocessor):
           SamplingStrategy(preprocessor){
           mType = DIRECTION_BOX_BASED_DISTRIBUTION;
         }
           
private:
           virtual bool GenerateSample(SimpleRay &ray);
};


class SpatialBoxBasedDistribution: public SamplingStrategy
{
 public:
  HaltonSequence mHalton;
  SpatialBoxBasedDistribution(const Preprocessor &preprocessor):
        SamplingStrategy(preprocessor){
        mType = DIRECTION_BOX_BASED_DISTRIBUTION;
  }
  
private:
           virtual bool GenerateSample(SimpleRay &ray);
};


class ViewSpaceBorderBasedDistribution: public SamplingStrategy
{
 public:
         ViewSpaceBorderBasedDistribution(const Preprocessor &preprocessor):
           SamplingStrategy(preprocessor){
           mType = SPATIAL_BOX_BASED_DISTRIBUTION;
         }
         
private:
         virtual bool GenerateSample(SimpleRay &ray);
};


class ReverseViewSpaceBorderBasedDistribution: public SamplingStrategy
{
 public:
         ReverseViewSpaceBorderBasedDistribution(const Preprocessor &preprocessor):
           SamplingStrategy(preprocessor){
           mType = SPATIAL_BOX_BASED_DISTRIBUTION;
         }
         
private:
         virtual bool GenerateSample(SimpleRay &ray);
};


class RssBasedDistribution: public SamplingStrategy
{
 public:
  RssBasedDistribution(const Preprocessor &preprocessor):
        SamplingStrategy(preprocessor){
        mType = RSS_BASED_DISTRIBUTION;
  }


  virtual int GenerateSamples(const int number, SimpleRayContainer &ray) {
        // TBD!!!
        return 0;
  }

private:
  virtual bool GenerateSample(SimpleRay &ray);
  
};


class ViewCellBorderBasedDistribution: public SamplingStrategy
{
 public:
  ViewCellBorderBasedDistribution(const Preprocessor &preprocessor):
        SamplingStrategy(preprocessor) {}
  
  virtual bool GenerateSample(SimpleRay &ray);
};

class GlobalLinesDistribution: public SamplingStrategy
{
public:
  //Halton<4> halton;
  HaltonSequence mHalton;

  GlobalLinesDistribution(const Preprocessor &preprocessor):
        SamplingStrategy(preprocessor) {
        mType = GLOBAL_LINES_DISTRIBUTION;
  }
  
  virtual bool GenerateSample(SimpleRay &ray);
};


/** This strategy generates samples inside of the objects, e.g.,
        for sampling the inside of a colon.
*/
/*class ObjectsInteriorDistribution: public SamplingStrategy
{
 public:
         ObjectsInteriorDistribution(const Preprocessor &preprocessor):
         SamplingStrategy(preprocessor) {}
         
         virtual bool GenerateSample(SimpleRay &ray);
};
*/

class MixtureDistribution : public SamplingStrategy {
public:
  // halton sequence generator for deciding between distributions
  HaltonSequence mHalton;
  
  // container for the distributions
  vector<SamplingStrategy *> mDistributions;

  MixtureDistribution(const Preprocessor &preprocessor):
        SamplingStrategy(preprocessor)
  {
  }

  // has to called before first usage
  void Init();
  
  // Generate a new sample according to a mixture distribution
  virtual bool GenerateSample(SimpleRay &ray);

  // add contributions of the sample to the strategies
  void UpdateContributions(VssRayContainer &vssRays);
  
protected:
  // distributions sorted according to their contribution
  // used for new sample generation accordint to the pdf
  vector<SamplingStrategy *> mSortedDistributions;
  
};

};

#endif