mi32/fillpoly.h

Go to the documentation of this file.

#ifndef  INC_MI32_FILLPOLY_H
#define  INC_MI32_FILLPOLY_H

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

#ifndef GENERATING_DOXYGEN_OUTPUT
class POLYLINE;
class SUBREGION2D;
#endif

class FILLPOLYGON {
   public:

   class SPAN {
      public:
         void Process (const double x1, const double x2, const double y)
            { VProcess(x1,x2,y); }
      private:
         virtual void VProcess (const double x1, const double x2, const double y) = 0; 
      };

   static ERRVALUE MakeScans (
      const POLYLINE& polyline,
      SPAN& span,
      const double origin = 0.0,
      const double step = 1.0
      );

   static ERRVALUE MakeScans (
      const SUBREGION2D& subregion,
      SPAN& span,
      const double origin = 0.0,
      const double step = 1.0
      );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      class EDGE {
         public:

            EDGE (
               const DPOINT2D& p1,           
               const DPOINT2D& p2            
               ) :
               m_YMin(MIN(p1.y,p2.y)),
               m_YMax(MAX(p1.y,p2.y)),
               m_DX((p1.y != p2.y) ? (p2.x - p1.x) / (p2.y - p1.y) : 0.0),
               m_X((p1.y < p2.y) ? p1.x : p2.x)
               { }

            EDGE& operator= (
               const EDGE& rhs
               ) {
               if (this != &rhs) {
                  const_cast<double&>(m_YMin) = rhs.m_YMin;
                  const_cast<double&>(m_YMax) = rhs.m_YMax;
                  const_cast<double&>(m_DX) = rhs.m_DX;
                  m_X = rhs.m_X;
                  }
               return (*this);
               }

            bool IsHorizontal (
               ) const {
               return (m_YMin == m_YMax);
               }

            void SetX (
               const double y
               ) {
               m_X += m_DX * (y - m_YMin);
               return;
               }

            double GetX (
               ) {
               return m_X;
               }

            void UpdateX (
               ) {
               m_X += m_DX;
               return;
               }

            const double m_YMin;
            const double m_YMax;
            const double m_DX;

         private:
            double m_X;
         };

      static int DoubleLessCompare (
         const void *p1,
         const void *p2
         ) {
         const double *d1 = static_cast<const double*>(p1);
         const double *d2 = static_cast<const double*>(p2);

         if (*d1 > *d2) return 1;
         if (*d1 < *d2) return -1;
         return 0;
         };

      static int EdgeYMinGreaterCompare (
         const void *p1,
         const void *p2
         ) {
         const EDGE *d1 = static_cast<const EDGE*>(p1);
         const EDGE *d2 = static_cast<const EDGE*>(p2);

         if (d1->m_YMin < d2->m_YMin) return 1;
         if (d1->m_YMin > d2->m_YMin) return -1;
         return 0;
         };

      FILLPOLYGON();
      ~FILLPOLYGON();
      FILLPOLYGON(const FILLPOLYGON&);

      #endif // GENERATING_DOXYGEN_OUTPUT

   };

#endif   // INC_MI32_FILLPOLY_H

---