CBDR.h

Go to the documentation of this file.

 
#pragma once
 
#if defined(CBDR_RECURSES)
#error Recursive header files inclusion detected in CBDR.h
#else // defined(CBDR_RECURSES)
#define CBDR_RECURSES
 
#if !defined CBDR_h
#define CBDR_h
 
// Inclusions
#include "GAVector.h"
#include "CBDRSolver.h"
#include "CBDRFastSolver.h"
 
#include "Rotationtables.h"
#include "NBijectiveReflectionGenerator.h"
 
 
namespace DGtal {
    template<typename TSpace, typename TInputValue = typename TSpace::RealPoint, typename TOutputValue = typename TSpace::Point>
struct CBDR {
        BOOST_CONCEPT_ASSERT(( concepts::CSpace<TSpace> ));
        BOOST_STATIC_ASSERT(( TSpace::dimension == 2 ));
        BOOST_STATIC_ASSERT(( TOutputValue::dimension == 2 ));
        BOOST_STATIC_ASSERT(( TInputValue::dimension == 2 ));
 
 
        typedef Reflection<TSpace,TInputValue> DigitizedReflection;
        typedef std::vector<std::pair<std::vector<GAVector<TSpace>>,GAVector<TSpace>>> BijectiveSearchTree;
 
 
        CBDR(const double theta,const typename TSpace::Point center,const size_t nbreflect,const size_t km, std::shared_ptr<Policy<TSpace,HyperRectDomain< TSpace>,CBDR_naiverotation<TSpace>>> policy,
            const bool precompute=true, const bool fast =true ):nbijectiveGen(km),my_domain(typename TSpace::Point(0,0),typename TSpace::Point(100,100)),my_angle(theta),my_center(center),nbReflections(nbreflect),kmax(km),my_policy(policy),
                        usePrecomputedTable(precompute),useFastTable(fast),N(100),my_cbdr(initCBDRVec()) {
        }
 
 
 
 
        // whenever fast is set, load the table that stores for each angle the optimised set of bijective reflections
        std::shared_ptr<CBDR_naiverotation<TSpace>> initCBDRVec() {
            if(useFastTable) {
                std::cout << "use fast table"<<std::endl;
                std::string fastTableName=("CBDROptimisedTable_"+std::to_string(nbReflections)+"_"+std::to_string(kmax)+".txt");
                struct stat buffer;
                fastTableFound = (stat (fastTableName.c_str(), &buffer) == 0);
                if(fastTableFound) {
                        fastCBDRTable=loadFastOptimisedTable(fastTableName);
                }else {
                        initcbdr_loadBijectiveReflectionSearchTree(my_domain);
                        fastCBDRTable=initFastPrecomputationTable(my_domain,nbijectiveGen,vecBijectiveSearchTree);
                }
                CBDRFastSolver<TSpace,HyperRectDomain<TSpace>> cbdrFastSolver(fastCBDRTable,my_angle,my_center,kmax);
                return std::make_shared<CBDR_naiverotation<TSpace>>(cbdrFastSolver.solve());
            }else{
                initcbdr_loadBijectiveReflectionSearchTree(my_domain);
                CBDRSolver<TSpace,HyperRectDomain<TSpace>>  cbdrSolver(my_angle, my_center,kmax,N);
                return std::make_shared<CBDR_naiverotation<TSpace>>(cbdrSolver.solve(my_domain,nbijectiveGen, vecBijectiveSearchTree,*my_policy));
            }
        }
 
        void set_angle(const double newAngle) {
            my_angle = newAngle;
            if(fastTableFound) {
                // does not use the policy since the table is already stored.
                CBDRFastSolver<TSpace,HyperRectDomain<TSpace>> cbdrFastSolver(fastCBDRTable,my_angle,my_center,kmax);
                my_cbdr=std::make_shared<CBDR_naiverotation<TSpace>>(cbdrFastSolver.solve());
            }else {
                CBDRSolver<TSpace,HyperRectDomain<TSpace>>  cbdrSolver(my_angle, my_center,kmax,N);
                my_cbdr=std::make_shared<CBDR_naiverotation<TSpace>>(cbdrSolver.solve(my_domain,nbijectiveGen, vecBijectiveSearchTree,*my_policy));
            }
        }
 
        void setPolicy(const std::shared_ptr<Policy<TSpace,HyperRectDomain< TSpace>,CBDR_naiverotation<TSpace>>>& newPolicy) {
            // need to search again for the precomputed tables
            my_policy = newPolicy;
            my_cbdr = initCBDRVec();
        }
 
 
        TOutputValue operator()( const TInputValue & aInput ) const
        {
            return my_cbdr->operator()(aInput-my_center)+my_center;
        }
 
        template<typename TImage>
        TImage rotateImage(TImage img) const {
            return my_cbdr->rotateImage(img);
        }
 
        std::string tostring() const {
            return {"CBDR"};
        }
 
        inline TOutputValue  center() const{return my_center;}
 
    public:
        NBijectiveGenerator<TSpace,TInputValue> nbijectiveGen;
        std::vector<BijectiveSearchTree> vecBijectiveSearchTree;
        HyperRectDomain<TSpace> my_domain;
 
        size_t kmax;
        size_t nbReflections;
        bool usePrecomputedTable;
        bool useFastTable;
        int N;
        double my_angle;
        TOutputValue my_center;
        std::shared_ptr<Policy<TSpace,HyperRectDomain< TSpace>,CBDR_naiverotation<TSpace>>> my_policy;
        std::vector<CBDR_naiverotation<TSpace,TInputValue>> fastCBDRTable;
        std::shared_ptr<CBDR_naiverotation<TSpace>> my_cbdr;
 
 
    private:
        bool fastTableFound;
 
