source: trunk/VUT/GtpVisibilityPreprocessor/src/MutualVisibility.h @ 191

#ifndef __MUTUAL_VISIBILITY_H
#define __MUTUAL_VISIBILITY_H

#include "Vector3.h"
#include "Ray.h"
#include "Triangle3.h"

class Intersectable;
class AxisAlignedBox3;




struct SimpleRay {
  Vector3 mOrigin;
  Vector3 mDirection;
};


struct TriangleSample {
public:
  /// evaluted sampling error
  float mError;
  /// depth in recursion
  int mDepth;
  /// The source triangle
  Triangle3 mSource;
  /// The target triangle
  Triangle3 mTarget;
  
  /// intersections with the scene
  vector<Ray::Intersection> mIntersections[9];
  
  void ComputeError();
  
  TriangleSample () {}
  
  TriangleSample (
                  const Triangle3 &source,
                  const Triangle3 &target)
  {
    Init(source, target);
  }

  // initial triangle sample
  void Init(
            const Triangle3 &source,
            const Triangle3 &target);
  
  Vector3
  GetIntersectionPoint(const int rayIndex,
                       const int depth) const;

  void GetRay(const int rayIndex,
              Vector3 &origin,
              Vector3 &direction) const;

};

enum { VISIBLE, INVISIBLE };

  
class MutualVisibilitySampler {
public:
  KdTree *mKdTree;
  AxisAlignedBox3 mSource;
  AxisAlignedBox3 mTarget;
  float mSolidAngleThreshold;


  MutualVisibilitySampler(KdTree *kdTree,
                          AxisAlignedBox3 &source,
                          AxisAlignedBox3 &target,
                          const float solidAngleThreshold);
  int
  ComputeVisibility();

  void
  ConstructInitialSamples(
                          const AxisAlignedBox3 &source,
                          const AxisAlignedBox3 &target,
                          vector<TriangleSample *> &samples
                          );

  void
  AddInitialSamples(
                    const Rectangle3 &sourceRect,
                    const Rectangle3 &targetRect,
                    vector<TriangleSample *> &samples
                    );

  // the split sample method contains a methodology to create new samples
  // or terminate the sampling
  bool
  SplitSample(
              const TriangleSample &source,
              TriangleSample &sample1,
              TriangleSample &sample2
              );
  void
  PerformSplit(
               const TriangleSample &sample,
               const bool splitSource,
               const int edge,
               const Vector3 &splitPoint,
               const Ray &ray,
               TriangleSample &sample1,
               TriangleSample &sample2
               );
  

  bool
  SampleTerminationCriteriaMet(
                               const TriangleSample &sample);
  
  float
  GetSpatialAngle(const TriangleSample &sample,
                  const Vector3 &point
                  );

  void
  ComputeError(TriangleSample &sample);


};
  
int
ComputeBoxVisibility(KdTree *kdTree,
                     AxisAlignedBox3 &source,
                     AxisAlignedBox3 &target,
                     float solidAngleThreshold);






#endif