structuring_element.h

Go to the documentation of this file.

/* This software and supporting documentation are distributed by
 *     Institut Federatif de Recherche 49
 *     CEA/NeuroSpin, Batiment 145,
 *     91191 Gif-sur-Yvette cedex
 *     France
 *
 * This software is governed by the CeCILL-B license under
 * French law and abiding by the rules of distribution of free software.
 * You can  use, modify and/or redistribute the software under the
 * terms of the CeCILL-B license as circulated by CEA, CNRS
 * and INRIA at the following URL "http://www.cecill.info".
 *
 * As a counterpart to the access to the source code and  rights to copy,
 * modify and redistribute granted by the license, users are provided only
 * with a limited warranty  and the software's author,  the holder of the
 * economic rights,  and the successive licensors  have only  limited
 * liability.
 *
 * In this respect, the user's attention is drawn to the risks associated
 * with loading,  using,  modifying and/or developing or reproducing the
 * software by the user in light of its specific status of free software,
 * that may mean  that it is complicated to manipulate,  and  that  also
 * therefore means  that it is reserved for developers  and  experienced
 * professionals having in-depth computer knowledge. Users are therefore
 * encouraged to load and test the software's suitability as regards their
 * requirements in conditions enabling the security of their systems and/or
 * data to be ensured and,  more generally, to use and operate it in the
 * same conditions as regards security.
 *
 * The fact that you are presently reading this means that you have had
 * knowledge of the CeCILL-B license and that you accept its terms.
 */
 
#ifndef AIMS_CONNECTIVITY_STRUCTURING_ELEMENT_2_H
#define AIMS_CONNECTIVITY_STRUCTURING_ELEMENT_2_H
 
//--- aims -------------------------------------------------------------------
#include <aims/vector/vector.h>                                     // Point3dl
//--- carto ------------------------------------------------------------------
#include <cartobase/smart/rcptr.h>                           // smart pointers
#include <cartobase/smart/refwrapper.h>               // wrapper to references
//--- std --------------------------------------------------------------------
#include <string>
#include <vector>
#include <set>
#include <map>
//--- forward declarations ---------------------------------------------------
namespace carto {
  template <typename T> class Volume;
}
//----------------------------------------------------------------------------
 
namespace aims {
 
  //==========================================================================
  // STRUCTURING ELEMENT: BASE CLASS
  //==========================================================================
  class StructuringElement {
    public:
      //----------------------------------------------------------------------
      // TYPEDEF
      //----------------------------------------------------------------------
      typedef std::vector<Point3dl>::iterator iterator;
      typedef std::vector<Point3dl>::const_iterator const_iterator;
 
      //----------------------------------------------------------------------
      // CONSTRUCTOR
      //----------------------------------------------------------------------
      StructuringElement(): _vector() {}
      StructuringElement( const std::vector<Point3dl> & vector ):
        _vector(vector) {}
      virtual ~StructuringElement() {}
      // Use default compiler-supplied copy constructor and assignment operator
      // StructuringElement( const StructuringElement & se );
      // StructuringElement & operator= ( const StructuringElement & se );
 
      //----------------------------------------------------------------------
      // ITERATORS
      //----------------------------------------------------------------------
      iterator begin() { return _vector.begin(); }
      iterator end() { return _vector.end(); }
      const_iterator begin() const { return _vector.begin(); }
      const_iterator end() const { return _vector.end(); }
 
 
      //----------------------------------------------------------------------
      // ACCESSOR
      //----------------------------------------------------------------------
      size_t size() const { return _vector.size(); }
      const std::vector<Point3dl> & getVector() const { return _vector; }
      std::vector<int> getAmplitude( const Point3dl & origin = Point3dl(0,0,0) ) const;

      virtual StructuringElement* clone() const { return new StructuringElement(*this); }
    protected:
      std::vector<Point3dl> _vector;
  };
 
