#include <DGtal/images/bijectiveRotations/NBijectiveReflectionGenerator.h>

Inheritance diagram for DGtal::NBijectiveGenerator< TSpace, TInputValue >:

Public Member Functions
	NBijectiveGenerator (const size_t km)

std::vector< std::pair< std::vector< int >, GAVector< TSpace > > >	composeBijectiveReflections (std::vector< std::pair< std::vector< int >, GAVector< TSpace >>> &Avector)
	compose bijective digitized reflections More...

bool	sameBijectiveComposition (const std::pair< std::vector< int >, GAVector< TSpace >> &b1, const std::pair< std::vector< int >, GAVector< TSpace >> &b2) const
	predicate to compare two composition of bijective reflections More...

std::vector< std::pair< std::vector< GAVector< TSpace > >, GAVector< TSpace > > >	vecBijNormals_index_2_GAVector (const std::vector< std::pair< std::vector< int >, GAVector< TSpace >>> &vecBijNormalsIndex)

std::vector< std::pair< std::vector< int >, GAVector< TSpace > > >	n_bijectiveReflections_get_NormalVectorsAngles (size_t n)
	generate all n =2,4 reflection composition More...

void	displayNormalVectorsAndAngles (const std::vector< std::pair< std::vector< int >, GAVector< TSpace >>> &vecBijNormals)

std::vector< Reflection< TSpace > >	getGAVectorFromIndex (const std::vector< int > &indices) const
	getter function used in predicate More...

void	writeBijectiveVectors (const std::string &fileName, const std::vector< std::pair< std::vector< int >, GAVector< TSpace >>> &vecBijNormals)

void	getKNearestBijectiveComposition (std::vector< std::pair< std::vector< GAVector< TSpace >>, GAVector< TSpace >>> &vecBijNormals, typename std::vector< std::pair< std::vector< GAVector< TSpace >>, GAVector< TSpace >>>::iterator &lowerBound, typename std::vector< std::pair< std::vector< GAVector< TSpace >>, GAVector< TSpace >>>::iterator &upperBound, const int K, const double targetAngle)

Data Fields
size_t	kmax

std::vector< GAVector< TSpace > >	BijectiveVectors

Detailed Description

template<typename TSpace, typename TInputValue = typename TSpace::RealPoint>
struct DGtal::NBijectiveGenerator< TSpace, TInputValue >

Definition at line 56 of file NBijectiveReflectionGenerator.h.

Constructor & Destructor Documentation

◆ NBijectiveGenerator()

template<typename TSpace , typename TInputValue = typename TSpace::RealPoint>

DGtal::NBijectiveGenerator< TSpace, TInputValue >::NBijectiveGenerator ( const size_t km )

inlineexplicit

Definition at line 58 of file NBijectiveReflectionGenerator.h.

                                                      :kmax(km){
             for(int k=0; k<kmax; k++){
                 int x_kpp_k = (k+1);
                 int x_k_kpp = (k);
                 int x_1_2kpp = (1);
                 int x_2kpp_1 = (2*k+1);
  
  
                 int y_kpp_k = (k);
                 int y_k_kpp = (k+1);
                 int y_1_2kpp = (2*k+1);
                 int y_2kpp_1 = (1);
  
  
                 int x_kpp_k_m = (k+1);
                 int x_k_kpp_m = (k);
                 int x_1_2kpp_m = (1);
                 int x_2kpp_1_m = (2*k+1);
  
  
                 int y_kpp_k_m = -(k);
                 int y_k_kpp_m = -(k+1);
                 int y_1_2kpp_m = -(2*k+1);
                 int y_2kpp_1_m = -(1);
  
                 BijectiveVectors.push_back(GAVector<TSpace>({x_kpp_k,y_kpp_k}));
                 BijectiveVectors.push_back(GAVector<TSpace>({x_k_kpp,y_k_kpp}));
                 BijectiveVectors.push_back(GAVector<TSpace>({x_1_2kpp,y_1_2kpp}));
                 BijectiveVectors.push_back(GAVector<TSpace>({x_2kpp_1,y_2kpp_1}));
                 BijectiveVectors.push_back(GAVector<TSpace>({x_kpp_k_m,y_kpp_k_m}));
                 BijectiveVectors.push_back(GAVector<TSpace>({x_k_kpp_m,y_k_kpp_m}));
                 BijectiveVectors.push_back(GAVector<TSpace>({x_1_2kpp_m,y_1_2kpp_m}));
                 BijectiveVectors.push_back(GAVector<TSpace>({x_2kpp_1_m,y_2kpp_1_m}));
             }
         }

