testAffineGeometry.cpp File Reference

#include <iostream>
#include <vector>
#include <algorithm>
#include <random>
#include "DGtal/base/Common.h"
#include "DGtal/kernel/SpaceND.h"
#include "DGtal/geometry/tools/AffineGeometry.h"
#include "DGtal/geometry/tools/AffineBasis.h"
#include "DGtalCatch.h"

Include dependency graph for testAffineGeometry.cpp:

Go to the source code of this file.

Functions
std::mt19937	g (rd())
std::uniform_real_distribution< double >	uniform (-1.0, 1.0)
template<typename RealPoint>
void	perturb (RealPoint &x, double perturbation)
template<typename RealPoint>
void	perturb (std::vector< RealPoint > &X, double perturbation)
template<typename Point>
std::vector< Point >	makeRandomVectors (int nb, int amplitude)
template<typename Point>
std::vector< Point >	makeRandomLatticePointsFromDirVectors (int nb, const vector< Point > &V)
template<typename Point>
std::vector< Point >	makeRandomRealPointsFromDirVectors (int nb, const vector< Point > &V)
	SCENARIO ("AffineGeometry< Point2i > unit tests", "[affine_subset][2i]")
	SCENARIO ("AffineGeometry< Point2d > unit tests", "[affine_subset][2d]")
	SCENARIO ("AffineGeometry< Point2i > orthogonal tests", "[orthogonal_vector][2i]")
	SCENARIO ("AffineGeometry< Point3i > unit tests", "[affine_subset][3i]")
	SCENARIO ("AffineGeometry< Point3i > orthogonal tests", "[orthogonal_vector][3i]")
	SCENARIO ("AffineGeometry< Point4i > unit tests", "[affine_subset][4i]")
	SCENARIO ("AffineGeometry< Point4d > unit tests", "[affine_subset][4d]")
	SCENARIO ("AffineGeometry< Point4i > orthogonal tests", "[orthogonal_vector][4i]")
	SCENARIO ("AffineGeometry< Z3 > bug", "[affine_geom][3d]")
	SCENARIO ("AffineGeometry< Z3 > orthogonality", "[affine_geom][3d]")

Variables
std::random_device	rd

Detailed Description

This program is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Author

Jacques-Olivier Lachaud (jacqu.nosp@m.es-o.nosp@m.livie.nosp@m.r.la.nosp@m.chaud.nosp@m.@uni.nosp@m.v-sav.nosp@m.oie..nosp@m.fr ) Laboratory of Mathematics (CNRS, UMR 5127), University of Savoie, France

Date

2025/08/24

Functions for testing class AffineGeometry.

This file is part of the DGtal library.

Definition in file testAffineGeometry.cpp.

Function Documentation

g()

std::mt19937 g

(

rd()

)

References g(), and rd.

makeRandomLatticePointsFromDirVectors()

template<typename Point>

std::vector< Point > makeRandomLatticePointsFromDirVectors	(	int	nb,
		const vector< Point > &	V )

Definition at line 79 of file testAffineGeometry.cpp.

{
  std::uniform_int_distribution<int> U(-10, 10);
  vector< Point > P;
  int n = V[0].size();
  int m = V.size();
  Point A;
  for ( auto i = 0; i < n; i++ )
    A[ i ] = U( g );
  P.push_back( A );
  for ( auto k = 0; k < nb; k++ )
    {
      Point B = A;
      for ( auto i = 0; i < m; i++ )
        {
          int l = U( g );
          B += l * V[ i ];
        }
      P.push_back( B );
    }
  std::shuffle( P.begin(), P.end(), g );
  return P;
}

References g(), and makeRandomLatticePointsFromDirVectors().

makeRandomRealPointsFromDirVectors()

template<typename Point>

std::vector< Point > makeRandomRealPointsFromDirVectors	(	int	nb,
		const vector< Point > &	V )

Definition at line 105 of file testAffineGeometry.cpp.

{
  std::uniform_real_distribution<double> U(-1., 1.);
  vector< Point > P;
  int n = V[0].size();
  int m = V.size();
  Point A;
  for ( auto i = 0; i < n; i++ )
    A[ i ] = U( g );
  P.push_back( A );
  for ( auto k = 0; k < nb; k++ )
    {
      Point B = A;
      for ( auto i = 0; i < m; i++ )
        {
          double l = 5.* U( g );
          B += l * V[ i ];
        }
      P.push_back( B );
    }
  std::shuffle( P.begin(), P.end(), g );
  return P;
}

