Modifier.h

#pragma once

#if defined(Modifier_RECURSES)
#error Recursive header files inclusion detected in Modifier.h
#else // defined(Modifier_RECURSES)

#define Modifier_RECURSES

#if !defined Modifier_h

#define Modifier_h

// Inclusions
#include <iostream>
#include <utility>


#include "DGtal/base/Common.h"
#include "DGtal/kernel/PointVector.h"


namespace DGtal
{

namespace deprecated
{
  
  // template class Point3dTo2dXY
  template <typename Coordinate>
  class Point3dTo2dXY
  {
        
    public: 
      
    typedef PointVector<3,Coordinate> Input; 
    typedef PointVector<2,Coordinate> Output; 
    
    public:
      
    Output get(const Input& p) const
    {
      Input tmp = p;
      return Output(tmp.at(0),tmp.at(1));
    }
  
  }; // end of class Point3dTo2dXY
  
  // template class Point3dTo2dXZ
  template <typename Coordinate>
  class Point3dTo2dXZ
  {

    public: 
      
    typedef PointVector<3,Coordinate> Input; 
    typedef PointVector<2,Coordinate> Output; 
    
    public:
      
    Output get(const Input& p) const
    {
      Input tmp = p;
      return Output(tmp.at(0),tmp.at(2));
    }
  
  }; // end of class Point3dTo2dXZ

  // template class Point3dTo2dYZ
  template <typename Coordinate>
  class Point3dTo2dYZ
  {
    
    public: 
      
    typedef PointVector<3,Coordinate> Input; 
    typedef PointVector<2,Coordinate> Output; 
    
    public:
      
    Output get(const Input& p) const
    {
      Input tmp = p;
      return Output(tmp.at(1),tmp.at(2));
    }
  
  }; // end of class Point3dTo2dYZ

  // template class SCellToPoint
  template <typename KSpace>
  class SCellToPoint
  {
    
    private: 
    KSpace myK; 
    
    public: 
      
    typedef typename KSpace::Point Output;
    typedef typename KSpace::SCell Input;
    
    public:
      
    SCellToPoint() { }
    SCellToPoint(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 get(const Input& s) const
    {
      return Output( myK.sCoords(s) );
    }
      
  }; // end of class SCellToPoint

  // template class SCellToMidPoint
  template <typename KSpace>
  class SCellToMidPoint
  {
    
    public: 
      
    typedef PointVector<KSpace::dimension,double> Output;
    typedef typename KSpace::SCell Input;
    
    private: 
    KSpace myK;   
    
    public:
      
    SCellToMidPoint() { }
    SCellToMidPoint(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 get(const Input& s) const
    {
      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: 
    KSpace myK;   
    
    public:
     
    SCellToArrow() { }
    
    SCellToArrow(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 get(const Input& s) const
    {
      //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
  {
    BOOST_STATIC_ASSERT(( KSpace::dimension == 2 ));
    
    public: 
      
    typedef typename KSpace::Point Output;
    typedef typename KSpace::SCell Input;
    
    private: 
    KSpace myK;   
    
    public:
      
    SCellToInnerPoint() { }
    SCellToInnerPoint(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 get(const Input& s) const
    {
      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
  {
    BOOST_STATIC_ASSERT(( KSpace::dimension == 2 ));
    
    public: 
      
    typedef typename KSpace::Point Output;
    typedef typename KSpace::SCell Input;
    
    private: 
    KSpace myK;   
    
    public:
      
    SCellToOuterPoint() { }
    SCellToOuterPoint(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 get(const Input& s) const
    {
      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
  {
    
    BOOST_STATIC_ASSERT(( KSpace::dimension == 2 ));
    
    public: 
      
    typedef typename KSpace::Point Point;
    typedef std::pair<Point,Point> Output;

    typedef typename KSpace::SCell Input;
    
    private: 
    KSpace myK;   
    
    public:
      
    SCellToIncidentPoints() { }
    SCellToIncidentPoints(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 get(const Input& s) const
    {
      //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: 
    KSpace myK;   
    
    public:
      
    SCellToCode() { }
    SCellToCode(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 get(const Input& s) const
    {
      //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 SCellToArrow

} //namespace deprecated
  
} // namespace DGtal


// Includes inline functions.
//#include "DGtal/base/Modifier.ih"

//                                                                           //

#endif // !defined Modifier_h

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