ssChordIntersector.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2005 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/
/******************************************************************************
** $RCSfile: ssChordIntersector.h,v $ $Revision: 1.6 $ $State: Exp $
******************************************************************************/
#ifndef ssChordIntersector_H_
#define ssChordIntersector_H_

#include <vlutil/vlConfig.h> 
#include <vlutil/vlPrint.h>

#include "geometry/spatialSubdivision.h"
#include "geometry/ssFunctor.h"
#include "geometry/ssExtentIntersector.h"

#include "geometry/chord.h"
#include "geometry/point.h"
#include "geometry/plane.h"
#include "geometry/tdbextent.h"


// Note:  Must use this macro to get around issues with VC 6.0 vs .Net/gcc.
// 6.0 complains if you use the typename qualifier outside of a class definition,
// but it is incorrect to not specify that the cell type is a type when using it
// as a template parameter.
#ifdef DtSPATIAL_SUB_CELL_TYPE
#undef DtSPATIAL_SUB_CELL_TYPE
#endif

#if _MSC_VER == 1200 // Visual Studio 6.0
#define DtSPATIAL_SUB_CELL_TYPE DtSpatialSubdivision< T >::DtSpatialSubCellType 
#else
#define DtSPATIAL_SUB_CELL_TYPE typename DtSpatialSubdivision< T >::DtSpatialSubCellType 
#endif



//
// The DtSsChordIntersector is *solely* responsible for intersecting a DtChord and a 
// DtSpatialSubdivision together.  It does not know what to do with the intersection
// results, nor does it rely on the specific contents of the spatial subdivision.
//
// This is one of the basic SS intersection classes provided by the toolkit.
//
template <typename T>
class DtSsChordIntersector
{
public:

   // Constructor
   DtSsChordIntersector();

   // Destructor
   virtual ~DtSsChordIntersector();

   // Intersects the specified chord and spatial subdivision together.
   // @returns A boolean indicating whether or not the chord intersected the
   // spatial subdivision at all.  
   // @note Technically, this returns true if the chord's @b extent intersects 
   // the spatial subdivision at all.  It does not do a true mathematical 
   // intersection of the chord and the SS.
   virtual bool intersect(const DtChord& chord, DtSpatialSubdivision< T >& spatialSubdivision) const;

   // Intersects the specified chord and spatial subdivision together.  Applies
   // the functor to the intersection results, in order, until the functor 
   // is done processing (returns true).
   // 
   // @returns A boolean indicating whether or not the chord intersected the
   // spatial subdivision or not. Has nothing to do with the functor's success
   // or failure in its own processing.
   // 
   // @note Unlike the above intersection function, this function only returns 
   // true if the chord intersected the SS, not just the chord's extent.  And the
   // functor is applied to the cells in the SS in the order that the chord intersects
   // them.
   //
   virtual bool intersect(const DtChord& chord, 
      DtSpatialSubdivision< T >& spatialSubdivision,
      DtSsFunctor<const DtChord, DtSPATIAL_SUB_CELL_TYPE >& functor) const;

protected:

   // Trims the specified chord to the spatial subdivision.  
   bool trimChordToSubdivision(const DtChord& chord, 
                               const DtSpatialSubdivision<T>& spatialSubdivision,
                               int xIndexStart, int yIndexStart, int zIndexStart, 
                               int xIndexEnd, int yIndexEnd, int zIndexEnd, 
                               double& tMin, double& tMax) const;

   // A utility function used when trimming the chord to the spatial subdivision.
   // Given the specified chord, the specified starting/ending indices - in a single
   // dimension, the min and max planes in that dimension, and the actual starting
   // and ending indices, it computes the minimum and maximum time along the chord
   // in the specified dimension (basically when along the chord it intersects 
   // the min and max planes.
   // 
   // @returns a boolean indicating whether or not any part of the chord is inside
   // the specified planes.  If the chord lies before the minPlane or after the maxPlane,
   // then the function returns false.
   bool trimChordInSingleDimension(const DtChord& chord,
      int minIndex, int maxIndex, DtPlane& minPlane, DtPlane& maxPlane, 
      int indexStart, int indexEnd, double& tMin, double& tMax) const;

   // Performs a recursive intersection of the chord with the spatial subdivision,
   // starting in the specified cell.  Intersects the chord with the initial cell,
   // and then, if the functor is not done processing, creates a new chord from the
   // intersection point of the chord and the cell wall, and the endpoint of the 
   // chord, and continues traversing/intersecting with that chord until no more
   // of the chord lies in the spatial subdivision or is entirely contained within
   // a single cell.
   // 
   //@returns A boolean indicating whether or not the intersection succeeded or not.
   bool intersectStartingIn(const DtChord& chord, 
      DtSpatialSubdivision< T >& spatialSubdivision, 
      int xIndexStart, int yIndexStart, int zIndexStart, 
      int xIndexEnd, int yIndexEnd, int zIndexEnd, 
      DtSsFunctor<const DtChord, DtSPATIAL_SUB_CELL_TYPE >& functor) const;

   // A utility function used in determining chord traversal in the x, y, z dimensions.
   // If the start is greater than the end, then we are traversing backwards in 
   // the dimension. If the start is less than the end, then we are traversing 
   // forwards in the dimension.  
   // Specifically if the
   //    start < end, then direction = 1
   //    start > end, then direction = -1
   //    start == end, then direction = 0
   int getRelativeDirection(int start, int end) const;

   // A utility function used in determining chord traversal.  This function
   // determines the nearest time along the chord until it intersects a cell wall
   // in the spatial subdivision, given the starting indices and the directions
   // of traversal in the different dimensions.  
   void determineDirectionOfTraversal(const DtChord& chord, 
                                      DtSpatialSubdivision<T>& spatialSubdivision, 
                                      double& nearestTime, double& cellTime, int* offsetToNext, 
                                      int xDir, int yDir, int zDir, 
                                      int xIndexStart, int yIndexStart, int zIndexStart) const;

private:
   // Copy constructor & Assignment operator  - not implemented
   DtSsChordIntersector(const DtSsChordIntersector& orig);
   DtSsChordIntersector& operator=(const DtSsChordIntersector& orig);

};

#define SSCHORDINTERSECTOR_HEADER
#include "geometry/ssChordIntersector.inl"
#undef SSCHORDINTERSECTOR_HEADER

#ifdef DtSPATIAL_SUB_CELL_TYPE
#undef DtSPATIAL_SUB_CELL_TYPE
#endif

#endif