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

  // 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)