mi32/bintoreg.h

Go to the documentation of this file.

/*****************************************************************************
 *
 * \file mi32/bintoreg.h
 * \brief A Binary raster to region converer class
 *
 * \if NODOC
 * $Log: bintoreg.h_v $
 * Revision 1.4  2005/03/09 22:56:20  mju
 * Eliminate most virtual overrides, now all goes through ProcessLine.
 *
 * Revision 1.3  2004/09/24 15:01:17  mju
 * Add isPointOnSpan.
 *
 * Revision 1.2  2004/07/02 17:38:29  dwilliss
 * Added AddSpansFromBytes
 *
 * Revision 1.1  2003/12/15 17:26:58  dwilliss
 * Initial revision
 * \endif
**/

#ifndef INC_MI32_BINTOREG_H
#define INC_MI32_BINTOREG_H

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

#ifndef INC_MI32_POLYLINE_H
#include <mi32/polyline.h>
#endif

#ifndef INC_MI32_REGION2D_H
#include <mi32/region2d.h>
#endif



//! Class for converting a binary raster to a region.
//!
//! This is a generic base class which can be extended to create any sort of
//! region: REGION2D, X region or Windows Region.
class BINARYTOREGIONINTERFACE {
   public:

      //! Add a span to the region.
      //! This is used to transfer the binary object (whatever the source)
      //! into a format that this class can use.
      //! Note, this method makes sure that the spans are kept in order and
      //! combines spans which overlap. 
      //! If you know you're adding spans in top-to-bottom, left-to-right order,
      //! call AddSpanFast() instead.
      ERRVALUE AddSpan (
         INT32 x1,
         INT32 x2,
         INT32 y
         );

      //! Add a span to the region.
      //! This is used to transfer the binary object (whatever the source)
      //! into a format that this class can use.
      //! Note, no attempt is made to keep the spans sorted or make sure the 
      //! span does not overlap any existing spans.  If you know you're adding
      //! spans in top-to-bottom, left-to-right order, you can use this method
      //! and it will be much faster than AddSpan()
      ERRVALUE AddSpanFast (
         INT32 x1,
         INT32 x2,
         INT32 y
         );

      //! Add spans to the region from a buffer of UINT8s
      //!
      //! This function takes an array of UINT8s representing a raster line
      //! and adds spans for all of the non-zero runs.
      //! The buffer is treated as one byte per pixel with 0 being false and
      //! non-zero being true.
      //! 
      //! The bFast parameter tells the function whether or not you're procssing
      //! lines in a top-down order without back-tracking.  If you are, pass
      //! true and it can add the spans without having to keep them sorted.
      ERRVALUE AddSpansFromBytes (
         INT32 lin,
         INT32 col,
         INT32 len,
         const UINT8* buf,
         bool bFast = false
         );

      //! Clear any existing spans.
      void Clear (
         );

      //! Determine if specified point is on existing span.
      bool IsPointOnSpan (
         INT32 x,
         INT32 y
         ) const;

      //! Process the spans that have been set.
      ERRVALUE ProcessSpans (
         );

   protected:

      BINARYTOREGIONINTERFACE ();

      virtual ~BINARYTOREGIONINTERFACE ();

   private:

      #ifndef GENERATING_DOXYGEN_OUTPUT

      struct SPAN {
         INT32 start;
         INT32 end;
         };

      typedef SIMPLE_ARRAY<SPAN> SPANARRAY;

      SIMPLE_ARRAY<SPANARRAY*> m_Spans;

      void FillSpan (
         INT32 x1,
         INT32 x2,
         INT32 y
         );

      static int TraceTest (
         INT32 x,
         INT32 y,
         void* cbdata
         );

      static int FillSpan (
         INT32 x1,
         INT32 x2,
         INT32 y,
         void* cbdata
         );

      #endif   // GENERATING_DOXYGEN_OUTPUT

      // Overridables

      //! Clear the current region.
      //! Will be called by the Clear() method, which also gets called by
      //! the destructor.
      virtual void v_Clear ();

      //! Add or remove a line from the region.
      //! Note that the points array passed in is not const for a reason. 
      //! The method is allowed to modify the points in the buffer before 
      //! adding them to the region.  Just don't free the buffer.
      virtual ERRVALUE v_ProcessLine (
         LPOINT2D* points,
         int numpts
         ) = 0;

   };


// An in implementation of BINARYTOREGIONINTERFACE which converts to a
// REGION2D
class BINARYTOREGION2D : public BINARYTOREGIONINTERFACE {
   public:
      BINARYTOREGION2D() {}
      ~BINARYTOREGION2D() {}

      // Get the region.
      // You must setup the spans and call ProcessSpans first.
      const REGION2D& GetRegion() {
         return m_region;
         }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      void v_Clear();

      virtual ERRVALUE v_ProcessLine (
         LPOINT2D* points,
         int numpts
         );

      REGION2D m_region;
      #endif   // GENERATING_DOXYGEN_OUTPUT
   };


#ifdef X_NATIVE

#include <X11/Intrinsic.h>

// An in implementation of BINARYTOREGIONINTERFACE which converts to an X
// Region.
class BINARYTOXREGION : public BINARYTOREGIONINTERFACE {
   public:
      BINARYTOXREGION() :
         m_region(0)
         {}

      ~BINARYTOXREGION() {}

      Region GetRegion() {
         return m_region;
         }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      void v_Clear();

      virtual ERRVALUE v_ProcessLine (
         LPOINT2D* points,
         int numpts
         );

      Region m_region;
      #endif   // GENERATING_DOXYGEN_OUTPUT
   };


#endif






#endif // INC_MI32_BINTOREG_H

---