References g(), and makeRandomRealPointsFromDirVectors().

Referenced by makeRandomRealPointsFromDirVectors(), and SCENARIO().

makeRandomVectors()

template<typename Point>

std::vector< Point > makeRandomVectors	(	int	nb,
		int	amplitude )

Definition at line 63 of file testAffineGeometry.cpp.

{
  std::uniform_int_distribution<int> U(-amplitude, amplitude);
  std::vector< Point > P;
  for ( auto n = 0; n < nb; ++n )
    {
      Point A;
      for ( auto i = 0; i < Point::dimension; i++ )
        A[ i ] = U( g );
      P.push_back( A );
    }
  return P;
}

References g(), and makeRandomVectors().

perturb() [1/2]

template<typename RealPoint>

void perturb	(	RealPoint &	x,
		double	perturbation )

Definition at line 50 of file testAffineGeometry.cpp.

{
  for ( auto& c : x ) c += uniform( g ) * perturbation;
}

References g(), perturb(), and uniform().

Referenced by perturb(), perturb(), and SCENARIO().

perturb() [2/2]

template<typename RealPoint>

void perturb	(	std::vector< RealPoint > &	X,
		double	perturbation )

Definition at line 56 of file testAffineGeometry.cpp.

{
  for ( auto& x : X ) perturb( x, perturbation );
}

References perturb().

SCENARIO() [1/10]

SCENARIO	(	"AffineGeometry< Point2d > unit tests"	,
		""	[affine_subset][2d] )

Definition at line 159 of file testAffineGeometry.cpp.

{
  typedef SpaceND< 2, int >                Space;
  typedef Space::RealPoint                 Point;
  typedef AffineGeometry< Point >            Affine;
  GIVEN( "Given X = { (0,0), (-4,-1), (16,4), (-3,5), (7,3), (5, -2) } of affine dimension 2" ) {
    std::vector<Point> X
      = { Point(0,0), Point(-4,-1), Point(16,4), Point(-3,5), Point(7,3), Point(5, -2) };
    auto I = Affine::affineSubset( X );
    THEN( "It has an affine basis of 3 points [0,1,3]" ) {
      CAPTURE( I );
      REQUIRE( I.size() == 3 );
      REQUIRE( I[ 2 ] == 3 );
    }
  }
  GIVEN( "Given X = { (0,0), (-4,-1), (-8,-2), (8,2), (16,4), (200,50) } of affine dimension 1" ) {
    std::vector<Point> X
      = { Point(0,0), Point(-4,-1), Point(-8,-2), Point(8,2), Point(16,4), Point(200,50) };
    auto I = Affine::affineSubset( X );
    THEN( "It has an affine basis of 2 points [0,1]" ) {
      CAPTURE( I );
      REQUIRE( I.size() == 2 );
    }
  }
  GIVEN( "Given a perturbated X = { (0,0), (-4,-1), (16,4), (-3,5), (7,3), (5, -2) } of affine dimension 2 by U[-1e-4,1e-4]" ) {
    std::vector<Point> X
      = { Point(0,0), Point(-4,-1), Point(16,4), Point(-3,5), Point(7,3), Point(5, -2) };
    perturb( X, 1e-4 );
    auto I = Affine::affineSubset( X, 1e-12 );
    THEN( "It has an affine basis of 3 points [0,1,x]" ) {
      CAPTURE( I );
      REQUIRE( I.size() == 3 );
    }
  }
  GIVEN( "Given a perturbated X = { (0,0), (-4,-1), (-8,-2), (8,2), (16,4), (200,50) } of affine dimension 1 by U[-1e-4,1e-4]" ) {
    std::vector<Point> X
      = { Point(0,0), Point(-4,-1), Point(-8,-2), Point(8,2), Point(16,4), Point(200,50) };
    perturb( X, 1e-4 );
    auto I = Affine::affineSubset( X, 1e-12 );
    THEN( "It has an affine basis of 3 points [0,1,x]" ) {
      CAPTURE( I );
      REQUIRE( I.size() == 3 );
    }
  }
  GIVEN( "Given a perturbated X = { (0,0), (-4,-1), (-8,-2), (8,2), (16,4), (200,50) } of affine dimension 1 by U[-1e-11,1e-11]" ) {
    std::vector<Point> X
      = { Point(0,0), Point(-4,-1), Point(-8,-2), Point(8,2), Point(16,4), Point(200,50) };
    perturb( X, 1e-11 );
    auto I = Affine::affineSubset( X, 1e-7 );
    THEN( "It has an affine basis of 2 points [0,1] if tolerance is 1e-7" ) {
      CAPTURE( X );
      CAPTURE( I );
      REQUIRE( I.size() == 2 );
    }
  }
}

