ssClosestIntersectionFunctor.h

Go to the documentation of this file.

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

#include <vlutil/vlConfig.h> 
#include "geometry/spatialSubdivision.h"
#include "geometry/ssFunctor.h"

#include "geometry/chordIntersectionRecord.h"
#include "gdb/gdbNode.h"
#include <assert.h>

//
// A functor intended for use with the spatial subdivision set of classes.  It's 
// primary usage is to intersect the first parameter into the second.  Results
// of the intersection are reported in the record type specified in the third
// template parameter.
// 
// Expected usage:
// When passed to the intersection objects intersection functions, this fucntor 
// intersects the first item into the second one.  Used primarily for intersecting the
// different spatial sorted elements into their appropriate spatial subdivisions.
// For an example, see the gdbNode intersecter class.
// 
template <typename TypeToIntersect, typename Container, typename T_IntersectionRecordType>
class DtSsClosestIntersectionFunctor : public DtSsFunctor<TypeToIntersect, Container>
{
public:
   // Constructor
   DtSsClosestIntersectionFunctor();

   // Destructor
   virtual ~DtSsClosestIntersectionFunctor();

private:
   // not implemented
   DtSsClosestIntersectionFunctor(const DtSsClosestIntersectionFunctor& original);   
   DtSsClosestIntersectionFunctor& operator=(const DtSsClosestIntersectionFunctor& original);

public:
   // Function operator - when applied intersects the first element with the
   // second element.
   // @param itemToIntersect The item to intersect into the second parameter.
   // @param container The container of elements into which to intersect the first
   // parameter.
   //
   // @returns Always returns false as it is never done processing - it can
   // always continue intersecting elements.
   virtual bool operator()(TypeToIntersect& itemToIntersect, Container& container);

   virtual T_IntersectionRecordType* intersectionRecord() const;

   virtual void setIntersectionRecord(T_IntersectionRecordType* newIntersectionRecord);

   virtual DtGdbNode::DtIntersectRecordType intersectionRecordType() const;

   virtual void setIntersectionRecordType(
      DtGdbNode::DtIntersectRecordType& newIntersectionRecordType);


private:

   T_IntersectionRecordType*        myIntersectionRecord;
   DtGdbNode::DtIntersectRecordType myIntersectionRecordType;
};


//------------------------------------------------------
//  INLINE METHODS
//------------------------------------------------------
template <typename TypeToIntersect, typename Container, typename T_IntersectionRecordType>
DtSsClosestIntersectionFunctor<TypeToIntersect, Container, T_IntersectionRecordType>::DtSsClosestIntersectionFunctor()
: DtSsFunctor<TypeToIntersect, Container>()
, myIntersectionRecord(0)
, myIntersectionRecordType(DtGdbNode::IRT_IPOINT)
{
}


template <typename TypeToIntersect, typename Container, typename T_IntersectionRecordType>
DtSsClosestIntersectionFunctor<TypeToIntersect, Container, T_IntersectionRecordType>::~DtSsClosestIntersectionFunctor()
{
}

template <typename TypeToIntersect, typename Container, typename T_IntersectionRecordType>
bool DtSsClosestIntersectionFunctor<TypeToIntersect, Container, T_IntersectionRecordType>::operator()
   (TypeToIntersect& itemToIntersect, Container& containerToIntersect) 
{
   bool retVal = false;
   
   assert(myIntersectionRecord != 0);

   typename Container::iterator iter = containerToIntersect.begin();
   typename Container::iterator endIter = containerToIntersect.end();
   for (; iter != endIter; ++iter)
   {
      if ((*iter)->intersect(itemToIntersect, *myIntersectionRecord, myIntersectionRecordType))
      {
         assert(myIntersectionRecord->intersectionFound());
         retVal = true;
      }
   }

   return retVal;
}


template <typename TypeToIntersect, typename Container, typename T_IntersectionRecordType>
T_IntersectionRecordType* 
DtSsClosestIntersectionFunctor<TypeToIntersect, Container, T_IntersectionRecordType>::intersectionRecord() const
{
   return myIntersectionRecord;
}


template <typename TypeToIntersect, typename Container, typename T_IntersectionRecordType>
void DtSsClosestIntersectionFunctor<TypeToIntersect, Container, T_IntersectionRecordType>::
setIntersectionRecord(T_IntersectionRecordType* newIntersectionRecord)
{
   assert(newIntersectionRecord != 0);
   myIntersectionRecord = newIntersectionRecord;
}


template <typename TypeToIntersect, typename Container, typename T_IntersectionRecordType>
DtGdbNode::DtIntersectRecordType 
DtSsClosestIntersectionFunctor<TypeToIntersect, Container, T_IntersectionRecordType>::intersectionRecordType() const
{
   return myIntersectionRecordType;
}

template <typename TypeToIntersect, typename Container, typename T_IntersectionRecordType>
void DtSsClosestIntersectionFunctor<TypeToIntersect, Container, T_IntersectionRecordType>::
setIntersectionRecordType(DtGdbNode::DtIntersectRecordType& newIntersectionRecordType) 
{  
   myIntersectionRecordType = newIntersectionRecordType;
}

#endif