spatmod/imagefiltermorphology.h

Go to the documentation of this file.

#ifndef  INC_SPATMOD_IMAGEFILTERMORPHOLOGY_H
#define  INC_SPATMOD_IMAGEFILTERMORPHOLOGY_H

#ifndef  INC_SPATMOD_IMAGEFILTER_H
#include <spatmod/imagefilter.h>
#endif

#ifndef  INC_SPATMOD_IMAGEBUFFER_H
#include <spatmod/imagebuffer.h>
#endif

#ifndef  INC_MI32_MIMATRIX_H
#include <mi32/mimatrix.h>
#endif

namespace SPATMOD {
namespace IMAGE {

//=====================================================================================================================

#if 0
   enum MORPHOLOGY_TYPE {
         TYPE_Dilation = 0,
         TYPE_Erosion,
         TYPE_Opening,  // Erodes and then dilates
         TYPE_Closing,  // Dilates then erodes
         TYPE_HitMiss,  // no idea -- doesn't seem to be implemented
         TYPE_BoundExtract,   // not implemented?
         TYPE_Fill,           // iterates
         TYPE_Connected,      // iterates

         TYPE_ConvexHull,     // not implemented?
         TYPE_Thin,     // not implemented?
         TYPE_Thick,    // not implemented?
         TYPE_Skeleton,    // not implemented?
         TYPE_Prune,    // not implemented?

         TYPE_Clump,    // current implementation in rastclum.c
         TYPE_Sieve,    // current implementation in rastclum.c

         TYPE_Difference,  // in morphol.c only Trivial B - A
         TYPE_Intersection,   // in morphol.c only
         TYPE_Compliment      // in morphol.c Trivial for binary, wrong for anything else (really negates?)
         };
#endif

class FILTER_MORPHOLOGY : public FILTER {
   public:

      enum SHAPE {
         SHAPE_ShortLine = 0,
         SHAPE_Diagonal,
         SHAPE_LongLine,
         SHAPE_Plus,
         SHAPE_Square,
         SHAPE_Tee
         };

      enum ROTATION {
         ROTATION_0 = 0,
         ROTATION_90 = 90,
         ROTATION_180 = 180,
         ROTATION_270 = 270
         };

      virtual ~FILTER_MORPHOLOGY ();

      static void BuildElementMatrix (
         MIMATRIX& matrix,
         INT32 NumRows,
         INT32 NumCols,
         SHAPE shape,
         double OnValue,
         double OffValue = 0.0,
         ROTATION rotation = ROTATION_0
         );

      void SetElementMatrix (
         const MIMATRIX& matrix
         ) { m_Matrix = matrix; }

      void SetElementMatrix (
         INT32 NumRows,
         INT32 NumCols,
         SHAPE shape,
         double OnValue,
         double OffValue = 0.0,
         ROTATION rotation = ROTATION_0
         ) { BuildElementMatrix(m_Matrix, NumRows, NumCols, shape, OnValue, OffValue, rotation); }

   protected:

      FILTER_MORPHOLOGY (
         STAGE *pInputStage,              
         bool TakeOwnership               
         );

      const MIMATRIX& GetMatrix (
         ) const { return m_Matrix; }

      // STAGE/FILTER overrides.

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      // Unimplemented
      FILTER_MORPHOLOGY (const FILTER_MORPHOLOGY&);
      FILTER_MORPHOLOGY& operator= (const FILTER_MORPHOLOGY&);
      
      MIMATRIX m_Matrix;
      #endif // GENERATING_DOXYGEN_OUTPUT

   };

class FILTER_MORPHOLOGY_DILATION : public FILTER_MORPHOLOGY {
   public:

      FILTER_MORPHOLOGY_DILATION (
         STAGE *pInputStage,              
         bool TakeOwnership               
         );

      virtual ~FILTER_MORPHOLOGY_DILATION ();

   protected:

