source: GTP/trunk/Lib/Vis/Preprocessing/src/Mutation.h @ 1997

#ifndef _Mutation_H__
#define _Mutation_H__

#include <vector>
using namespace std;

#include "common.h"
#include "Halton.h"

namespace GtpVisibilityPreprocessor {

class Vector2;
class Vector3;
class VssRay;
class Preprocessor;
struct SimpleRay;
class SimpleRayContainer;

struct VssRayContainer;

class MutationBasedDistribution: public SamplingStrategy
{
public:
  MutationBasedDistribution(Preprocessor &preprocessor);
  virtual void Update(VssRayContainer &vssRays);

  virtual bool RequiresRays() { return true; }

private:
  virtual bool GenerateSample(SimpleRay &ray);

  bool
  GenerateMutation(const int index, SimpleRay &ray);
  bool
  GenerateSilhouetteMutation(const int index, SimpleRay &ray);

  bool
  GenerateMutationCandidate(const int index,
                                                        SimpleRay &ray,
                                                        Intersectable *object,
                                                        const AxisAlignedBox3 &box
                                                        );


  
  struct RayEntry {
        // halton sequence for generatin gmutations of this ray
        VssRay *mRay;
        int mMutations;
        int mUnsuccessfulMutations;
        HaltonSequence mHalton;
        float mImportance;
        float mCdf;

        float GetSamplingFactor() const { return mMutations/mImportance; }
        RayEntry() {}
        RayEntry(VssRay *r):mRay(r),
                                                mMutations(0),
                                                mUnsuccessfulMutations(0),
                                                mHalton(),
                                                mImportance(1.0f) {}
  };


  Vector3
  ComputeOriginMutation(const VssRay &ray,
                                                const Vector3 &U,
                                                const Vector3 &V,
                                                const Vector2 vr2,
                                                const float radius
                                                );

  Vector3
  ComputeTerminationMutation(const VssRay &ray,
                                                         const Vector3 &U,
                                                         const Vector3 &V,
                                                         const Vector2 vr2,
                                                         const float radius
                                                         );


  Vector3
  ComputeSilhouetteTerminationMutation(const VssRay &ray,
                                                                           const Vector3 &origin,
                                                                           const AxisAlignedBox3 &box,
                                                                           const Vector3 &U,
                                                                           const Vector3 &V,
                                                                           const Vector2 vr2,
                                                                           const float radius
                                                                           );

  RayEntry &GetEntry(const int index) {
        return mRays[(mBufferStart+index)%mRays.size()];
  }
  
  vector<RayEntry> mRays;
  int mMaxRays;
  float mOriginMutationSize;
  int mBufferStart;
  int mLastIndex;
};


}

#endif