  //==========================================================================
  // STRUCTURED VOLUME
  //==========================================================================
  template <typename T>
  class StructuredVolume
  {
    public:
      typedef typename std::vector<carto::reference_wrapper<T> >::iterator iterator;
      typedef typename std::vector<carto::reference_wrapper<T> >::const_iterator const_iterator;
      StructuredVolume( carto::Volume<T> & vol,
                        const StructuringElement & se ):
        _vector()
      {
        StructuringElement::const_iterator i, e = se.end();
        for( i=se.begin(); i!=e; ++i )
          _vector.push_back( carto::wrap::ref( vol( (*i)[0], (*i)[1], (*i)[2] ) ) );
      }
      ~StructuredVolume() {}
      typename StructuredVolume<T>::iterator begin() { return _vector.begin(); }
      typename StructuredVolume<T>::iterator end() { return _vector.end(); }
      typename StructuredVolume<T>::const_iterator begin() const { return _vector.begin(); }
      typename StructuredVolume<T>::const_iterator end() const { return _vector.end(); }
    protected:
      std::vector<carto::reference_wrapper<T> > _vector;
  };

  template <typename T>
  class StructuredConstVolume
  {
    public:
      typedef typename std::vector<carto::reference_wrapper<const T> >::iterator iterator;
      typedef typename std::vector<carto::reference_wrapper<const T> >::const_iterator const_iterator;
      StructuredConstVolume( const carto::Volume<T> & vol,
                             const StructuringElement & se ):
        _vector()
      {
        StructuringElement::const_iterator i, e = se.end();
        for( i=se.begin(); i!=e; ++i )
          _vector.push_back( carto::wrap::cref( vol( (*i)[0], (*i)[1], (*i)[2] ) ) );
      }
      ~StructuredConstVolume() {}
      typename StructuredConstVolume<T>::iterator begin() { return _vector.begin(); }
      typename StructuredConstVolume<T>::iterator end() { return _vector.end(); }
      typename StructuredConstVolume<T>::const_iterator begin() const { return _vector.begin(); }
      typename StructuredConstVolume<T>::const_iterator end() const { return _vector.end(); }
    protected:
      std::vector<carto::reference_wrapper<const T> > _vector;
  };
 
  //==========================================================================
  // STRUCTURING ELEMENT: REFERENCE
  //==========================================================================
  class StructuringElementRef: public carto::rc_ptr<StructuringElement>
  {
    public:
      typedef StructuringElement::iterator        iterator;
      typedef StructuringElement::const_iterator  const_iterator;

      StructuringElementRef():
        carto::rc_ptr<StructuringElement>() {}

      StructuringElementRef( StructuringElement * se ):
        carto::rc_ptr<StructuringElement>(se) {}

      StructuringElementRef( const carto::rc_ptr<StructuringElement> & se ):
        carto::rc_ptr<StructuringElement>(se) {}
 
      iterator begin() { return (*this)->begin(); }
      iterator end() { return (*this)->end(); }
      const_iterator begin() const { return (*this)->begin(); }
      const_iterator end() const { return (*this)->end(); }
 
      size_t size() const { return (*this)->size(); }
      const std::vector<Point3dl> & getVector() const
      { return (*this)->getVector(); }
      std::vector<int>
      getAmplitude( const Point3dl & origin = Point3dl(0,0,0) ) const
      { return (*this)->getAmplitude(origin); }
  };
 
  namespace strel {
    extern StructuringElementRef none();
 
    //========================================================================
    // STRUCTURING ELEMENT: SHAPE INTERFACE
    //========================================================================
    class Shape: public StructuringElement
    {
      friend class ShapeFactory;
      public:
        typedef StructuringElement::iterator        iterator;
        typedef StructuringElement::const_iterator  const_iterator;
        virtual ~Shape() {};
        virtual Shape* clone() const = 0;
        
      protected:
        // Defined methods
        void setParameters( const double amplitude = 1.,
                            const bool usecenter = false );
        void setParameters( const Point3dl & origin,
                            const double amplitude = 1.,
                            const bool usecenter = false );
        void setParameters( const Point3d & origin,
                            const double amplitude = 1,
                            const bool usecenter = false );   
        void setParameters( const std::vector<double> & amplitude,
                            const bool usecenter = false );
        void setParameters( const Point3d & origin,
                            const std::vector<double> & amplitude,
                            const bool usecenter = false );
        