References DGtal::NBijectiveGenerator< TSpace, TInputValue >::BijectiveVectors, and DGtal::NBijectiveGenerator< TSpace, TInputValue >::kmax.

Member Function Documentation

◆ composeBijectiveReflections()

template<typename TSpace , typename TInputValue = typename TSpace::RealPoint>

std::vector<std::pair<std::vector<int>,GAVector<TSpace> > > DGtal::NBijectiveGenerator< TSpace, TInputValue >::composeBijectiveReflections ( std::vector< std::pair< std::vector< int >, GAVector< TSpace >>> & Avector )

inline

compose bijective digitized reflections

Parameters

Avector the composition of bijective reflection

Returns: vector of indices of bijective digitized reflections

Definition at line 99 of file NBijectiveReflectionGenerator.h.

                                                                            {
             std::vector<std::pair<std::vector<int>,GAVector<TSpace>>> result;
             result.reserve(Avector.size()*BijectiveVectors.size());
  
             for(std::pair<std::vector<int>,GAVector<TSpace>> normalVectorsAndResult : Avector){
                 std::pair<std::vector<int>,GAVector<TSpace>> resultatCourant = normalVectorsAndResult;
                 for(size_t indexB = 0 ; indexB<BijectiveVectors.size();++indexB){
                     GAVector<TSpace> outVec = normalVectorsAndResult.second*BijectiveVectors[indexB];
                     if(outVec.my_gavec[0] <0){
                         // resultatCourant.first.insert(resultatCourant.first.begin(),indexB);
                         // resultatCourant.second = outVec*-1;
                     }else{
                         resultatCourant.first.push_back(indexB);
                         resultatCourant.second = outVec;
                         result.push_back(resultatCourant);
                         resultatCourant=normalVectorsAndResult;
                     }
  
                 }
             }
             // unique
             std::sort(result.begin(), result.end(), [](const std::pair<std::vector<int>,GAVector<TSpace>>& b1, const std::pair<std::vector<int>,GAVector<TSpace>>& b2) {
                     return b1.second < b2.second;});
  
  
             return result;
         }

References DGtal::NBijectiveGenerator< TSpace, TInputValue >::BijectiveVectors, and DGtal::GAVector< TSpace, TInputValue >::my_gavec.

Referenced by DGtal::NBijectiveGenerator< TSpace, TInputValue >::n_bijectiveReflections_get_NormalVectorsAngles().

◆ displayNormalVectorsAndAngles()

template<typename TSpace , typename TInputValue = typename TSpace::RealPoint>

void DGtal::NBijectiveGenerator< TSpace, TInputValue >::displayNormalVectorsAndAngles ( const std::vector< std::pair< std::vector< int >, GAVector< TSpace >>> & vecBijNormals )

inline

Definition at line 208 of file NBijectiveReflectionGenerator.h.

                                                                                                                     {
             for(size_t i =0;i<vecBijNormals.size();++i){
                 auto currentIndicesNormalVector=vecBijNormals[i].first;
                 GAVector<TSpace> finalNormalVec = vecBijNormals[i].second;
  
                 if(2.0*finalNormalVec.angleToXAxis() < M_PI_4/8){
                 std::cout << "m=[";
                 for(int indexBijective : currentIndicesNormalVector){
                     std::cout <<"("<<BijectiveVectors[indexBijective].x<<","<<BijectiveVectors[indexBijective].y<<"),";
                 }
                 std::cout << "], angle="<<2.0*finalNormalVec.angleToXAxis()<<std::endl;
                 }
             }
         }

References DGtal::GAVector< TSpace, TInputValue >::angleToXAxis(), and DGtal::NBijectiveGenerator< TSpace, TInputValue >::BijectiveVectors.

◆ getGAVectorFromIndex()

template<typename TSpace , typename TInputValue = typename TSpace::RealPoint>

std::vector<Reflection<TSpace> > DGtal::NBijectiveGenerator< TSpace, TInputValue >::getGAVectorFromIndex ( const std::vector< int > & indices ) const

inline

getter function used in predicate

Definition at line 224 of file NBijectiveReflectionGenerator.h.

                                                                                                {
             std::vector<Reflection<TSpace>> normals;
             for(auto i : indices){
                 Reflection<TSpace> refi(BijectiveVectors[i]);
                 normals.push_back(refi);
             }
             return normals;
         }

