source: trunk/VUT/GtpVisibilityPreprocessor/src/Beam.cpp @ 534

#include "VssRay.h"
#include "Beam.h"



void
Beam::Construct(const  AxisAlignedBox3 &box, const  AxisAlignedBox3 &dBox)
{
  // the frustum is defined by set of negative halfspace described by mPlanes
  
  // construct
  Vector3 center = box.Center();
  Vector3 dCenter = dBox.Center();

  // "back plane"
  mPlanes.push_back(Plane3(-VssRay::GetDirection(dCenter.x, dCenter.y), center));
  
  Vector3 directions[4];
  directions[0] = VssRay::GetDirection(dBox.Min().x, dBox.Min().y);
  directions[1] = VssRay::GetDirection(dBox.Max().x, dBox.Min().y);
  directions[2] = VssRay::GetDirection(dBox.Max().x, dBox.Max().y);
  directions[3] = VssRay::GetDirection(dBox.Min().x, dBox.Max().y);
  
  // side planes
  mPlanes.push_back(Plane3(-CrossProd(directions[0], directions[1]), center));
  mPlanes.push_back(Plane3(-CrossProd(directions[1], directions[2]), center));
  mPlanes.push_back(Plane3(-CrossProd(directions[2], directions[3]), center));
  mPlanes.push_back(Plane3(-CrossProd(directions[3], directions[0]), center));


  // now make sure all planes contain the spatial box
  int i, j;
  for (i=0; i < mPlanes.size(); i++) {
        for (j=0; j < 8; j++) {
          float dist = mPlanes[i].Distance(box.GetVertex(j));
          if (dist > 0)
                mPlanes[i].mD -= dist;
        }
  }

  mBox = box;
  mDirBox = dBox;
  
  SetValid();
}

// conservative frustum box intersection
// returns
// 0 - box intersects the frustum
// -1 - box intersects the frustum and is fully inside
// 1 - box does not intersect the frustum

int
Beam::ComputeIntersection(const AxisAlignedBox3 &box)
{
  int i;
  int result = -1;
  for (i=0; i < mPlanes.size(); i++) {
        int side = box.Side(mPlanes[i]);
        if (side == 1)
          return 1;
        if (side > result)
          result = side;
  }
  return result;
}


void Beam::ComputeFrustum(float &left, float &right,
                                                  float &bottom, float &top,
                                                  float &near, float &far,
                                                  const AxisAlignedBox3 &sceneBBox) const
{
        const float xDirRange = mDirBox.Max().x - mDirBox.Min().x;
        const float yDirRange = mDirBox.Max().y - mDirBox.Min().y;

        near = 0.1f; // NOTE: what is the best value for near and far plane?
        far = 2.0f * Magnitude(sceneBBox.Diagonal());

        left = near / tan(xDirRange * 0.5f);
        right = near / tan(xDirRange * 0.5f);

        bottom = near / tan(yDirRange * 0.5f);
        top = near / tan(yDirRange * 0.5f);
}

Vector3 Beam::GetMainDirection() const
{
         Vector3 directions[4];
         
         directions[0] = VssRay::GetDirection(mDirBox.Min().x, mDirBox.Min().y);
         directions[1] = VssRay::GetDirection(mDirBox.Max().x, mDirBox.Min().y);
         directions[2] = VssRay::GetDirection(mDirBox.Max().x, mDirBox.Max().y);
         directions[3] = VssRay::GetDirection(mDirBox.Min().x, mDirBox.Max().y);

        const Vector3 mainDir = directions[0] + directions[1] + directions[2] + directions[3];
        return Normalize(mainDir);
}


void BeamSampleStatistics::Print(ostream &app) const
{
  app << "===== Beam sample statistics ===============\n";

  app << "#N_PVSSIZE ( size of pvs )\n" << pvsSize << "\n";

  app << "#N_RAYS ( Number of rays )\n" << rays << "\n";

  app << "#N_RAYCONTRIBUTIONS ( number of ray constributions )\n" <<
    rayContributions << "\n";

  app << "#N_RAYLENGHTENTROPY  ( Ray lenght entropy )\n" <<
    rayLengthEntropy << "\n";

  app << "#N_IMPORTANCE  ( importance )\n" <<
    importance << "\n";

  app << "#N_CTIME  ( Construction time [s] )\n"
      << Time() << " \n";

  app << "===== END OF KdTree statistics ==========\n";

}