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

#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;
        short mMutations;
        short mUnsuccessfulMutations;
        HaltonSequence mHalton;
        float mImportance;
        float mCdf;

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

        void ResetReverseMutation() {
          mutatedOrigin = mutatedTermination = Vector3(0,0,0);
        }
        bool HasReverseMutation() const {
          return !(mutatedOrigin == mutatedTermination);
        }
        
        void SetReverseMutation(const Vector3 &a, const Vector3 &b) {
          mutatedOrigin = a;
          mutatedTermination = b;
        }

  };
  

  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
                                                                           );


  bool
  ComputeReverseMutation(
                                                 const VssRay &oldRay,
                                                 const VssRay &newRay,
                                                 Vector3 &origin,
                                                 Vector3 &termination
                                                 );

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


}

#endif