mi32/fillpoly.h

Go to the documentation of this file.

/**
 * \file fillpoly.h <mi32/fillpoly.h>
 * \brief Definitions for FILLPOLYGON class
 *
 * \if NODOC
 * $Id: fillpoly.h_v 1.3 2003/09/15 13:49:56 fileserver!dwilliss Exp $
 *
 * $Log: fillpoly.h_v $
 * Revision 1.3  2003/09/15 13:49:56  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.2  2002/08/22 15:41:08  vdronov
 * const_cast was used in operator=
 *
 * Revision 1.1  2002/08/21 14:25:31  vdronov
 * Initial revision
 *
 * \endif
**/


#ifndef  INC_MI32_FILLPOLY_H
#define  INC_MI32_FILLPOLY_H

#include <mi32/polyline.h>

//! FILLPOLYGON class provides MakeScans method
class FILLPOLYGON {
   public:

   //! An interface that deal with result of fill polygon
   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; 
      };

   //! MakeScans method creates set of scans of polygon "points" depends on "origin" and "step"
   //! and call method "Process" of "span" for each scan.
   static ERRVALUE MakeScans (
      const POLYLINE& polyline,
      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;
      };

      //! Not implemented
      FILLPOLYGON();
      ~FILLPOLYGON();
      FILLPOLYGON(const FILLPOLYGON&);
      #endif // GENERATING_DOXYGEN_OUTPUT

   };

#endif   //!< INC_MI32_FILLPOLY_H

---