include/gdb/ssAllIntersectionsFunctor.h

Go to the documentation of this file.

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

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

#include "geometry/chrdIntRec.h"
#include "gdb/gdbNode.h"
#include "geometry/intRecLst.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.  
// 
// 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>
class DtSsAllIntersectionsFunctor : public DtSsFunctor<TypeToIntersect, Container>
{
public:
   // Constructor
   DtSsAllIntersectionsFunctor();

   // Destructor
   virtual ~DtSsAllIntersectionsFunctor();

private:
   // not implemented
   DtSsAllIntersectionsFunctor(const DtSsAllIntersectionsFunctor& original);   
   DtSsAllIntersectionsFunctor& operator=(const DtSsAllIntersectionsFunctor& 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 DtChordIntersectRecordList* intersectionRecordContainer() const;

   virtual void setIntersectionRecordContainer(
      DtChordIntersectRecordList* newIntersectionRecordContainer);

   virtual DtGdbNode::DtIntersectRecordType intersectionRecordType() const;

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


private:

   DtChordIntersectRecordList*      myIntersectionRecordContainer;
   DtGdbNode::DtIntersectRecordType myIntersectionRecordType;
};


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


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

template <typename TypeToIntersect, typename Container>
bool DtSsAllIntersectionsFunctor<TypeToIntersect, Container>::operator()
   (TypeToIntersect& itemToIntersect, Container& containerToIntersect) 
{
   // Use our record type to determine whether we should keep looking
   bool retVal = false;
   
   assert(myIntersectionRecordContainer != 0);

   typename Container::iterator iter = containerToIntersect.begin();
   typename Container::iterator endIter = containerToIntersect.end();
   for (; iter != endIter; ++iter)
   {
      if ((*iter)->allIntersectsAlongChord(itemToIntersect, 
         *myIntersectionRecordContainer, myIntersectionRecordType))
      {
         assert(myIntersectionRecordContainer->count() != 0);
         // Ok I found one. Is that all I'm looking for?
         // If our intersection record is IRT_ALL_DATA_TERRAIN or 
         // IRT_VECTOR_DATA_ALONG_CHORD or IRT_ALL_DATA_ALONG_CHORD
         // we are looking for all possible hits so keep looking even
         // if one interesection is found.
         if ( myIntersectionRecordType == 0x07 ||
              myIntersectionRecordType == 0x20 ||
              myIntersectionRecordType == 0x27)
         {
            // We should keep looking for more
            retVal = false;
         }
         else
         {
            // We're done, we found the intersection we were looking for
            retVal = true;
         }
      }
   }

   return retVal;
}


template <typename TypeToIntersect, typename Container>
DtChordIntersectRecordList* 
DtSsAllIntersectionsFunctor<TypeToIntersect, Container>::intersectionRecordContainer() const
{
   return myIntersectionRecordContainer;
}


template <typename TypeToIntersect, typename Container>
void DtSsAllIntersectionsFunctor<TypeToIntersect, Container>::
setIntersectionRecordContainer(DtChordIntersectRecordList* newIntersectionRecordContainer)
{
   assert(newIntersectionRecordContainer != 0);
   myIntersectionRecordContainer = newIntersectionRecordContainer;
}


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


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



#endif