CDLR_naiverotation.h

 
#pragma once
 
#if defined(CDLR_NAIVEROTATION_RECURSES)
#error Recursive header files inclusion detected in RDSL.h
#else // defined(CDLR_NAIVEROTATION_RECURSES)
#define CDLR_NAIVEROTATION_RECURSES
 
#if !defined CDLR_NAIVEROTATION_h
#define CDLR_NAIVEROTATION_h
 
#include "DGtal/base/Common.h"
#include <DGtal/images/RigidTransformation2D.h>
#include "PointUtils.h"
#include "DigitizedReflection.h"
 
namespace DGtal {
 
 
    template < typename TSpace, typename TInputValue = typename TSpace::Point, typename TOutputValue = typename TSpace::Point>
    struct CDLR_naiverotation {
 
        inline int X(int y, const double a, const double b, const int k) const {
            return std::ceil((2.0*k-1)/2.0 - (a/b)*(y)); // a = sin(theta) ; b=cos(theta)
        }
 
        TOutputValue reflect(const double angle, TOutputValue center, const TInputValue& p ) const{
            double a = std::sin(angle/2.0);
            double b = std::cos(angle/2.0);
            TOutputValue pcentered = p;
 
            int k = std::floor(pcentered[0] + (a/b)*pcentered[1] + 0.5);
 
            TOutputValue X1 = TOutputValue(X(std::ceil(a*b*k),a,b,k),std::ceil(a*b*k));
            TOutputValue X2 = TOutputValue(X(std::floor(a*b*k),a,b,k),std::floor(a*b*k));
 
            const double line2 = a*X1[0]-b*X1[1];
            if(line2<b/2 && line2 >(-b/2)){
                return TOutputValue(X(2*X1[1]-pcentered[1],a,b,k),2*X1[1]-pcentered[1]);
            }else{
                const double line3 = a*X2[0]-b*X2[1];
                if(line3<b/2 && line3 >(-b/2)){
                    return TOutputValue(X(2*X2[1]-pcentered[1],a,b,k),2*X2[1]-pcentered[1]);
                }
                else{
                    return TOutputValue(X(X1[1]+X2[1]-pcentered[1],a,b,k),X1[1]+X2[1]-pcentered[1]);
                }
            }
 
 
        }
 
 
 
 
        CDLR_naiverotation( double ang=0., TOutputValue ptCenter=TOutputValue(0,0), double starting_angle =0. ):my_angle(ang),my_center(ptCenter),my_startingAngle(starting_angle) {
        }
 
        inline double    angle() const{return my_angle;};
 
        inline double    startingAngle() const{return my_startingAngle;};
 
        inline void   set_angle(const double new_angle){my_angle=new_angle;}
 
        inline void  set_startingAngle(const double new_startingAngle){my_startingAngle=new_startingAngle;}
 
 
 
 
        inline TOutputValue  center() const{return my_center;};
        inline TOutputValue& center(){return my_center;};
 
        TOutputValue rotate( const TInputValue& p ) const {
            return reflect(my_startingAngle + my_angle, my_center,
                                                              reflect(
                                                                  my_startingAngle, my_center, p));
        }
        TOutputValue operator()( const TInputValue& p ) const {
            return rotate(p);
        }
 
 
 
 
    protected:
        double   my_angle;
        double my_startingAngle;
 
        TOutputValue my_center;
 
 
    };
 
}
 
 
 
#endif //CDLR_NAIVEROTATION
#undef CDLR_NAIVEROTATION_RECURSES
#endif // else defined(CDLR_NAIVEROTATION_RECURSES)