        // Pure virtual methods:
        virtual void setParameters( const Point3dl & origin,
                                    const std::vector<double> & amplitude,
                                    const bool usecenter = false ) = 0;
    };
 
    //========================================================================
    // STRUCTURING ELEMENT: SHAPE FACTORY
    //========================================================================
    class ShapeFactory {
      public:
        static Shape* create( const std::string & type,
                              const double amplitude = 1.,
                              const bool usecenter = false );
        static Shape* create( const std::string & type,
                              const Point3d & origin,
                              const double amplitude = 1.,
                              const bool usecenter = false );
        static Shape* create( const std::string & type,
                              const Point3dl & origin,
                              const double amplitude = 1.,
                              const bool usecenter = false );
        static Shape* create( const std::string & type,
                              const std::vector<double> & amplitude,
                              const bool usecenter = false );
        static Shape* create( const std::string & type,
                              const Point3d & origin,
                              const std::vector<double> & amplitude,
                              const bool usecenter = false );
        static Shape* create( const std::string & type,
                              const Point3dl & origin,
                              const std::vector<double> & amplitude,
                              const bool usecenter = false );
        static void registerShape( const std::string & type,
                                   const Shape & strel );
        static std::set<std::string> shapes();
      protected:
        static void init();
        static std::map<std::string,carto::rc_ptr<Shape> > & _map();
    };
 
    //========================================================================
    // STRUCTURING ELEMENT: CONNECTIVITY INTERFACE
    //========================================================================
    class Connectivity: public StructuringElement
    {
      friend class ConnectivityFactory;
      public:
        typedef StructuringElement::iterator        iterator;
        typedef StructuringElement::const_iterator  const_iterator;
        virtual ~Connectivity() {};
        virtual Connectivity* clone() const = 0;
        //--------------------------------------------------------------------
        // TYPEDEF
        //--------------------------------------------------------------------
        typedef const bool (&Matrix3x3x3Const)[3][3][3];
        //--------------------------------------------------------------------
        // METHODS
        //--------------------------------------------------------------------
        virtual Matrix3x3x3Const getMatrix() const = 0;
      protected:
        void setVectorFromMatrix( const Point3dl & origin = Point3dl(0,0,0),
                                  const bool usecenter = false );
    };
 
    //========================================================================
    // STRUCTURING ELEMENT: CONNECTIVITY FACTORY
    //========================================================================
    class ConnectivityFactory
    {
      public:
        static Connectivity* create( const std::string & type,
                                     const bool usecenter = false );
        static Connectivity* create( const std::string & type,
                                     const Point3d & origin,
                                     const bool usecenter = false );
        static Connectivity* create( const std::string & type,
                                     const Point3dl & origin,
                                     const bool usecenter = false );
        static void registerConnectivity( const std::string & type,
                                          const Connectivity & strel );
        static std::set<std::string> connectivities();
      protected:
        static void init();
        static std::map<std::string,carto::rc_ptr<Connectivity> > & _map();
    };
 
  } // namespace strel
} // namespace aims
 
 
//============================================================================
// STRUCTURING ELEMENT: SHAPE DERIVED CLASSES
//============================================================================
#define AIMS_DECLARE_STREL_SHAPE( NAME )                                     \
  class NAME: public Shape                                                   \
  {                                                                          \
    public:                                                                  \
      typedef StructuringElement::iterator        iterator;                  \
      typedef StructuringElement::const_iterator  const_iterator;            \
      NAME( const double amplitude = 1.,                                     \
            const bool usecenter = false ): Shape()                          \
          { Shape::setParameters( amplitude, usecenter ); }                  \
      NAME( const Point3d & origin,                                          \
            const double amplitude = 1.,                                     \
            const bool usecenter = false ): Shape()                          \
          { Shape::setParameters( origin, amplitude, usecenter ); }          \
      NAME( const Point3dl & origin,                                         \
            const double amplitude = 1.,                                     \
            const bool usecenter = false ): Shape()                          \
          { Shape::setParameters( origin, amplitude, usecenter ); }          \
      NAME( const std::vector<double> & amplitude,                           \
            const bool usecenter = false ): Shape()                          \
          { Shape::setParameters( amplitude, usecenter ); }                  \
      NAME( const Point3d & origin,                                          \
            const std::vector<double> & amplitude,                           \
            const bool usecenter = false ): Shape()                          \
          { Shape::setParameters( origin, amplitude, usecenter ); }          \
      NAME( const Point3dl & origin,                                         \
            const std::vector<double> & amplitude,                           \
            const bool usecenter = false ): Shape()                          \
          { setParameters( origin, amplitude, usecenter ); }                 \
      virtual ~NAME() {}                                                     \
    protected:                                                               \
      virtual void setParameters( const Point3dl & origin,                   \
                                  const std::vector<double> & amplitude,     \
                                  const bool usecenter = false );            \
      virtual NAME* clone() const { return new NAME(*this); }                \
  };
  