References DGtal::NBijectiveGenerator< TSpace, TInputValue >::BijectiveVectors.

Referenced by DGtal::NBijectiveGenerator< TSpace, TInputValue >::sameBijectiveComposition().

◆ getKNearestBijectiveComposition()

template<typename TSpace , typename TInputValue = typename TSpace::RealPoint>

void DGtal::NBijectiveGenerator< TSpace, TInputValue >::getKNearestBijectiveComposition	(	std::vector< std::pair< std::vector< GAVector< TSpace >>, GAVector< TSpace >>> &	vecBijNormals,
		typename std::vector< std::pair< std::vector< GAVector< TSpace >>, GAVector< TSpace >>>::iterator &	lowerBound,
		typename std::vector< std::pair< std::vector< GAVector< TSpace >>, GAVector< TSpace >>>::iterator &	upperBound,
		const int	K,
		const double	targetAngle
	)

inline

Definition at line 247 of file NBijectiveReflectionGenerator.h.

         {
             // find the index of the closest angle
             int i = std::lower_bound(vecBijNormals.begin(), vecBijNormals.end(), targetAngle,[](const std::pair<std::vector<GAVector<TSpace>>,GAVector<TSpace>>& b1, const double b2) {
                         return 2.0*b1.second.angleToXAxis() < b2;
                     }) - vecBijNormals.begin();
  
             int leftCompo=i-1;
             int rightCompo = i;
  
             // assume that K<vecBijNormals.size()
             int numberElements=0;
             while(numberElements<K){
                 if (leftCompo < 0 || (rightCompo < vecBijNormals.size() &&
                     fabs(2*vecBijNormals[leftCompo].second.angleToXAxis() - targetAngle) > fabs(2*vecBijNormals[rightCompo].second.angleToXAxis() - targetAngle))) {
                     rightCompo++;
                 }
                 else {
                     leftCompo--;
                 }
                 numberElements++;
             }
             lowerBound=vecBijNormals.begin()+leftCompo;
             upperBound=vecBijNormals.begin()+rightCompo;
  
         }

References K.

Referenced by DGtal::CBDRSolver< TSpace, TDomain >::solve().

◆ n_bijectiveReflections_get_NormalVectorsAngles()

template<typename TSpace , typename TInputValue = typename TSpace::RealPoint>

std::vector<std::pair<std::vector<int>,GAVector<TSpace> > > DGtal::NBijectiveGenerator< TSpace, TInputValue >::n_bijectiveReflections_get_NormalVectorsAngles ( size_t n )

inline

generate all n =2,4 reflection composition

Parameters

n	number of reflection to compose

interpret as the composition of 4 vectors : 3 bijective and 1 trivial bijective reflection

Definition at line 176 of file NBijectiveReflectionGenerator.h.

         {
             std::vector<std::pair<std::vector<int>,GAVector<TSpace>>> vecBijNormals;
             for(int i =0 ; i< BijectiveVectors.size() ; ++i){
                 vecBijNormals.push_back({{i},BijectiveVectors[i]});
             }
             if(n>3) {
                 --n;
             }
  
             for ( size_t j = 1; j < n; ++j )
             {
                 vecBijNormals = composeBijectiveReflections( vecBijNormals);
  
                 // remove duplicates with predicate defined below
                 auto last = std::unique(vecBijNormals.begin(),vecBijNormals.end(),[this](const std::pair<std::vector<int>,GAVector<TSpace>>& b1, const std::pair<std::vector<int>,GAVector<TSpace>>& b2) {
                 return sameBijectiveComposition(b1, b2);});
                 vecBijNormals.erase(last,vecBijNormals.end());
             }
             if(n==3){
                 for(auto& pairIndicesGAVec : vecBijNormals)
                     pairIndicesGAVec.first.insert(pairIndicesGAVec.first.begin(),0);
             }
  
             std::sort(vecBijNormals.begin(), vecBijNormals.end(), [](const std::pair<std::vector<int>,GAVector<TSpace>>& b1, const std::pair<std::vector<int>,GAVector<TSpace>>& b2) {
                       return b1.second.angleToXAxis() < b2.second.angleToXAxis();});
  
  
             return vecBijNormals;
         }

References DGtal::NBijectiveGenerator< TSpace, TInputValue >::BijectiveVectors, and DGtal::NBijectiveGenerator< TSpace, TInputValue >::composeBijectiveReflections().

