RigidTransformation2D.h

 
#pragma once
 
#if defined(RigidTransformation2D_RECURSES)
#error Recursive header files inclusion detected in RigidTransformation2D.h
#else // defined(RigidTransformation2D_RECURSES)
 
#define RigidTransformation2D_RECURSES
 
#if !defined RigidTransformation2D_h
 
#define RigidTransformation2D_h
 
// Inclusions
#include <iostream>
#include <cmath>
#include <climits>
#include <utility>
#include "DGtal/base/Common.h"
#include "DGtal/kernel/BasicPointFunctors.h"
#include <DGtal/helpers/StdDefs.h>
#include <DGtal/kernel/domains/CDomain.h>
#include <DGtal/kernel/CSpace.h>
 
namespace DGtal
{
namespace functors
{
// Template class ForwardRigidTransformation2D
template < typename TSpace, typename TInputValue = typename TSpace::RealPoint, typename TOutputValue = typename TSpace::Point,
           typename TFunctor = VectorRounding < TInputValue, TOutputValue > >
class ForwardRigidTransformation2D
{
    BOOST_CONCEPT_ASSERT(( concepts::CSpace<TSpace> ));
    BOOST_STATIC_ASSERT(( TSpace::dimension == 2 ));
    BOOST_STATIC_ASSERT(( TOutputValue::dimension == 2 ));
    BOOST_STATIC_ASSERT(( TInputValue::dimension == 2 ));
 
    // ----------------------- Types ------------------------------
public:
    typedef typename TSpace::RealPoint RealPoint;
    typedef typename TSpace::RealVector RealVector;
 
    // ----------------------- Interface --------------------------------------
public:
    ForwardRigidTransformation2D ( const RealPoint & aOrigin, const double & angle, const RealVector & aTranslate )
        :origin(aOrigin), translation(aTranslate)
    {
        t_sin = std::sin ( angle );
        t_cos = std::cos ( angle );
    }
 
    inline
    TOutputValue operator()( const TInputValue & aInput ) const
    {
        RealPoint p;
        p[0] = ( ( t_cos * ( aInput[0] - origin[0] ) -
               t_sin * ( aInput[1] - origin[1] ) ) + translation[0] ) + origin[0];
 
        p[1] = ( ( t_sin * ( aInput[0] - origin[0] ) +
               t_cos * ( aInput[1] - origin[1] ) ) + translation[1] ) + origin[1];
        return functor ( p );
    }
 
    // ------------------------- Protected Datas ------------------------------
protected:
    RealPoint origin;
    double t_sin;
    double t_cos;
    RealVector translation;
    TFunctor functor;
};
 
// Template class BackwardRigidTransformation2D
template < typename TSpace, typename TInputValue = typename TSpace::RealPoint, typename TOutputValue = typename TSpace::Point,
           typename TFunctor = VectorRounding < TInputValue, TOutputValue > >
class BackwardRigidTransformation2D
{
    BOOST_CONCEPT_ASSERT(( concepts::CSpace<TSpace> ));
    BOOST_STATIC_ASSERT(( TSpace::dimension == 2 ));
    BOOST_STATIC_ASSERT(( TOutputValue::dimension == 2 ));
    BOOST_STATIC_ASSERT(( TInputValue::dimension == 2 ));
 
    // ----------------------- Types ------------------------------
public:
    typedef typename TSpace::RealPoint RealPoint;
    typedef typename TSpace::RealVector RealVector;
 
    // ----------------------- Interface --------------------------------------
public:
    BackwardRigidTransformation2D ( const RealPoint& aOrigin, const double & angle, const RealVector & aTranslate )
        :origin(aOrigin), translation(aTranslate)
    {
        t_sin = std::sin ( angle );
        t_cos = std::cos ( angle );
    }
 
    inline
    TOutputValue operator()( const TInputValue & aInput ) const
    {
        RealPoint p;
        p[0] = ( t_cos * (aInput[0] - translation[0] - origin[0] ) +
               t_sin * ( aInput[1] - translation[1] - origin[1] ) ) + origin[0];
 
        p[1] = ( -t_sin * ( aInput[0] - translation[0] - origin[0] ) +
               t_cos * ( aInput[1] - translation[1] - origin[1] ) ) + origin[1];
        return functor ( p);
    }
 
    // ------------------------- Protected Datas ------------------------------
protected:
    RealPoint origin;
    double t_sin;
    double t_cos;
    RealVector translation;
    TFunctor functor;
};
 
// Template class DomainRigidTransformation2D
template <typename TDomain, typename TRigidTransformFunctor >
class DomainRigidTransformation2D
{
    BOOST_STATIC_ASSERT(( TDomain::dimension == 2 ));
    BOOST_CONCEPT_ASSERT(( concepts::CDomain<TDomain> ));
 
    // ----------------------- Types ------------------------------
public:
    typedef std::pair < typename TDomain::Space::Point, typename TDomain::Space::Point > Bounds;
 
    // ----------------------- Interface --------------------------------------
public:
    DomainRigidTransformation2D ( const  TRigidTransformFunctor & aRigidFunctor ) : transform ( aRigidFunctor ) {}
 
    inline
    Bounds operator()( const TDomain & aInput ) const
    {
        typedef typename TDomain::Point Point;
        Point points[4];
        points[0] = transform ( aInput.lowerBound() );
        points[1] = transform ( aInput.upperBound() );
        points[2] = transform ( Point ( aInput.upperBound()[0], aInput.lowerBound()[1] ) );
        points[3] = transform ( Point ( aInput.lowerBound()[0], aInput.upperBound()[1] ) );
 
        Point t_min ( INT_MAX, INT_MAX ), t_max ( INT_MIN, INT_MIN );
        for ( unsigned int i = 0; i < 4 ; i++ )
        {
            if ( points[i][0] < t_min[0] )
                t_min[0] = points[i][0];
            if ( points[i][1] < t_min[1] )
                t_min[1] = points[i][1];
 
            if ( points[i][0] > t_max[0] )
                t_max[0] = points[i][0];
            if ( points[i][1] > t_max[1] )
                t_max[1] = points[i][1];
        }
 
        Bounds bounds;
        bounds.first = t_min;
        bounds.second = t_max;
        return bounds;
    }
 
    // ------------------------- Protected Datas ------------------------------
protected:
   const TRigidTransformFunctor & transform;
};
 
}// namespace DGtal::functors
}// namespace DGtal
 
#endif // !defined RigidTransformation2D_h
 
#undef RigidTransformation2D_RECURSES
#endif // else defined(RigidTransformation2D_RECURSES)