        std::vector<CBDR_naiverotation<TSpace, TInputValue>> loadFastOptimisedTable(const std::string& fastTableName);
        void initcbdr_loadBijectiveReflectionSearchTree(const HyperRectDomain<TSpace>& my_domain);
        std::vector<CBDR_naiverotation<TSpace, TInputValue>> initFastPrecomputationTable(
                                         const HyperRectDomain<TSpace>& points,
                                         NBijectiveGenerator<TSpace>& nbijectiveVectors,
                                         std::vector<BijectiveSearchTree>& vecBijectiveSearchTree);
    };
 
 
    template<typename TSpace, typename TInputValue, typename TOutputValue>
    std::vector<CBDR_naiverotation<TSpace, TInputValue>> CBDR<TSpace, TInputValue, TOutputValue>::loadFastOptimisedTable(const std::string &fastTableName) {
        auto vecTable = DGtal::functions::loadFastCBDRTable<DGtal::SpaceND< 2, DGtal::int32_t >>(fastTableName);
        std::vector<CBDR_naiverotation<TSpace, TInputValue>> fastCBDRtab(vecTable.size());
        std::transform(vecTable.begin(),vecTable.end(), fastCBDRtab.begin(), [](std::tuple<std::vector<DGtal::GAVector<DGtal::SpaceND< 2, DGtal::int32_t >>>,double,double>& x) {
             return DGtal::CBDR_naiverotation<DGtal::SpaceND< 2, DGtal::int32_t >>(std::get<0>(x));
        });
        return fastCBDRtab;
    }
 
    template<typename TSpace, typename TInputValue, typename TOutputValue>
    void CBDR<TSpace, TInputValue, TOutputValue>::initcbdr_loadBijectiveReflectionSearchTree(const HyperRectDomain<TSpace>& my_domain) {
 
        for(size_t nbReflec = 2 ; nbReflec <= nbReflections ; nbReflec+=2) {
            BijectiveSearchTree vecBijNormals;
            std::string tableName("CBDRTable_"+std::to_string(nbReflec)+"_"+std::to_string(kmax)+".txt");
            // check that the file exists when usePrecomputedTable is set to true
            if(usePrecomputedTable ) {
                struct stat buffer;
                bool exists = (stat (tableName.c_str(), &buffer) == 0);
                if(!exists) {
                    usePrecomputedTable=false;
                }
            }
 
            if(usePrecomputedTable){
                std::cout << "loading precomputed table ..."<<std::endl;
                vecBijNormals = functions::loadBijectiveRotationTable<TSpace,TInputValue>(tableName,nbReflec,kmax);
            } else {
                std::cout << "does not use precomputed table"<<std::endl;
                auto tableIntVecBijNormals = nbijectiveGen.n_bijectiveReflections_get_NormalVectorsAngles(nbReflec);
                nbijectiveGen.writeBijectiveVectors("CBDRTable_"+std::to_string(nbReflec)+"_"+std::to_string(kmax)+".txt",tableIntVecBijNormals );
                vecBijNormals = nbijectiveGen.vecBijNormals_index_2_GAVector(tableIntVecBijNormals);
            }
            vecBijectiveSearchTree.push_back(vecBijNormals);
        }
 
    }
 
    template<typename TSpace, typename TInputValue, typename TOutputValue>
    std::vector<CBDR_naiverotation<TSpace, TInputValue>> CBDR<TSpace, TInputValue, TOutputValue>::
    initFastPrecomputationTable(const HyperRectDomain<TSpace> &points, NBijectiveGenerator<TSpace> &nbijectiveVectors,
        std::vector<BijectiveSearchTree> &vecBijectiveSearchTree) {
        std::vector<CBDR_naiverotation<TSpace, TInputValue>> fastCBDRtab;
        auto Linf = std::make_shared<DGtal::LinfPolicy<TSpace,DGtal::HyperRectDomain<TSpace>,DGtal::CBDR_naiverotation<TSpace>>>();
        auto LContinuity = std::make_shared<DGtal::LcontinuityPolicy<TSpace,DGtal::HyperRectDomain<TSpace>,DGtal::CBDR_naiverotation<TSpace>>>();
 
        std::string tablefilename ="CBDROptimisedTable_"+std::to_string(nbReflections)+"_"+std::to_string(kmax)+".txt";
        std::ofstream file(tablefilename);
        for(int alpha = 0 ; alpha < 91; ++alpha) {
            double currentAngle = (alpha * M_PI) / 180.0;
            CBDRSolver<TSpace,HyperRectDomain<TSpace>>  cbdrsolv(currentAngle, my_center,kmax,N);
            std::vector<Reflection<TSpace>> bestReflections =cbdrsolv.solve(points,nbijectiveVectors,
                vecBijectiveSearchTree,*my_policy);
 
            CBDR_naiverotation<TSpace> currentRotation(bestReflections);
            fastCBDRtab.push_back(currentRotation);
 
            // display vector of reflections
            for(size_t i = 0 ; i<bestReflections.size() ; ++i) {
                if(i<bestReflections.size()-1)
                    file << bestReflections[i].normalVector.my_gavec << ",";
                else
                    file << bestReflections[i].normalVector.my_gavec;
            }
            file << ";"<<Linf->evaluate(points,currentRotation,currentAngle,my_center);
            file << ";"<<LContinuity->evaluate(points,currentRotation,currentAngle,my_center);
            file << std::endl;
 
        }
        file.close();
        std::cout << "table written !"<<std::endl;
        fastTableFound=true;
        return fastCBDRtab;
    }
 
 
}
 
 
 
 
#endif //CBDR
#undef CBDR_RECURSES
#endif // else defined(CBDR_RECURSES)