References CAPTURE(), GIVEN(), perturb(), REQUIRE(), and SCENARIO().

SCENARIO() [2/10]

SCENARIO	(	"AffineGeometry< Point2i > orthogonal tests"	,
		""	[orthogonal_vector][2i] )

Definition at line 216 of file testAffineGeometry.cpp.

{
  typedef SpaceND< 2, int >                Space;
  typedef Space::Point                     Point;
  typedef AffineGeometry< Point >          Affine;
  GIVEN( "Given basis B = { (7,3) } " ) {
    std::vector<Point> B = { Point(7,3) };
    Affine::completeBasis( B, true );
    THEN( "The complete basis has dimension 2" ) {
      CAPTURE( B );
      REQUIRE( B.size() == 2 );
    }
    THEN( "The last vector is non null and orthogonal to all the others" ) {
      CAPTURE( B.back() );
      REQUIRE( B.back().normInfinity() > 0 );
      REQUIRE( B.back().dot( B[ 0 ] ) == 0 );
    }
  }
}

References CAPTURE(), GIVEN(), REQUIRE(), and SCENARIO().

SCENARIO() [3/10]

SCENARIO	(	"AffineGeometry< Point2i > unit tests"	,
		""	[affine_subset][2i] )

Definition at line 133 of file testAffineGeometry.cpp.

{
  typedef SpaceND< 2, int >                Space;
  typedef Space::Point                     Point;
  typedef AffineGeometry< Point >            Affine;
  GIVEN( "Given X = { (0,0), (-4,-1), (16,4), (-3,5), (7,3), (5, -2) } of affine dimension 2" ) {
    std::vector<Point> X
      = { Point(0,0), Point(-4,-1), Point(16,4), Point(-3,5), Point(7,3), Point(5, -2) };
    auto I = Affine::affineSubset( X );
    THEN( "It has an affine basis of 3 points" ) {
      CAPTURE( I );
      REQUIRE( I.size() == 3 );
      REQUIRE( I[ 2 ] == 3 );
    }
  }
  GIVEN( "Given X = { (0,0), (-4,-1), (-8,-2), (8,2), (16,4), (200,50) } of affine dimension 1" ) {
    std::vector<Point> X
      = { Point(0,0), Point(-4,-1), Point(-8,-2), Point(8,2), Point(16,4), Point(200,50) };
    auto I = Affine::affineSubset( X );
    THEN( "It has an affine basis of 2 points" ) {
      CAPTURE( I );
      REQUIRE( I.size() == 2 );
    }
  }
}

References CAPTURE(), GIVEN(), REQUIRE(), and SCENARIO().

SCENARIO() [4/10]

SCENARIO	(	"AffineGeometry< Point3i > orthogonal tests"	,
		""	[orthogonal_vector][3i] )

Definition at line 297 of file testAffineGeometry.cpp.

