rvc/spattree.h

Go to the documentation of this file.

#ifndef INC_RVC_SPATTREE_H
#define INC_RVC_SPATTREE_H

#ifndef INC_RVC_OBJECT_H
   #include <rvc/object.h>
#endif

#ifndef INC_MI32_ELEMTYPE_H
   #include <mi32/elemtype.h>
#endif

#ifndef INC_MI32_RANGE_H
   #include <mi32/range.h>
#endif

#ifndef INC_MI32_POINT_H
   #include <mi32/point.h>
#endif


#ifndef GENERATING_DOXYGEN_OUTPUT
// Forward Declarations
class UNSIGNEDSET;
namespace RVC {
   class SPATIALTREEHANDLE;
   }
#endif


namespace RVC {

class SPATIALTREE : public RVC::OBJECT {
   public:

      struct TIERINFO {
         // No members may ever be added to this structure.
         // The DLL does not support expansion.
      
         DPOINT3D m_Origin;
         DPOINT3D m_NodeSize;
         WPOINT3D m_NumNodes;
         UINT8 spare[2];
      
         TIERINFO (
            ) { Clear(); } 

         INT32 CalcNode2D (
            const DPOINT2D& point
            ) const {
            INT32 xpos = CalcNodeX(point.x);
            if (xpos < 0 || xpos >= m_NumNodes.x) return (-1);
            INT32 ypos = CalcNodeY(point.y);
            if (ypos < 0 || ypos >= m_NumNodes.y) return (-1);
            return (ypos * m_NumNodes.x + xpos);
            }
      
         INT32 CalcNode3D (
            const DPOINT3D& point
            ) const {
            INT32 node = CalcNode2D(point);
            if (m_NumNodes.z > 1 && node >= 0) {
               INT32 zpos = CalcNodeZ(point.z);
               if (zpos < 0 || zpos >= m_NumNodes.z) return (-1);
               node += zpos * m_NumNodes.x * m_NumNodes.y;
               }
            return (node);
            }
      
         INT32 CalcNodeX (
            double x
            ) const { return (static_cast<INT32>(floor((x - m_Origin.x) / m_NodeSize.x))); }
      
         INT32 CalcNodeY (
            double y
            ) const { return (static_cast<INT32>(floor((y - m_Origin.y) / m_NodeSize.y))); }
      
         INT32 CalcNodeZ (
            double z
            ) const { return (static_cast<INT32>(floor((z - m_Origin.z) / m_NodeSize.z))); }

         void Clear (
            ) {memset(static_cast<void*>(this), 0, sizeof(*this));}
         };

      SPATIALTREE (
         );

      SPATIALTREE (
         const RVC::SPATIALTREE& rhs
         );

      virtual ~SPATIALTREE (
         );

      RVC::SPATIALTREE& operator= (
         const RVC::SPATIALTREE& rhs
         );

      ERRVALUE Search (
         ELEMTYPE elemtype,                     
         const DRECT2D& rect,                
         SIMPLE_ARRAY<INT32_RANGE>& elemranges     
         );
      
      ERRVALUE Search (
         ELEMTYPE elemtype,                  
         const DRECT2D& rect,                
         UNSIGNEDSET& ElemSet                
         );
      
      INT32 GetMaxNodeArrayElems (
         ELEMTYPE elemtype                   
         );
      
      INT32 GetNumTiers (
         ELEMTYPE elemtype                   
         );
      
      ERRVALUE Make (
         const RVC::OBJECT& parent,             
         const RVC::DESCRIPTOR& Descriptor,     
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS            
         );
      
      ERRVALUE Make (
         RVC::OBJITEM& ObjItem,                       
#ifdef RVC_CREDENTIALS_MANDATORY
         const char* Source,                    
         const CREDENTIALS* Credentials
#else
         const char* Source = 0,                   
         const CREDENTIALS* Credentials = 0
#endif
         );
      
      ERRVALUE ReadTier (
         ELEMTYPE elemtype,                     
         int tier,                           
         TIERINFO& tierinfo,                    
         INT32 *firstelemarray                  
         );
      
      ERRVALUE WriteTier (
         ELEMTYPE elemtype,                     
         int tier,                           
         TIERINFO& tierinfo,                    
         INT32 *firstelemarray                  
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      virtual ERRVALUE v_CloseObject ();
      virtual RVC::OBJTYPE v_GetDftObjectType () const;
      virtual bool v_IsObjectOpen () const;
      virtual ERRVALUE v_OpenObject (OPENMODE OpenMode, MDLGPARENT parent, const CREDENTIALS* Credentials);

      SPATIALTREEHANDLE *m_pSpatialTreeHandle;
      #endif // GENERATING_DOXYGEN_OUTPUT

   };

}     

#endif      

---