SCellsFunctors.h

 
#pragma once
 
#if defined(SCellsFunctors_RECURSES)
#error Recursive header files inclusion detected in SCellsFunctors.h
#else // defined(SCellsFunctors_RECURSES)
#define SCellsFunctors_RECURSES
 
#if !defined SCellsFunctors_h
#define SCellsFunctors_h
 
// Inclusions
#include <iostream>
#include <iterator>
#include "DGtal/base/Common.h"
#include "DGtal/base/ConstAlias.h"
#include "DGtal/base/BasicBoolFunctors.h"
#include "DGtal/kernel/SpaceND.h"
 
// @since 0.8 In DGtal::functors
namespace DGtal {
  namespace functors {
 
  // template class SCellToPoint
  template <typename KSpace>
  class SCellToPoint
  {
  public:
    typedef typename KSpace::Point Output;
    typedef typename KSpace::SCell Input;
 
    private: 
    const KSpace* myK; 
    
    public:
 
    SCellToPoint() : myK(NULL) { }
    SCellToPoint( ConstAlias<KSpace> aK ) : myK(&aK) { }
 
    SCellToPoint(const SCellToPoint& other)
    : myK(other.myK) { }
 
    SCellToPoint& operator= ( const SCellToPoint & other ) 
    {
      if (this != &other)
        {
          myK = other.myK;
        }
      return *this;
    }
    
    Output operator()(const Input& aSCell) const
    {
      ASSERT( myK );
      Input s = aSCell; 
      while ( myK->sDim(s) > 0 )
        {
          Input tmp( myK->sIndirectIncident( s, *myK->sDirs( s ) ) );
          ASSERT( myK->sDim(tmp) < myK->sDim(s) ); 
          s = tmp; 
        }
      return Output( myK->sCoords(s) );
    }
      
  }; // end of class SCellToPoint
 
  namespace deprecated
  {
  // template class SCellToMidPoint
  template <typename KSpace>
  class SCellToMidPoint
  {
    
    public: 
      
    typedef typename KSpace::Space::RealPoint Output;
    typedef typename KSpace::SCell Input;
    
    private: 
    const KSpace* myK;
    
    public:
      
    SCellToMidPoint() : myK(NULL) { }
    SCellToMidPoint( ConstAlias<KSpace> aK ) : myK(&aK) { }
 
    SCellToMidPoint(const SCellToMidPoint& other)
    : myK(other.myK) { }
 
    SCellToMidPoint & operator= ( const SCellToMidPoint & other ) 
    {
      if (this != &other)
        {
          myK = other.myK;
        }
      return *this;
    }
    
    Output operator()(const Input& s) const
    {
      ASSERT( myK ); 
      Output o( myK->sKCoords(s) );
      o /= 2;
      for( unsigned int i = 0; i < o.dimension; ++i )
          o[i] -= 0.5;
      return o;
    } 
      
  }; // end of class SCellToMidPoint
  } // end of namespace deprecated
  // template class SCellToArrow
  template <typename KSpace>
  class SCellToArrow
  {
    
    public: 
      
    typedef typename KSpace::Point Point;
    typedef typename KSpace::Vector Vector;
    typedef std::pair<Point,Vector> Output;
    typedef typename KSpace::SCell Input;
    
    private: 
    const KSpace* myK; 
    
    public:
    
    SCellToArrow() : myK(NULL) { }
    SCellToArrow( ConstAlias<KSpace> aK ) : myK(&aK) { }
 
    SCellToArrow(const SCellToArrow& other)
    : myK(other.myK) { }
 
    SCellToArrow & operator= ( const SCellToArrow & other ) 
    {
      if (this != &other)
        {
          myK = other.myK;
        }
      return *this;
    }
      
    Output operator()(const Input& s) const
    {
      ASSERT( myK ); 
      //starting point of the arrow
      Input pointel( myK->sIndirectIncident( s, *myK->sDirs( s ) ) );
      Point p( myK->sCoords( pointel ) );   //integer coordinates
      //displacement vector
      Vector v( myK->sKCoords( s ) - myK->sKCoords( pointel ) );
      return Output(p,v);
    }
      
  }; // end of class SCellToArrow
 
  // template class SCellToInnerPoint
  template <typename KSpace>
  class SCellToInnerPoint
  {
    
    public: 
      
    typedef typename KSpace::Point Output;
    typedef typename KSpace::SCell Input;
    
    private: 
    const KSpace* myK; 
    
    public:
      
    SCellToInnerPoint() : myK(NULL) { }
    SCellToInnerPoint( ConstAlias<KSpace> aK ) : myK(&aK) { }
 
    SCellToInnerPoint(const SCellToInnerPoint& other)
    : myK(other.myK) { }
 