{
  typedef SpaceND< 3, int >                Space;
  typedef Space::Point                     Point;
  typedef AffineGeometry< Point >          Affine;
  GIVEN( "Given basis B = { (7,3,1), (2,-5,1) } " ) {
    std::vector<Point> B = { Point(7,3,1), Point( 2,-5,1) };
    Point n = B[ 0 ].crossProduct( B[ 1 ] );
    Affine::completeBasis( B, true );
    THEN( "The complete basis has dimension 3" ) {
      CAPTURE( B );
      REQUIRE( B.size() == 3 );
    }
    THEN( "The last vector is non null and orthogonal to all the others" ) {
      CAPTURE( B.back() );
      REQUIRE( B.back().normInfinity() > 0 );
      REQUIRE( B.back().dot( B[ 0 ] ) == 0 );
      REQUIRE( B.back().dot( B[ 1 ] ) == 0 );
    }
    THEN( "The last vector is the cross product of the two others" ) {
      CAPTURE( B.back() );
      REQUIRE( B.back() == n );
    }
  }
  GIVEN( "Given basis B = { (7,3,1) } " ) {
    std::vector<Point> B = { Point(7,3,1) };
    Affine::completeBasis( B, true );
    THEN( "The complete basis has dimension 3" ) {
      CAPTURE( B );
      REQUIRE( B.size() == 3 );
    }
    THEN( "The mid vector is non null and trivial" ) {
      CAPTURE( B[ 1 ] );
      REQUIRE( B[ 1 ].norm1() == 1 );
    }
    THEN( "The last vector is non null and orthogonal to all the others" ) {
      CAPTURE( B.back() );
      REQUIRE( B.back().normInfinity() > 0 );
      REQUIRE( B.back().dot( B[ 0 ] ) == 0 );
      REQUIRE( B.back().dot( B[ 1 ] ) == 0 );
    }
    THEN( "The last vector is the cross product of the two others" ) {
      Point n = B[ 0 ].crossProduct( B[ 1 ] );
      CAPTURE( B.back() );
      REQUIRE( B.back() == n );
    }
  }
}

References CAPTURE(), GIVEN(), REQUIRE(), and SCENARIO().

SCENARIO() [5/10]

SCENARIO	(	"AffineGeometry< Point3i > unit tests"	,
		""	[affine_subset][3i] )

Definition at line 240 of file testAffineGeometry.cpp.

{
  typedef SpaceND< 3, int >                Space;
  typedef Space::Point                     Point;
  typedef AffineGeometry< Point >            Affine;
  GIVEN( "Given X = { (1, 0, 0), (2, 1, 0), (3, 1, 1), (3, 2, 0), (5, 2, 2), (4, 2, 1)} of affine dimension 2" ) {
    std::vector<Point> X
      = { Point{1, 0, 0}, Point{2, 1, 0}, Point{3, 1, 1}, Point{3, 2, 0}, Point{5, 2, 2}, Point{4, 2, 1} };
 
    auto I = Affine::affineSubset( X );
    THEN( "It has an affine basis of 3 points" ) {
      CAPTURE( I );
      REQUIRE( I.size() == 3 );
      REQUIRE( I[ 2 ] == 2 );
    }
  }
  GIVEN( "Given X = { (1, 0, 0), (2, 1, 0), (3, 1, 1), (3, 2, 0), (5, 2, 2), (4, 2, 1), (7, 3, 2)} of affine dimension 3" ) {
    std::vector<Point> X
      = { Point{1, 0, 0}, Point{2, 1, 0}, Point{3, 1, 1}, Point{3, 2, 0}, Point{5, 2, 2}, Point{4, 2, 1}, Point{7, 3, 2} };
 
    auto I = Affine::affineSubset( X );
    THEN( "It has an affine basis of 4 points" ) {
      CAPTURE( I );
      REQUIRE( I.size() == 4 );
      REQUIRE( I[ 2 ] == 2 );
      REQUIRE( I[ 3 ] == 6 );
    }
  }
  GIVEN( "Given X a set of randomly generated points by adding linear combinations of 1 lattice vectors" ) {
    std::vector< Point > V = { Point{ 3, 1, 0 } };
    auto X = makeRandomLatticePointsFromDirVectors( 20, V );
    auto I = Affine::affineSubset( X );
    THEN( "It has an affine basis of 2 points" ) {
      CAPTURE( I );
      REQUIRE( I.size() == 2 );
    }
  }
  GIVEN( "Given X a set of randomly generated points by adding linear combinations of 2 lattice vectors" ) {
    std::vector< Point > V = { Point{ 3, 1, 0 }, Point{ -2, -1, 2 } };
    auto X = makeRandomLatticePointsFromDirVectors( 20, V );
    auto I = Affine::affineSubset( X );
    THEN( "It has an affine basis of 3 points" ) {
      CAPTURE( I );
      REQUIRE( I.size() == 3 );
    }
  }
  GIVEN( "Given X a set of randomly generated points by adding linear combinations of 3 lattice vectors" ) {
    std::vector< Point > V = { Point{ 3, 1, 0 }, Point{ -2, -1, 2 }, Point{ -1, 4, 3 } };
    auto X = makeRandomLatticePointsFromDirVectors( 20, V );
    auto I = Affine::affineSubset( X );
    THEN( "It has an affine basis of 4 points" ) {
      CAPTURE( I );
      REQUIRE( I.size() == 4 );
    }
  }
}