namespace aims {
  namespace strel {
    AIMS_DECLARE_STREL_SHAPE( Cube );
    AIMS_DECLARE_STREL_SHAPE( SquareXY );
    AIMS_DECLARE_STREL_SHAPE( SquareXZ );
    AIMS_DECLARE_STREL_SHAPE( SquareYZ );
    AIMS_DECLARE_STREL_SHAPE( Sphere );
    AIMS_DECLARE_STREL_SHAPE( DiskXY );
    AIMS_DECLARE_STREL_SHAPE( DiskXZ );
    AIMS_DECLARE_STREL_SHAPE( DiskYZ );
    AIMS_DECLARE_STREL_SHAPE( Cross );
    AIMS_DECLARE_STREL_SHAPE( CrossXY );
    AIMS_DECLARE_STREL_SHAPE( CrossXZ );
    AIMS_DECLARE_STREL_SHAPE( CrossYZ );
    AIMS_DECLARE_STREL_SHAPE( DiagonalCross );
    AIMS_DECLARE_STREL_SHAPE( DiagonalCrossXY );
    AIMS_DECLARE_STREL_SHAPE( DiagonalCrossXZ );
    AIMS_DECLARE_STREL_SHAPE( DiagonalCrossYZ );
    AIMS_DECLARE_STREL_SHAPE( CircleXY );    
    
    class ClockWiseCircleXY: public CircleXY
    {
      public:
        typedef StructuringElement::iterator        iterator;
        typedef StructuringElement::const_iterator  const_iterator;
        ClockWiseCircleXY( const double amplitude = 1.,
                           const bool usecenter = false ): CircleXY()
            { Shape::setParameters( amplitude, usecenter ); }
        ClockWiseCircleXY( const Point3d & origin,
                           const double amplitude = 1.,
                           const bool usecenter = false ): CircleXY()
            { Shape::setParameters( origin, amplitude, usecenter ); }
        ClockWiseCircleXY( const Point3dl & origin,
                           const double amplitude = 1.,
                           const bool usecenter = false ): CircleXY()
            { Shape::setParameters( origin, amplitude, usecenter ); }
        ClockWiseCircleXY( const std::vector<double> & amplitude,
                           const bool usecenter = false ): CircleXY()
            { Shape::setParameters( amplitude, usecenter ); }
        ClockWiseCircleXY( const Point3d & origin,
                           const std::vector<double> & amplitude,
                           const bool usecenter = false ): CircleXY()
            { Shape::setParameters( origin, amplitude, usecenter ); }
        ClockWiseCircleXY( const Point3dl & origin,
                           const std::vector<double> & amplitude,
                           const bool usecenter = false ): CircleXY()
            { setParameters( origin, amplitude, usecenter ); }
        virtual ~ClockWiseCircleXY() {}
        
