gre/3dpntfld.h

Go to the documentation of this file.

/*** 
 * \file gre/3dpntfld.h
 * \brief 3D Points field
 *
 * \if NODOC
 * $Id: 3dpntfld.h_v 1.4 2005/09/15 18:03:40 vdronov Exp $
 *
 * $Log: 3dpntfld.h_v $
 * Revision 1.4  2005/09/15 18:03:40  vdronov
 * added comments
 *
 * Revision 1.3  2005/03/16 14:18:14  vdronov
 * *** empty log message ***
 *
 * Revision 1.2  2005/03/10 21:42:59  vdronov
 * *** empty log message ***
 *
 * Revision 1.1  2005/02/01 17:27:17  vdronov
 * Initial revision
 *
 *
 * \endif
**/ 

#ifndef  INC_GRE_3DPNTFLD_H
#define  INC_GRE_3DPNTFLD_H

#ifndef  INC_MI32_RECT_H
#include <mi32/rect.h>
#endif

#ifndef  INC_MI32_SIMPLEAR_H
#include <mi32/simplear.h>
#endif

#include <vector>

#ifndef GENERATING_DOXYGEN_OUTPUT
class BITSET;
#endif // GENERATING_DOXYGEN_OUTPUT

namespace GRE {

// POINTSFIELD class is the variaion of quadtree with given number of buckets equally distributed in given extents. 
// There are no methods for deleting or modifying of elements.
class POINTSFIELD {
   public:

      POINTSFIELD (
         ) :
         m_IsCreated(false),
         m_UseMask(false),
         m_StepReciprocal(0.0),
         m_NumColumns(0),
         m_NumLines(0)
         { }

      ~POINTSFIELD() { Clear(); }

      // Removes elements from quadtree and realeses all resources
      void Clear (
         );

      // Creates quadtree for given extents and number of buckets
      // equally distributed in extents
      ERRVALUE Create (
         const DRECT2D& extents,
         const INT32 numBuckets  = 4096
         );

      // Checks if quadtree is created
      bool IsCreated (
         ) const { return m_IsCreated; }

      // Adds a point to quadtree
      ERRVALUE AddPoint (
         const FPOINT3D& point
         );

      // Finds points inside given extents
      ERRVALUE FindInExtents (
         const DRECT2D& extents,
         SIMPLE_ARRAY<FPOINT3D>& points
         ) const;

      // Finds points inside given triangle
      ERRVALUE FindInTriangle (
         const FPOINT2D& point1,
         const FPOINT2D& point2,
         const FPOINT2D& point3,
         SIMPLE_ARRAY<FPOINT3D>& points
         ) const;

      // Finds points inside given ellipse
      ERRVALUE FindInEllipse (
         const FPOINT2D& center, 
         const float xradius,
         const float yradius,
         SIMPLE_ARRAY<FPOINT3D>& points
         ) const;

      // Masks points inside given extents
      ERRVALUE MaskExtents (
         const DRECT2D& extents
         );

      // Masks points inside given triangle
      ERRVALUE MaskTriangle (
         const FPOINT2D& point1,
         const FPOINT2D& point2,
         const FPOINT2D& point3
         );

      // Masks points inside given ellipse
      ERRVALUE MaskEllipse (
         const FPOINT2D& center,
         const float xradius,
         const float yradius
         );

      // Set use of mask, so if it set all find methods will find points only inside masked area.
      void UseMask (
         const bool use
         );

   private:

      class TRIANGLE {
         public:
         
            TRIANGLE (
               const FPOINT2D& point1,
               const FPOINT2D& point2,
               const FPOINT2D& point3
               );

            const DRECT2D& GetExtents (
               ) { return m_Extents; }

            bool IsPointInside (
               const FPOINT2D& point
               ) const;

         private:

            TRIANGLE ();

            static const bool s_Inside[27];

            DRECT2D m_Extents;
            DPOINT2D m_Normal1;
            DPOINT2D m_Normal2;
            DPOINT2D m_Normal3;
            double m_C1;
            double m_C2;
            double m_C3;
         };

      class ELLIPSE {
         public:
         
            ELLIPSE (
               const FPOINT2D& point,
               const float& x,
               const float& y
               );

            const DRECT2D& GetExtents (
               ) { return m_Extents; }

            bool IsPointInside (
               const FPOINT2D& point
               ) const;

         private:

            ELLIPSE ();

            DRECT2D m_Extents;
            DPOINT2D m_Center;
            double m_X2Reciprocal;
            double m_Y2Reciprocal;
         };

      typedef SIMPLE_ARRAY<FPOINT3D> BUCKET;
      typedef std::vector<BUCKET> BUCKETS;
      typedef std::vector<BITSET> MASK;

      bool m_IsCreated;
      bool m_UseMask;
      DRECT2D m_Extents;
      double m_StepReciprocal;
      INT32 m_NumColumns;
      INT32 m_NumLines;

      BUCKETS m_Buckets;
      MASK m_Mask;

   }; // End of POINTSFIELD class.

}     // End of GRE namespace

#endif

---