References CAPTURE(), GIVEN(), makeRandomLatticePointsFromDirVectors(), REQUIRE(), and SCENARIO().

SCENARIO() [6/10]

SCENARIO	(	"AffineGeometry< Point4d > unit tests"	,
		""	[affine_subset][4d] )

Definition at line 417 of file testAffineGeometry.cpp.

{
  // NB: 1e-10 in tolerance is ok for these examples.
  // max norm of rejected vectors are 2e-12.
  typedef SpaceND< 4, int >                Space;
  typedef Space::RealPoint                 Point;
  GIVEN( "Given X a set of randomly generated points by adding linear combinations of 1 lattice vectors" ) {
    std::vector< Point > V = { Point{ 3, 1, 0, 2 } };
    auto X = makeRandomRealPointsFromDirVectors( 20, V );
    auto I = functions::computeAffineSubset( X, 1e-10 );
    Point o;
    std::vector< Point > B;
    functions::getAffineBasis( o, B, X, 1e-10 );
    THEN( "It has an affine subset of 2 points" ) {
      CAPTURE( I );
      REQUIRE( I.size() == 2 );
    }
    THEN( "It has an affine basis of 1 vector" ) {
      REQUIRE( B.size() == 1 );
    }
  }
  GIVEN( "Given X a set of randomly generated points by adding linear combinations of 2 lattice vectors" ) {
    std::vector< Point > V = { Point{ 3, 1, 0, 2 }, Point{ -2, -1, 2, 7 } };
    auto X = makeRandomRealPointsFromDirVectors( 20, V );
    auto I = functions::computeAffineSubset( X, 1e-10 );
    Point o;
    std::vector< Point > B;
    functions::getAffineBasis( o, B, X, 1e-10 );
    THEN( "It has an affine subset of 3 points" ) {
      CAPTURE( I );
      REQUIRE( I.size() == 3 );
    }
    THEN( "It has an affine basis of 2 vectors" ) {
      REQUIRE( B.size() == 2 );
    }
  }
  GIVEN( "Given X a set of randomly generated points by adding linear combinations of 3 lattice vectors" ) {
    std::vector< Point > V = { Point{ 3, 1, 0, 2 }, Point{ -2, -1, 2, 7 }, Point{ -1, 4, 3, -1  } };
    auto X = makeRandomRealPointsFromDirVectors( 20, V );
    auto I = functions::computeAffineSubset( X, 1e-10 );
    Point o;
    std::vector< Point > B;
    functions::getAffineBasis( o, B, X, 1e-10 );
    THEN( "It has an affine subset of 4 points" ) {
      CAPTURE( I );
      REQUIRE( I.size() == 4 );
    }
    THEN( "It has an affine basis of 3 vectors" ) {
      REQUIRE( B.size() == 3 );
    }
  }
  GIVEN( "Given X a set of randomly generated points by adding linear combinations of 4 lattice vectors" ) {
    std::vector< Point > V = { Point{ 3, 1, 0, 2 }, Point{ -2, -1, 2, 7 }, Point{ -1, 4, 3, -1 }, Point{ 2, 1, -3, -4 } };
    auto X = makeRandomRealPointsFromDirVectors( 20, V );
    auto I = functions::computeAffineSubset( X, 1e-10 );
    Point o;
    std::vector< Point > B;
    functions::getAffineBasis( o, B, X, 1e-10 );
    THEN( "It has an affine subset of 5 points" ) {
      CAPTURE( I );
      REQUIRE( I.size() == 5 );
    }
    THEN( "It has an affine basis of 4 vectors" ) {
      REQUIRE( B.size() == 4 );
    }
  }
}

References CAPTURE(), DGtal::functions::computeAffineSubset(), DGtal::functions::getAffineBasis(), GIVEN(), makeRandomRealPointsFromDirVectors(), REQUIRE(), and SCENARIO().

SCENARIO() [7/10]

SCENARIO	(	"AffineGeometry< Point4i > orthogonal tests"	,
		""	[orthogonal_vector][4i] )

Definition at line 485 of file testAffineGeometry.cpp.