      // STAGE/FILTER overrides.

      virtual ERRVALUE v_Initialize ();

      virtual ERRVALUE v_PullBegin (const SECTION_ITERATOR& iterator);

      virtual ERRVALUE v_PullSubSection (const SECTION& section, BUFFER& target);

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      // Unimplemented
      FILTER_MORPHOLOGY_DILATION (const FILTER_MORPHOLOGY_DILATION&);
      FILTER_MORPHOLOGY_DILATION& operator= (const FILTER_MORPHOLOGY_DILATION&);
      
      SAMPLEITERATOR* m_itInput;
      SIMPLE_ARRAY<UINT8*> m_pValidInput;
      SIMPLE_ARRAY<const UINT8*> m_pInput;
      #endif // GENERATING_DOXYGEN_OUTPUT

   };

class FILTER_MORPHOLOGY_EROSION : public FILTER_MORPHOLOGY {
   public:

      FILTER_MORPHOLOGY_EROSION (
         STAGE *pInputStage,              
         bool TakeOwnership               
         );

      virtual ~FILTER_MORPHOLOGY_EROSION ();

   protected:

      // STAGE/FILTER overrides.

      virtual ERRVALUE v_Initialize ();

      virtual ERRVALUE v_PullBegin (const SECTION_ITERATOR& iterator);

      virtual ERRVALUE v_PullSubSection (const SECTION& section, BUFFER& target);

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      // Unimplemented
      FILTER_MORPHOLOGY_EROSION (const FILTER_MORPHOLOGY_EROSION&);
      FILTER_MORPHOLOGY_EROSION& operator= (const FILTER_MORPHOLOGY_EROSION&);
      
      SAMPLEITERATOR* m_itInput;
      SIMPLE_ARRAY<UINT8*> m_pValidInput;
      SIMPLE_ARRAY<const UINT8*> m_pInput;
      #endif // GENERATING_DOXYGEN_OUTPUT

   };

class FILTER_MORPHOLOGY_OPENING : public FILTER_MORPHOLOGY {
   public:

      FILTER_MORPHOLOGY_OPENING (
         STAGE *pInputStage,              
         bool TakeOwnership               
         );

      virtual ~FILTER_MORPHOLOGY_OPENING ();

   protected:

      // STAGE/FILTER overrides.

      virtual ERRVALUE v_Initialize ();

      virtual ERRVALUE v_PullSubSection (const SECTION& section, BUFFER& target);

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      // Unimplemented
      FILTER_MORPHOLOGY_OPENING (const FILTER_MORPHOLOGY_OPENING&);
      FILTER_MORPHOLOGY_OPENING& operator= (const FILTER_MORPHOLOGY_OPENING&);
      
      MIMATRIX m_Matrix;
      #endif // GENERATING_DOXYGEN_OUTPUT

   };


class FILTER_MORPHOLOGY_CLOSING : public FILTER_MORPHOLOGY {
   public:

      FILTER_MORPHOLOGY_CLOSING (
         STAGE *pInputStage,              
         bool TakeOwnership               
         );

      virtual ~FILTER_MORPHOLOGY_CLOSING ();

   protected:

      // STAGE/FILTER overrides.

      virtual ERRVALUE v_Initialize ();

      virtual ERRVALUE v_PullSubSection (const SECTION& section, BUFFER& target);

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      // Unimplemented
      FILTER_MORPHOLOGY_CLOSING (const FILTER_MORPHOLOGY_CLOSING&);
      FILTER_MORPHOLOGY_CLOSING& operator= (const FILTER_MORPHOLOGY_CLOSING&);
      
      MIMATRIX m_Matrix;
      #endif // GENERATING_DOXYGEN_OUTPUT

   };

//=====================================================================================================================

}  // End namespace IMAGE
}  // End namespace SPATMOD

#endif   // INC_SPATMOD_IMAGEFILTERMORPHOLOGY_H

---