      protected:
        virtual void clockwise_order();
        virtual void setParameters( const Point3dl & origin,
                                    const std::vector<double> & amplitude,
                                    const bool usecenter = false );
        virtual ClockWiseCircleXY* clone() const
            { return new ClockWiseCircleXY(*this); }
    };
    
  } // namespace strel
} // namespace aims
 
//============================================================================
// STRUCTURING ELEMENT: CONNECTIVITY DERIVED CLASSES
//============================================================================
#define AIMS_DECLARE_STREL_CONNECTIVITY( NAME )                              \
  class NAME: public Connectivity                                            \
  {                                                                          \
    public:                                                                  \
      typedef StructuringElement::iterator        iterator;                  \
      typedef StructuringElement::const_iterator  const_iterator;            \
      NAME(): Connectivity() { setVectorFromMatrix(); }                      \
      virtual ~NAME() {}                                                     \
      Connectivity::Matrix3x3x3Const getMatrix() const;                      \
    protected:                                                               \
      virtual NAME* clone() const                                            \
        { return new NAME(*this); }                                          \
  }
 
namespace aims {
  namespace strel {
    AIMS_DECLARE_STREL_CONNECTIVITY( Connectivity4XY );
    AIMS_DECLARE_STREL_CONNECTIVITY( Connectivity4XZ );
    AIMS_DECLARE_STREL_CONNECTIVITY( Connectivity4YZ );
    AIMS_DECLARE_STREL_CONNECTIVITY( Connectivity4XYDiag );
    AIMS_DECLARE_STREL_CONNECTIVITY( Connectivity4XZDiag );
    AIMS_DECLARE_STREL_CONNECTIVITY( Connectivity4YZDiag );
    AIMS_DECLARE_STREL_CONNECTIVITY( Connectivity6XYZ );
    AIMS_DECLARE_STREL_CONNECTIVITY( Connectivity8XY );
    AIMS_DECLARE_STREL_CONNECTIVITY( Connectivity8XZ );
    AIMS_DECLARE_STREL_CONNECTIVITY( Connectivity8YZ );
    AIMS_DECLARE_STREL_CONNECTIVITY( Connectivity8XYZ );
    AIMS_DECLARE_STREL_CONNECTIVITY( Connectivity18XYZ );
    AIMS_DECLARE_STREL_CONNECTIVITY( Connectivity26XYZ );
    AIMS_DECLARE_STREL_CONNECTIVITY( Connectivity9XYZMinus );
    AIMS_DECLARE_STREL_CONNECTIVITY( Connectivity9XYZPlus );
    AIMS_DECLARE_STREL_CONNECTIVITY( Connectivity9XZYMinus );
    AIMS_DECLARE_STREL_CONNECTIVITY( Connectivity9XZYPlus );
    AIMS_DECLARE_STREL_CONNECTIVITY( Connectivity9YZXMinus );
    AIMS_DECLARE_STREL_CONNECTIVITY( Connectivity9YZXPlus );
    AIMS_DECLARE_STREL_CONNECTIVITY( Connectivity5XMinusY );
    AIMS_DECLARE_STREL_CONNECTIVITY( Connectivity5XPlusY );
    AIMS_DECLARE_STREL_CONNECTIVITY( Connectivity5XYMinus );
    AIMS_DECLARE_STREL_CONNECTIVITY( Connectivity5XYPlus );
    AIMS_DECLARE_STREL_CONNECTIVITY( Connectivity5XMinusZ );
    AIMS_DECLARE_STREL_CONNECTIVITY( Connectivity5XPlusZ );
    AIMS_DECLARE_STREL_CONNECTIVITY( Connectivity5XZMinus );
    AIMS_DECLARE_STREL_CONNECTIVITY( Connectivity5XZPlus );
    AIMS_DECLARE_STREL_CONNECTIVITY( Connectivity5YMinusZ );
    AIMS_DECLARE_STREL_CONNECTIVITY( Connectivity5YPlusZ );
    AIMS_DECLARE_STREL_CONNECTIVITY( Connectivity5YZMinus );
    AIMS_DECLARE_STREL_CONNECTIVITY( Connectivity5YZPlus );
  } // namespace strel
} // namespace aims
 
#endif