{
  typedef SpaceND< 4, int >                Space;
  typedef Space::Point                     Point;
  typedef AffineGeometry< Point >          Affine;
  GIVEN( "Given basis B = { (7,3,1,0), (2,-5,1,2), (-1,2,2,-3) } " ) {
    std::vector<Point> B = { Point(7,3,1,0), Point(2,-5,1,2), Point(-1,2,2,-3) };
    Affine::completeBasis( B, true );
    THEN( "The complete basis has dimension 4" ) {
      CAPTURE( B );
      REQUIRE( B.size() == 4 );
    }
    THEN( "The last vector is non null and orthogonal to all the others" ) {
      CAPTURE( B.back() );
      REQUIRE( B.back().normInfinity() > 0 );
      REQUIRE( B.back().dot( B[ 0 ] ) == 0 );
      REQUIRE( B.back().dot( B[ 1 ] ) == 0 );
      REQUIRE( B.back().dot( B[ 2 ] ) == 0 );
    }
  }
  GIVEN( "Given basis B = { (7,3,1,0), (2,-5,1,2) } " ) {
    std::vector<Point> B = { Point(7,3,1,0), Point(2,-5,1,2) };
    Affine::completeBasis( B, true );
    THEN( "The complete basis has dimension 4" ) {
      CAPTURE( B );
      REQUIRE( B.size() == 4 );
    }
    THEN( "The third vector is non null and trivial" ) {
      CAPTURE( B[ 2 ] );
      REQUIRE( B[ 2 ].norm1() == 1 );
    }
    THEN( "The last vector is non null and orthogonal to all the others" ) {
      CAPTURE( B.back() );
      REQUIRE( B.back().normInfinity() > 0 );
      REQUIRE( B.back().dot( B[ 0 ] ) == 0 );
      REQUIRE( B.back().dot( B[ 1 ] ) == 0 );
      REQUIRE( B.back().dot( B[ 2 ] ) == 0 );
    }
  }
}

References CAPTURE(), GIVEN(), REQUIRE(), and SCENARIO().

SCENARIO() [8/10]

SCENARIO	(	"AffineGeometry< Point4i > unit tests"	,
		""	[affine_subset][4i] )

Definition at line 350 of file testAffineGeometry.cpp.

{
  typedef SpaceND< 4, int >                Space;
  typedef Space::Point                     Point;
  GIVEN( "Given X a set of randomly generated points by adding linear combinations of 1 lattice vectors" ) {
    std::vector< Point > V = { Point{ 3, 1, 0, 2 } };
    auto X = makeRandomLatticePointsFromDirVectors( 20, V );
    auto I = functions::computeAffineSubset( X );
    Point o;
    std::vector< Point > B;
    functions::getAffineBasis( o, B, X );
    THEN( "It has an affine basis of 2 points" ) {
      CAPTURE( I );
      REQUIRE( I.size() == 2 );
    }
    THEN( "It has an affine basis of 1 vector" ) {
      REQUIRE( B.size() == 1 );
    }
 
  }
  GIVEN( "Given X a set of randomly generated points by adding linear combinations of 2 lattice vectors" ) {
    std::vector< Point > V = { Point{ 3, 1, 0, 2 }, Point{ -2, -1, 2, 7 } };
    auto X = makeRandomLatticePointsFromDirVectors( 20, V );
    auto I = functions::computeAffineSubset( X );
    Point o;
    std::vector< Point > B;
    functions::getAffineBasis( o, B, X );
    THEN( "It has an affine basis of 3 points" ) {
      CAPTURE( I );
      REQUIRE( I.size() == 3 );
    }
    THEN( "It has an affine basis of 2 vectors" ) {
      REQUIRE( B.size() == 2 );
    }
  }
  GIVEN( "Given X a set of randomly generated points by adding linear combinations of 3 lattice vectors" ) {
    std::vector< Point > V = { Point{ 3, 1, 0, 2 }, Point{ -2, -1, 2, 7 }, Point{ -1, 4, 3, -1  } };
    auto X = makeRandomLatticePointsFromDirVectors( 20, V );
    auto I = functions::computeAffineSubset( X );
    Point o;
    std::vector< Point > B;
    functions::getAffineBasis( o, B, X );
    THEN( "It has an affine basis of 4 points" ) {
      CAPTURE( I );
      REQUIRE( I.size() == 4 );
    }
    THEN( "It has an affine basis of 3 vectors" ) {
      REQUIRE( B.size() == 3 );
    }
  }
  GIVEN( "Given X a set of randomly generated points by adding linear combinations of 4 lattice vectors" ) {
    std::vector< Point > V = { Point{ 3, 1, 0, 2 }, Point{ -2, -1, 2, 7 }, Point{ -1, 4, 3, -1 }, Point{ 2, 1, -3, -4 } };
    auto X = makeRandomLatticePointsFromDirVectors( 20, V );
    auto I = functions::computeAffineSubset( X );
    Point o;
    std::vector< Point > B;
    functions::getAffineBasis( o, B, X, 1e-10 );
    THEN( "It has an affine basis of 5 points" ) {
      CAPTURE( I );
      REQUIRE( I.size() == 5 );
    }
    THEN( "It has an affine basis of 4 vectors" ) {
      REQUIRE( B.size() == 4 );
    }
  }
}