◆ sameBijectiveComposition()

template<typename TSpace , typename TInputValue = typename TSpace::RealPoint>

bool DGtal::NBijectiveGenerator< TSpace, TInputValue >::sameBijectiveComposition	(	const std::pair< std::vector< int >, GAVector< TSpace >> &	b1,
		const std::pair< std::vector< int >, GAVector< TSpace >> &	b2
	)		const

inline

predicate to compare two composition of bijective reflections

Parameters

b1	first pair of composition of bijective reflections
b2	second pair of composition of bijective reflections

Returns: composition leads to same error?

Definition at line 132 of file NBijectiveReflectionGenerator.h.

                                                                                                                                                    {
             // both reflections thanks to reflection composer
             if(fabs(b1.second.angleToXAxis()-b1.second.angleToXAxis())>1e-4){
                 return false;
             }
             std::vector<Reflection<TSpace,TInputValue>> normals1 = getGAVectorFromIndex(b1.first);
             std::vector<Reflection<TSpace,TInputValue>> normals2 = getGAVectorFromIndex(b2.first);
             CBDR_naiverotation<TSpace,TInputValue> reflectionsCompose1(normals1);
             CBDR_naiverotation<TSpace,TInputValue> reflectionsCompose2(normals2);
  
             typename TSpace::Point zeroPt(0,0);
  
             for(int i =0 ; i<100;++i){
                 for(int j =0 ; j<100;++j){
                     double x=i-50;
                     double y=j-50;
                     typename TSpace::RealPoint pointCourant = {x,y};
                     typename TSpace::Point out1 = reflectionsCompose1(pointCourant);
                     typename TSpace::Point out2 = reflectionsCompose2(pointCourant);
                     if((out1-out2)!= zeroPt  ){
                         return false;
                     }
                 }
             }
             return true;
         }

References DGtal::NBijectiveGenerator< TSpace, TInputValue >::getGAVectorFromIndex().

◆ vecBijNormals_index_2_GAVector()

template<typename TSpace , typename TInputValue = typename TSpace::RealPoint>

std::vector<std::pair<std::vector<GAVector<TSpace> >,GAVector<TSpace> > > DGtal::NBijectiveGenerator< TSpace, TInputValue >::vecBijNormals_index_2_GAVector ( const std::vector< std::pair< std::vector< int >, GAVector< TSpace >>> & vecBijNormalsIndex )

inline

Definition at line 160 of file NBijectiveReflectionGenerator.h.

                                                                                                                                                                                        {
             std::vector<std::pair<std::vector<GAVector<TSpace>>,GAVector<TSpace>>> vecBijNormalsIndex_GAVector;
             for(std::pair<std::vector<int>,GAVector<TSpace>> pairIndexGAVector : vecBijNormalsIndex) {
                 std::vector<GAVector<TSpace>> resGavec;
  
                 for(int index : pairIndexGAVector.first) {
                     resGavec.push_back(BijectiveVectors[index]);
                 }
                 vecBijNormalsIndex_GAVector.push_back({resGavec,pairIndexGAVector.second});
             }
             return vecBijNormalsIndex_GAVector;
  
         }

References DGtal::NBijectiveGenerator< TSpace, TInputValue >::BijectiveVectors.

◆ writeBijectiveVectors()

template<typename TSpace , typename TInputValue = typename TSpace::RealPoint>

void DGtal::NBijectiveGenerator< TSpace, TInputValue >::writeBijectiveVectors	(	const std::string &	fileName,
		const std::vector< std::pair< std::vector< int >, GAVector< TSpace >>> &	vecBijNormals
	)

inline

Definition at line 233 of file NBijectiveReflectionGenerator.h.

                                                                                                                                        {
             std::ofstream file(fileName);
  
             file << "kmax="<<kmax<<std::endl;
  
             for(size_t i = 0;i<vecBijNormals.size();++i){
                 std::vector<int> gaNormalVecs = vecBijNormals[i].first;
                 for(auto index :gaNormalVecs)
                     file << "("<< BijectiveVectors[index].my_gavec[0] << ","<<BijectiveVectors[index].my_gavec[1]<<"),";
                 file  << "("<<vecBijNormals[i].second.my_gavec[0]<<"," <<vecBijNormals[i].second.my_gavec[1]<<")"<<std::endl;
             }
             file.close();
         }