CDLR.h

 
#pragma once
 
#if defined(CDLR_RECURSES)
#error Recursive header files inclusion detected in CDLR.h
#else // defined(CDLR_RECURSES)
#define CDLR_RECURSES
 
#if !defined CDLR_h
#define CDLR_h
 
#include "DGtal/base/Common.h"
#include <DGtal/images/RigidTransformation2D.h>
#include "CDLR_naiverotation.h"
#include "DigitizedReflection.h"
#include "Policy.h"
namespace DGtal {
 
    template < typename TSpace, typename TInputValue = typename TSpace::Point, typename TOutputValue = typename TSpace::Point>
    class CDLR {
    public:
        CDLR( double ang, TOutputValue ptCenter, std::shared_ptr<Policy<TSpace,HyperRectDomain< TSpace>,CDLR_naiverotation<TSpace>>> policy  );
 
        inline double    angle() const{return my_angle;};
        inline void   set_angle(const double new_angle) {
            my_angle=new_angle;
            my_naive_rdlr_rotation.set_angle(new_angle);
            dslSolver(new_angle,my_center);
        }
 
        void dslSolver(double ang, TOutputValue ptCenter);
 
 
 
        inline TOutputValue  center() const{return my_center;};
        inline TOutputValue& center(){return my_center;};
 
        TOutputValue rotate( const TInputValue& p ) const;
        TOutputValue operator()( const TInputValue& p ) const;
 
        template<typename Img>
        Img rotateImage(Img img) const;
 
        std::string tostring() const {
            return {"CDLR"};
        }
 
    protected:
        double   my_angle;
        TOutputValue my_center;
 
 
 
        CDLR_naiverotation<TSpace,TInputValue,TOutputValue> my_naive_rdlr_rotation;
        std::shared_ptr<Policy<TSpace,HyperRectDomain< TSpace>,CDLR_naiverotation<TSpace>>> my_policy;
 
    private:
        double a;
        double b;
        double my_minAngle;
    };
 
    template<typename TSpace, typename TInputValue, typename TOutputValue>
    CDLR<TSpace,TInputValue,TOutputValue>::CDLR( const double ang, const TOutputValue ptCenter, std::shared_ptr<Policy<TSpace,HyperRectDomain< TSpace>,CDLR_naiverotation<TSpace>>> policy ):my_angle(ang),my_center(ptCenter),my_naive_rdlr_rotation(ang,ptCenter,0.),my_policy(policy){
        dslSolver(ang,ptCenter);
    }
 
    template<typename TSpace, typename TInputValue, typename TOutputValue>
    void CDLR<TSpace, TInputValue, TOutputValue>::dslSolver(double ang, TOutputValue ptCenter) {
 
        a = std::sin(ang/2.0);
        b = std::cos(ang/2.0);
 
        TInputValue origin(0,0);
        DGtal::functors::ForwardRigidTransformation2D<TSpace,TInputValue,DGtal::SpaceND< 2, DGtal::int32_t >::RealPoint,DGtal::functors::Identity> euclideanRot(my_center,my_angle,origin);
 
        double errorMinAlpha = 200.*200;
        int N = 200;
 
        // create the domain
        TOutputValue A(0,0);
        TOutputValue B(1000,1000);
        HyperRectDomain<TSpace> my_domain(A,B);
 
 
        std::vector<double> mix_errors;
        std::vector<double> angles;
        for(int k=0;k<N;++k){
            double alphaCourant = -M_PI_2 + (k*M_PI_2)/N;
            angles.push_back(alphaCourant);
 
            // compute both reflections and get both the Linf and Lcontinuity errors
            std::vector<double> linf_per_image;
            my_naive_rdlr_rotation.set_startingAngle(alphaCourant);
            double error = my_policy->evaluate(my_domain,my_naive_rdlr_rotation,my_angle,my_center);
            mix_errors.push_back(error);
        }
        for(int idxImages = 0 ; idxImages < mix_errors.size() ; idxImages++) {
            if(mix_errors[idxImages] < errorMinAlpha) {
                errorMinAlpha = mix_errors[idxImages];
                my_minAngle = angles[idxImages];
            }
        }
    }
 
 
    template<typename TSpace, typename TInputValue, typename TOutputValue>
    TOutputValue CDLR<TSpace,TInputValue,TOutputValue>::rotate( const TInputValue& p ) const{
        return this->operator()(p);
    }
 
 
 
 
 
 
 
    template<typename TSpace, typename TInputValue, typename TOutputValue>
    TOutputValue CDLR<TSpace,TInputValue,TOutputValue>::operator()( const TInputValue& p ) const{
        return my_naive_rdlr_rotation.reflect(my_minAngle+(my_angle),my_center,my_naive_rdlr_rotation.reflect(my_minAngle,my_center,p-my_center))+my_center;
    }
 
 
    template<typename TSpace, typename TInputValue, typename TOutputValue>
    template<typename TImage>
    TImage CDLR<TSpace,TInputValue,TOutputValue>::rotateImage( const TImage img ) const{
        typedef typename TImage::Domain TDomain;
        typedef DGtal::functors::DomainRigidTransformation2D < typename TImage::Domain, DGtal::CDLR<TSpace>> MyDomainTransformer;
        typedef std::pair < typename TSpace::Point, typename TSpace::Point > Bounds;
 
        typename TSpace::Point bottomLeft(-2,-2);
        typename TSpace::Point topRight(2,2);
        MyDomainTransformer domainTransformer ( *this );
        Bounds bounds = domainTransformer ( img.domain() );
        TDomain transformedDomain ( bounds.first+bottomLeft, bounds.second+topRight );
        TImage rotatedImage ( transformedDomain );
 
        for (typename TDomain::ConstIterator it = img.domain().begin(); it != img.domain().end(); ++it )
        {
            rotatedImage.setValue((*this)(*it),img(*it));
        }
        return rotatedImage;
    }
 
 
}
 
 
#endif //CDLR
#undef CDLR_RECURSES
#endif // else defined(CDLR_RECURSES)