    SCellToInnerPoint & operator= ( const SCellToInnerPoint & other ) 
    {
      if (this != &other)
        {
          myK = other.myK;
        }
      return *this;
    }
      
    Output operator()(const Input& s) const
    {
      ASSERT( myK ); 
      Input pixel( myK->sDirectIncident( s, *myK->sOrthDirs( s ) ) );
      return Output( myK->sCoords( pixel ) ); //integer coordinates
    }
      
  }; // end of class SCellToInnerPoint
 
  // template class SCellToOuterPoint
  template <typename KSpace>
  class SCellToOuterPoint
  {
    public: 
      
    typedef typename KSpace::Point Output;
    typedef typename KSpace::SCell Input;
    
    private: 
    const KSpace* myK; 
    
    public:
      
    SCellToOuterPoint() : myK(NULL) { }
    SCellToOuterPoint( ConstAlias<KSpace> aK ) : myK(&aK) { }
 
    SCellToOuterPoint(const SCellToOuterPoint& other)
    : myK(other.myK) { }
 
    SCellToOuterPoint & operator= ( const SCellToOuterPoint & other ) 
    {
      if (this != &other)
        {
          myK = other.myK;
        }
      return *this;
    }
      
    Output operator()(const Input& s) const
    {
      ASSERT( myK ); 
      Input pixel( myK->sIndirectIncident( s, *myK->sOrthDirs( s ) ) );
      return Output( myK->sCoords( pixel ) ); //integer coordinates
    }
      
  }; // end of class SCellToOuterPoint
 
  // template class SCellToIncidentPoints
  template <typename KSpace>
  class SCellToIncidentPoints
  {
    
    public: 
      
    typedef typename KSpace::Point Point;
    typedef std::pair<Point,Point> Output;
    typedef typename KSpace::SCell Input;
    
    private: 
    const KSpace* myK;   
    
    public:
      
    SCellToIncidentPoints() : myK(NULL) { }
    SCellToIncidentPoints( ConstAlias<KSpace> aK ) : myK(&aK) { }
 
    SCellToIncidentPoints(const SCellToIncidentPoints& other)
    : myK(other.myK) { }
 
    SCellToIncidentPoints & operator= ( const SCellToIncidentPoints & other ) 
    {
      if (this != &other)
        {
          myK = other.myK;
        }
      return *this;
    }
      
    Output operator()(const Input& s) const
    {
      ASSERT( myK ); 
      //inner point
      Input innerPixel( myK->sDirectIncident( s, *myK->sOrthDirs( s ) ) );
      //outer point
      Input outerPixel( myK->sIndirectIncident( s, *myK->sOrthDirs( s ) ) );
 
      return Output(myK->sCoords( innerPixel ),myK->sCoords( outerPixel ));
    }
      
  }; // end of class SCellToIncidentPoints
  
  // template class SCellToCode
  template <typename KSpace>
  class SCellToCode
  {
    
    BOOST_STATIC_ASSERT( KSpace::dimension == 2 );
 
    public: 
      
    typedef typename KSpace::Point Point;
    typedef typename KSpace::Vector Vector;
    typedef char Output;
 
    typedef typename KSpace::SCell Input;
    
    private: 
    const KSpace* myK;      
    
    public:
      
    SCellToCode() : myK(NULL) { }
    SCellToCode( ConstAlias<KSpace> aK ) : myK(&aK) { }
 
    SCellToCode(const SCellToCode& other)
    : myK(other.myK) { }
 
    SCellToCode & operator= ( const SCellToCode & other ) 
    {
      if (this != &other)
        {
          myK = other.myK;
        }
      return *this;
    }
      
    Output operator()(const Input& s) const
    {
      ASSERT( myK ); 
      //starting point of the arrow
      Input pointel( myK->sIndirectIncident( s, *myK->sDirs( s ) ) );
      Point p( myK->sCoords( pointel ) );   //integer coordinates
      //displacement vector
      Vector v( myK->sKCoords( s ) - myK->sKCoords( pointel ) );
      if (v == Vector(1,0)) return '0'; 
      else if (v == Vector(0,1)) return '1';
      else if (v == Vector(-1,0)) return '2';
      else if (v == Vector(0,-1)) return '3';
      else return 'e'; //e for error!
    }
      
  }; // end of class SCellToCode
 
} // namespace functors
} // namespace DGtal
 
 
// Includes inline functions.
//#include "DGtal/kernel/SCellsFunctors.ih"
 
//                                                                           //
 
#endif // !defined SCellsFunctors_h
 
#undef SCellsFunctors_RECURSES
#endif // else defined(SCellsFunctors_RECURSES)