References CAPTURE(), DGtal::functions::computeAffineSubset(), DGtal::functions::getAffineBasis(), GIVEN(), makeRandomLatticePointsFromDirVectors(), REQUIRE(), and SCENARIO().

SCENARIO() [9/10]

SCENARIO	(	"AffineGeometry< Z3 > bug"	,
		""	[affine_geom][3d] )

Definition at line 527 of file testAffineGeometry.cpp.

{
  typedef SpaceND<3,int>          Space;
  typedef Space::Point            Point;
  std::vector< Point > X = { {-46, 38, -43}, {27, -89, 20}, {53, 26, -57} };
  Point o;
  std::vector< Point > B;
  functions::getAffineBasis ( o, B, X );
  auto  C         = ( X[1]-X[0] ).crossProduct( X[2]-X[0] );
  auto  sC        = functions::computeSimplifiedVector( C );
  WHEN( "Computing orthogonal vector" ) {
    auto N = functions::computeOrthogonalVectorToBasis( B );
    THEN( "It is non null" ) {
      CAPTURE( N );
      REQUIRE( N != Point::zero );
    }
    THEN( "It corresponds to the reduced cross product" ) {
      CAPTURE( C );
      CAPTURE( sC );
      REQUIRE( N == sC );
    }
  }
}

References CAPTURE(), DGtal::functions::computeSimplifiedVector(), DGtal::crossProduct(), DGtal::functions::getAffineBasis(), REQUIRE(), and SCENARIO().

SCENARIO() [10/10]

SCENARIO	(	"AffineGeometry< Z3 > orthogonality"	,
		""	[affine_geom][3d] )

Definition at line 551 of file testAffineGeometry.cpp.

{
  typedef SpaceND<3,int64_t>          Space;
  typedef Space::Point            Point;
 
  WHEN( "Computing orthogonal vector to multiple random points" ) {
    std::vector< Point > X = makeRandomVectors<Point>( 100, 50 );
    std::size_t nb        = 300;
    std::size_t nb_equal  = 0;
    std::size_t nb_C_zero = 0;
    std::size_t nb_N_zero = 0;
    for ( auto i = 0; i < nb; i++ )
      {
        std::vector< Point > Y = { X[ rand() % 100 ], X[ rand() % 100 ], X[ rand() % 100 ] };
        auto  C         = ( Y[1]-Y[0] ).crossProduct( Y[2]-Y[0] );
        auto  sC        = functions::computeSimplifiedVector( C );
        Point N;
        functions::getOrthogonalVector( N, Y );
        nb_equal += (sC == N) ? 1 : 0;
        if ( sC != N )
          std::cout << "Y = " << Y[0] << " " << Y[1] << " " << Y[ 2 ]
                    << " sC = " << sC << " N = " << N << "\n";
        nb_C_zero += ( C == Point::zero ) ? 1 : 0;
        nb_N_zero += ( N == Point::zero ) ? 1 : 0;
      }
    THEN( "They corresponds to the reduced cross product" ) {
      REQUIRE( nb_equal == nb );
      REQUIRE( nb_C_zero == nb_N_zero );
    }
  }
}

References DGtal::functions::computeSimplifiedVector(), DGtal::crossProduct(), makeRandomVectors(), REQUIRE(), and SCENARIO().

uniform()

std::uniform_real_distribution< double > uniform	(	-1.	0,
		1.	0 )

References uniform().

Referenced by perturb(), and uniform().

Variable Documentation

rd

std::random_device rd

Definition at line 45 of file testAffineGeometry.cpp.