In This Package:

RectangularBox.cc

Go to the documentation of this file.

#include "RectangularBox.h"

using namespace HepGeom;

RectangularBox::RectangularBox(double xUp, double xLow,
                               double yUp, double yLow,
                               double zUp, double zLow)
{ 
  m_xUp  = xUp;
  m_xLow = xLow;
  m_yUp  = yUp;
  m_yLow = yLow;
  m_zUp  = zUp;
  m_zLow = zLow;
}


RectangularBox::~RectangularBox()
{}

bool RectangularBox::intersect(const Point3D<double> & linePoint, const Normal3D<double> & lineSlope,
                               Point3D<double> & intersectA, Point3D<double> & intersectB)
{
  Point3D<double>  aPoint=linePoint;
  Normal3D<double> aSlope=lineSlope;

  bool foundA;
  bool foundB;

  foundA=foundB=false;

  double x,y,z;

  // top plane
  if(foundA && foundB) return true;

  if( aSlope.z()!=0 ) {
    x=aSlope.x()/aSlope.z()*(m_zUp-aPoint.z()) + aPoint.x();
    y=aSlope.y()/aSlope.z()*(m_zUp-aPoint.z()) + aPoint.y();
  
    if(x>=m_xLow && x<=m_xUp &&
       y>=m_yLow && y<=m_yUp )  {
      if(!foundA) { 
        foundA = true; 
        intersectA.setX(x);
        intersectA.setY(y);
        intersectA.setZ(m_zUp);
      } else {
        if (!foundB) {
          foundB = true;
          intersectB.setX(x);
          intersectB.setY(y);
          intersectB.setZ(m_zUp);
        }
      }
    }
  }
  
  // bottom plane
  if(foundA && foundB) return true;

  if( aSlope.z()!=0 ) {
    x=aSlope.x()/aSlope.z()*(m_zLow-aPoint.z()) + aPoint.x();
    y=aSlope.y()/aSlope.z()*(m_zLow-aPoint.z()) + aPoint.y();
    
    if(x>=m_xLow && x<=m_xUp &&
       y>=m_yLow && y<=m_yUp )  {
      if(!foundA) {
        foundA = true;
        intersectA.setX(x);
        intersectA.setY(y);
        intersectA.setZ(m_zLow);
      } else {
        if (!foundB) {
          foundB = true;
          intersectB.setX(x);
          intersectB.setY(y);
          intersectB.setZ(m_zLow);
        }
      }
    }
  }

  // x positive plane
  if(foundA && foundB) return true;

  if( aSlope.x()!=0 ) {
    z=aSlope.z()/aSlope.x()*(m_xUp-aPoint.x()) + aPoint.z();
    y=aSlope.y()/aSlope.x()*(m_xUp-aPoint.x()) + aPoint.y();

    if(z>=m_zLow && z<=m_zUp &&
       y>=m_yLow && y<=m_yUp )  {
      if(!foundA) {
        foundA = true;
        intersectA.setZ(z);
        intersectA.setY(y);
        intersectA.setX(m_xUp);
      } else {
        if (!foundB) {
          foundB = true;
          intersectB.setZ(z);
          intersectB.setY(y);
          intersectB.setX(m_xUp);
        }
      }
    }
  }

  // x negtive plane
  if(foundA && foundB) return true;

  if( aSlope.x()!=0 ) {
    z=aSlope.z()/aSlope.x()*(m_xLow-aPoint.x()) + aPoint.z();
    y=aSlope.y()/aSlope.x()*(m_xLow-aPoint.x()) + aPoint.y();

    if(z>=m_zLow && z<=m_zUp &&
       y>=m_yLow && y<=m_yUp )  {
      if(!foundA) {
        foundA = true;
        intersectA.setZ(z);
        intersectA.setY(y);
        intersectA.setX(m_xLow);
      } else {
        if (!foundB) {
          foundB = true;
          intersectB.setZ(z);
          intersectB.setY(y);
          intersectB.setX(m_xLow);
        }
      }
    }
  }

  
  // y positive plane
  if(foundA && foundB) return true;

  if( aSlope.y()!=0 ) {
    z=aSlope.z()/aSlope.y()*(m_yUp-aPoint.y()) + aPoint.z();
    x=aSlope.x()/aSlope.y()*(m_yUp-aPoint.y()) + aPoint.x();

    if(z>=m_zLow && z<=m_zUp &&
       x>=m_xLow && x<=m_xUp )  {
      if(!foundA) {
        foundA = true;
        intersectA.setZ(z);
        intersectA.setX(x);
        intersectA.setY(m_yUp);
      } else {
        if (!foundB) {
          foundB = true;
          intersectB.setZ(z);
          intersectB.setX(x);
          intersectB.setY(m_yUp);
        }
      }
    }
  }

  // y negtive plane
  if(foundA && foundB) return true;

  if( aSlope.y()!=0 ) {
    z=aSlope.z()/aSlope.y()*(m_yLow-aPoint.y()) + aPoint.z();
    x=aSlope.x()/aSlope.y()*(m_yLow-aPoint.y()) + aPoint.x();

    if(z>=m_zLow && z<=m_zUp &&
       x>=m_xLow && x<=m_xUp )  {
      if(!foundA) {
        foundA = true;
        intersectA.setZ(z);
        intersectA.setX(x);
        intersectA.setY(m_yLow);
      } else {
        if (!foundB) {
          foundB = true;
          intersectB.setZ(z);
          intersectB.setX(x);
          intersectB.setY(m_yLow);
        }
      }
    }
  }

  return foundA && foundB;
}


std::ostream & operator<<(std::ostream & os, const RectangularBox & p)
{
  os<<"xUp="<<p.xUp()<<" "<<"xLow="<<p.xLow()<<" "
    <<"yUp="<<p.yUp()<<" "<<"yLow="<<p.yLow()<<" "
    <<"zUp="<<p.zUp()<<" "<<"zLow="<<p.zLow();

  return os;
}

---