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/kernel/SpaceND.h"
#include "DGtal/base/BasicBoolFunctions.h"

namespace DGtal
{

  // template class SCellToPoint
  template <typename KSpace>
  class SCellToPoint
  {

    typedef typename KSpace::Point Output;
    typedef typename KSpace::SCell Input;

    private: 
    const KSpace* myK; 
    
    public:

    SCellToPoint() : myK(NULL) { }
    SCellToPoint(const 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

  // 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(const 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;
      return o;
    } 
      
  }; // end of class SCellToMidPoint

  // 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(const 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(const 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->sIndirectIncident( 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(const 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->sDirectIncident( 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(const 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->sIndirectIncident( s, *myK->sOrthDirs( s ) ) );
      //outer point
      Input outerPixel( myK->sDirectIncident( 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(const 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 DGtal


// Includes inline functions.
//#include "DGtal/kernel/SCellsFunctors.ih"

//                                                                           //

#endif // !defined SCellsFunctors_h

#undef SCellsFunctors_RECURSES
#endif // else defined(SCellsFunctors_RECURSES)