testCubicalComplex.cpp File Reference

#include <iostream>
#include <map>
#include <unordered_map>
#include "DGtal/base/Common.h"
#include "DGtal/kernel/domains/HyperRectDomain.h"
#include "DGtal/topology/KhalimskySpaceND.h"
#include "DGtal/topology/KhalimskyCellHashFunctions.h"
#include "DGtal/topology/CubicalComplex.h"
#include "DGtalCatch.h"

Go to the source code of this file.

Typedefs
typedef KSpace::Point	Point
typedef KSpace::Cell	Cell
typedef std::unordered_map< Cell, CubicalCellData >	Map
typedef CubicalComplex< KSpace, Map >	CC
typedef CC::CellMapConstIterator	CellMapConstIterator

Functions
	srand (0)
K	init (Point(0, 0, 0), Point(512, 512, 512), true)
std::vector< int >	nbCoFaces (4, 0)
std::vector< int >	nbFaces (6, 0)
std::vector< int >	nbFaces2 (6, 0)
std::vector< int >	nbBdry (10, 0)
std::vector< int >	nbBdry2 (10, 0)
	GIVEN ("A cubical complex with random 3-cells")
	SCENARIO ("CubicalComplex< K3,std::unordered_map<> > collapse tests", "[cubical_complex][collapse]")
	SCENARIO ("CubicalComplex< K3,std::unordered_map<> > link tests", "[cubical_complex][link]")
	SCENARIO ("CubicalComplex< K3,std::map<> > collapse tests", "[cubical_complex][collapse]")
	SCENARIO ("CubicalComplex< K3,std::map<> > link tests", "[cubical_complex][link]")
	SCENARIO ("CubicalComplex< K3,std::map<> > concept check tests", "[cubical_complex][concepts]")
	SCENARIO ("CubicalComplex< K2,std::map<> > set operations and relations", "[cubical_complex][ccops]")

Variables
static const int	NBCELLS = 1000
KSpace	K

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

2015/08/28

Functions for testing class CubicalComplex.

This file is part of the DGtal library.

Definition in file testCubicalComplex.cpp.

Typedef Documentation

CC

typedef CubicalComplex< KSpace, Map > CC

Examples

topology/cubical-complex-collapse.cpp, topology/cubical-complex-illustrations.cpp, and topology/digitalSetToCubicalComplexes2D.cpp.

Definition at line 58 of file testCubicalComplex.cpp.

Cell

typedef KSpace::Cell Cell

Examples

dec/examplePropagation.cpp, and geometry/surfaces/dvcm-3d.cpp.

Definition at line 56 of file testCubicalComplex.cpp.

CellMapConstIterator

typedef CC::CellMapConstIterator CellMapConstIterator

Examples

topology/cubical-complex-collapse.cpp, and topology/digitalSetToCubicalComplexes2D.cpp.

Definition at line 59 of file testCubicalComplex.cpp.

Map

typedef std::map< Cell, CubicalCellData > Map

Examples

topology/cubical-complex-collapse.cpp, and topology/digitalSetToCubicalComplexes2D.cpp.

Definition at line 57 of file testCubicalComplex.cpp.

Point

typedef KSpace::Point Point

Initial value:

{
  typedef KhalimskySpaceND<3>                       KSpace

Definition at line 55 of file testCubicalComplex.cpp.

Function Documentation

GIVEN()

GIVEN

(

"A cubical complex with random 3-cells"

)

Definition at line 70 of file testCubicalComplex.cpp.

                                                   {
    CC complex( K );
    for ( int n = 0; n < NBCELLS; ++n )
      {
        Point p( (rand() % 512) | 0x1, (rand() % 512) | 0x1, (rand() % 512) | 0x1 );
        Cell cell = K.uCell( p );
        complex.insertCell( cell );
      }
    THEN( "It has only 3-cells and no other type of cells" ) {
      REQUIRE( complex.nbCells( 0 ) == 0 );
      REQUIRE( complex.nbCells( 1 ) == 0 );
      REQUIRE( complex.nbCells( 2 ) == 0 );
      REQUIRE( complex.nbCells( 3 ) > 0 );
    }
 
    WHEN( "Computing proper faces of these 3-cells" ) {
      std::vector<Cell> faces;
      std::back_insert_iterator< std::vector<Cell> > outIt( faces );
      for ( CellMapConstIterator it = complex.begin( 3 ), itE = complex.end( 3 );
            it != itE; ++it )
        complex.faces( outIt, it->first );
      THEN( "There are no proper faces within this complex" ) {
        REQUIRE( faces.size() == 0 );
      }
    }
 
    WHEN( "Closing the cubical complex" ) {
      complex.close();
      THEN( "It has cells of all dimensions." ) {
        REQUIRE( complex.nbCells( 0 ) > 0 );
        REQUIRE( complex.nbCells( 1 ) > 0 );
        REQUIRE( complex.nbCells( 2 ) > 0 );
      }
 
      WHEN( "Computing the direct co-faces of 2-cells" ) {
        for ( CellMapConstIterator it = complex.begin( 2 ), itE = complex.end( 2 );
              it != itE; ++it )
          {
            std::vector<Cell> faces;
            std::back_insert_iterator< std::vector<Cell> > outIt( faces );
            complex.directCoFaces( outIt, it->first );
            int n = static_cast<int>(faces.size());
            if ( n >= 3 ) n = 3; // should not happen
            nbCoFaces[ n ]++;
          }
        THEN( "None of them are incident to zero 3-cells" ) {
          REQUIRE( nbCoFaces[ 0 ] == 0 );
        } AND_THEN ( "Most of them are incident to one 3-cells and some of them to two 3-cells" ) {
          REQUIRE( nbCoFaces[ 1 ] > 10*nbCoFaces[ 2 ] );
        } AND_THEN ("None of them are incident to three or more 3-cells" ) {
          REQUIRE( nbCoFaces[ 3 ] == 0 );
        }
      }
 
      WHEN( "Computing direct faces of 2-cells" ) {
        for ( CellMapConstIterator it = complex.begin( 2 ), itE = complex.end( 2 );
              it != itE; ++it )
          {
            std::vector<Cell> faces;
            std::back_insert_iterator< std::vector<Cell> > outIt( faces );
            complex.directFaces( outIt, it->first, true );
            auto n = faces.size();
            if ( n < 4 ) n = 3; // should not happen
            if ( n > 4 ) n = 5; // should not happen
            nbFaces[ n ]++;
          }
        for ( CellMapConstIterator it = complex.begin( 2 ), itE = complex.end( 2 );
              it != itE; ++it )
          {
            std::vector<Cell> faces;
            std::back_insert_iterator< std::vector<Cell> > outIt( faces );
            complex.directFaces( outIt, it->first );
            auto n = faces.size();
            if ( n < 4 ) n = 3; // should not happen
            if ( n > 4 ) n = 5; // should not happen
            nbFaces2[ n ]++;
          }
        THEN( "All of them have exactly 4 incident 1-cells when computed with hint closed" ) {
          REQUIRE( nbFaces[ 3 ] == 0 );
          REQUIRE( nbFaces[ 4 ] > 0 );
          REQUIRE( nbFaces[ 5 ] == 0 );
        } AND_THEN( "All of them have exactly 4 incident 1-cells when computed without hint" ) {
          REQUIRE( nbFaces2[ 3 ] == 0 );
          REQUIRE( nbFaces2[ 4 ] > 0 );
          REQUIRE( nbFaces2[ 5 ] == 0 );
        } AND_THEN( "It gives the same number of incident cells with or without hint" ) {
          REQUIRE( nbFaces[ 4 ] == nbFaces2[ 4 ] );
        }
      }
 
      WHEN( "Computing boundaries of 2-cells" ) {
        for ( CellMapConstIterator it = complex.begin( 2 ), itE = complex.end( 2 );
              it != itE; ++it )
          {
            CC::Cells faces = complex.cellBoundary( it->first, true );
            size_t n = faces.size();
            if ( n < 8 ) n = 7; // should not happen
            if ( n > 8 ) n = 9; // should not happen
            nbBdry[ n ]++;
          }
        for ( CellMapConstIterator it = complex.begin( 2 ), itE = complex.end( 2 );
              it != itE; ++it )
          {
            CC::Cells faces = complex.cellBoundary( it->first, false );
            size_t n = faces.size();
            if ( n < 8 ) n = 7; // should not happen
            if ( n > 8 ) n = 9; // should not happen
            nbBdry2[ n ]++;
          }
        THEN( "All of them contain exactly 8 cells when computed with hint closed" ) {
          REQUIRE( nbBdry[ 7 ] == 0 );
          REQUIRE( nbBdry[ 8 ] > 0 );
          REQUIRE( nbBdry[ 9 ] == 0 );
        } AND_THEN( "All of them contain exactly 8 cells when computed without hint" ) {
          REQUIRE( nbBdry2[ 7 ] == 0 );
          REQUIRE( nbBdry2[ 8 ] > 0 );
          REQUIRE( nbBdry2[ 9 ] == 0 );
        } AND_THEN( "It gives the same number of incident cells with or without hint" ) {
          REQUIRE( nbBdry[ 8 ] == nbBdry2[ 8 ] );
        }
      }
    }  // WHEN( "Closing the cubical complex" ) {
  }

References DGtal::CubicalComplex< TKSpace, TCellContainer >::begin(), DGtal::CubicalComplex< TKSpace, TCellContainer >::cellBoundary(), DGtal::CubicalComplex< TKSpace, TCellContainer >::close(), DGtal::CubicalComplex< TKSpace, TCellContainer >::directCoFaces(), DGtal::CubicalComplex< TKSpace, TCellContainer >::directFaces(), DGtal::CubicalComplex< TKSpace, TCellContainer >::end(), DGtal::CubicalComplex< TKSpace, TCellContainer >::faces(), DGtal::CubicalComplex< TKSpace, TCellContainer >::insertCell(), K, nbBdry(), nbBdry2(), DGtal::CubicalComplex< TKSpace, TCellContainer >::nbCells(), NBCELLS, nbCoFaces(), nbFaces(), nbFaces2(), REQUIRE(), and DGtal::KhalimskySpaceND< dim, TInteger >::uCell().

Referenced by SCENARIO(), and TEST_CASE_METHOD().

init()

K init	(	Point(0, 0, 0)	,
		Point(512, 512, 512)	,
		true
	)

nbBdry()

std::vector< int > nbBdry	(	10	,
		0
	)

Referenced by GIVEN().

nbBdry2()

std::vector< int > nbBdry2	(	10	,
		0
	)

Referenced by GIVEN().

nbCoFaces()

std::vector< int > nbCoFaces	(	4	,
		0
	)

Referenced by GIVEN().

nbFaces()

std::vector< int > nbFaces	(	6	,
		0
	)

Referenced by GIVEN().

nbFaces2()

std::vector< int > nbFaces2	(	6	,
		0
	)

Referenced by GIVEN().

SCENARIO() [1/6]

SCENARIO	(	"CubicalComplex< K2,std::map<> > set operations and relations"	,
		""	[cubical_complex][ccops]
	)

Definition at line 576 of file testCubicalComplex.cpp.

{
  typedef KhalimskySpaceND<2>               KSpace;
  typedef KSpace::Space                     Space;
  typedef HyperRectDomain<Space>            Domain;
  typedef KSpace::Point                     Point;
  typedef KSpace::Cell                      Cell;
  typedef std::map<Cell, CubicalCellData>   Map;
  typedef CubicalComplex< KSpace, Map >     CC;
 
  KSpace K;
  K.init( Point( 0,0 ), Point( 5,3 ), true );
  Domain domain( Point( 0,0 ), Point( 5,3 ) );
  CC X1( K );
  X1.insertCell( K.uSpel( Point(1,1) ) );
  X1.insertCell( K.uSpel( Point(2,1) ) );
  X1.insertCell( K.uSpel( Point(3,1) ) );
  X1.insertCell( K.uSpel( Point(2,2) ) );
  CC X1c = ~ X1;
 
  CC X2( K );
  X2.insertCell( K.uSpel( Point(2,2) ) );
  X2.insertCell( K.uSpel( Point(3,2) ) );
  X2.insertCell( K.uSpel( Point(4,2) ) );
  X2.close();
  CC X2c = ~ X2;
  REQUIRE( ( X1 & X2 ).size() < X1.size() );
  bool X1_and_X2_included_in_X1 = ( X1 & X2 ) <= X1;
  bool X1c_and_X2c_included_in_X1c = ( X1c & X2c ) <= X1c;
  CC A = ~( X1 & X2 );
  CC B = ~( *(X1c & X2c) );
  CAPTURE( A );
  CAPTURE( B );
  bool cl_X1_and_X2_equal_to_X1c_and_X2c = A == B;
 
  REQUIRE( X1_and_X2_included_in_X1 );
  REQUIRE( X1c_and_X2c_included_in_X1c );
  REQUIRE( cl_X1_and_X2_equal_to_X1c_and_X2c );
 
  CC X1bd = X1c - *X1c;
  CAPTURE( X1bd );
  CAPTURE( X1.boundary() );
  bool X1bd_equal_X1boundary = X1bd == X1.boundary();
  REQUIRE( X1bd_equal_X1boundary );
}

References DGtal::CubicalComplex< TKSpace, TCellContainer >::boundary(), CAPTURE(), DGtal::CubicalComplex< TKSpace, TCellContainer >::close(), domain, DGtal::KhalimskySpaceND< dim, TInteger >::init(), DGtal::CubicalComplex< TKSpace, TCellContainer >::insertCell(), K, REQUIRE(), DGtal::CubicalComplex< TKSpace, TCellContainer >::size(), and DGtal::KhalimskySpaceND< dim, TInteger >::uSpel().

SCENARIO() [2/6]

SCENARIO	(	"CubicalComplex< K3,std::map<> > collapse tests"	,
		""	[cubical_complex][collapse]
	)

Definition at line 454 of file testCubicalComplex.cpp.

{
  typedef KhalimskySpaceND<3>               KSpace;
  typedef KSpace::Point            Point;
  typedef KSpace::Cell             Cell;
  typedef KSpace::Integer          Integer;
  typedef std::map<Cell, CubicalCellData>   Map;
  typedef CubicalComplex< KSpace, Map >     CC;
  typedef CC::CellMapIterator      CellMapIterator;
 
  srand( 0 );
  KSpace K;
  K.init( Point( 0,0,0 ), Point( 512,512,512 ), true );
 
  GIVEN( "A closed cubical complex made of 3x3x3 voxels with their incident cells" ) {
    CC complex( K );
    std::vector<Cell> S;
    for ( Integer x = 0; x < 3; ++x )
      for ( Integer y = 0; y < 3; ++y )
        for ( Integer z = 0; z < 3; ++z )
          {
            S.push_back( K.uSpel( Point( x, y, z ) ) );
            complex.insertCell( S.back() );
          }
    complex.close();
    CAPTURE( complex.nbCells( 0 ) );
    CAPTURE( complex.nbCells( 1 ) );
    CAPTURE( complex.nbCells( 2 ) );
    CAPTURE( complex.nbCells( 3 ) );
 
    THEN( "It has Euler characteristic 1" ) {
      REQUIRE( complex.euler() == 1 );
    }
 
    WHEN( "Fixing two vertices of this big cube and collapsing it" ) {
      CellMapIterator it1 = complex.findCell( 0, K.uCell( Point( 0, 0, 0 ) ) );
      CellMapIterator it2 = complex.findCell( 0, K.uCell( Point( 4, 4, 4 ) ) );
      REQUIRE( it1 != complex.end( 0 ) );
      REQUIRE( it2 != complex.end( 0 ) );
      it1->second.data |= CC::FIXED;
      it2->second.data |= CC::FIXED;
      CC::DefaultCellMapIteratorPriority P;
      functions::collapse( complex, S.begin(), S.end(), P, false, true );
      CAPTURE( complex.nbCells( 0 ) );
      CAPTURE( complex.nbCells( 1 ) );
      CAPTURE( complex.nbCells( 2 ) );
      CAPTURE( complex.nbCells( 3 ) );
 
      THEN( "It keeps its topology so its euler characteristic is 1" ) {
       REQUIRE( complex.euler() == 1 );
      } AND_THEN( "It has no more 2-cells and 3-cells" ) {
        REQUIRE( complex.nbCells( 2 ) == 0 );
        REQUIRE( complex.nbCells( 3 ) == 0 );
      } AND_THEN( "It has only 0-cells and 1-cells" ) {
        REQUIRE( complex.nbCells( 0 ) > 0 );
        REQUIRE( complex.nbCells( 1 ) > 0 );
      }
    }
  }
}

References DGtal::CubicalComplex< TKSpace, TCellContainer >::begin(), CAPTURE(), DGtal::CubicalComplex< TKSpace, TCellContainer >::close(), DGtal::functions::collapse(), DGtal::CubicalComplex< TKSpace, TCellContainer >::end(), DGtal::CubicalComplex< TKSpace, TCellContainer >::euler(), DGtal::CubicalComplex< TKSpace, TCellContainer >::findCell(), GIVEN(), DGtal::KhalimskySpaceND< dim, TInteger >::init(), DGtal::CubicalComplex< TKSpace, TCellContainer >::insertCell(), K, DGtal::CubicalComplex< TKSpace, TCellContainer >::nbCells(), REQUIRE(), srand(), DGtal::KhalimskySpaceND< dim, TInteger >::uCell(), and DGtal::KhalimskySpaceND< dim, TInteger >::uSpel().

SCENARIO() [3/6]

SCENARIO	(	"CubicalComplex< K3,std::map<> > concept check tests"	,
		""	[cubical_complex][concepts]
	)

Definition at line 563 of file testCubicalComplex.cpp.

{
  typedef KhalimskySpaceND<3>               KSpace;
  typedef KSpace::Cell                      Cell;
  typedef std::map<Cell, CubicalCellData>   Map;
  typedef CubicalComplex< KSpace, Map >     CC;
 
  BOOST_CONCEPT_ASSERT(( boost::Container<CC> ));
  BOOST_CONCEPT_ASSERT(( boost::ForwardIterator<CC::Iterator> ));
  BOOST_CONCEPT_ASSERT(( boost::ForwardIterator<CC::ConstIterator> ));
}

SCENARIO() [4/6]

SCENARIO	(	"CubicalComplex< K3,std::map<> > link tests"	,
		""	[cubical_complex][link]
	)

Definition at line 515 of file testCubicalComplex.cpp.

{
  typedef KhalimskySpaceND<3>               KSpace;
  typedef KSpace::Point            Point;
  typedef KSpace::Cell             Cell;
  typedef KSpace::Integer          Integer;
  typedef std::map<Cell, CubicalCellData>   Map;
  typedef CubicalComplex< KSpace, Map >     CC;
 
  srand( 0 );
  KSpace K;
  K.init( Point( 0,0,0 ), Point( 512,512,512 ), true );
 
  GIVEN( "A closed cubical complex made of 10x10x10 voxels with their incident cells" ) {
    CC X( K );
    CC S( K );
    for ( Integer x = 0; x < 10; ++x )
      for ( Integer y = 0; y < 10; ++y )
        for ( Integer z = 0; z < 10; ++z )
          {
            Cell c = K.uSpel( Point( x, y, z ) );
            if ( x*y*z != 0 )
              S.insert( K.uPointel( Point( x, y, z ) ) );
            X.insertCell( c );
          }
    X.close();
    THEN( "It has Euler characteristic 1" ) {
      REQUIRE( X.euler() == 1 );
    }
 
    WHEN( "Computing the link of its inner pointels without hint" ) {
      CC link_S_v1 = X.link( S );
 
      THEN( "This link is homeomorphic to a sphere and has euler characteristic 2" ) {
        REQUIRE( link_S_v1.euler() == 2 );
      }
    }
 
    WHEN( "Computing the link of its inner pointels with full hints" ) {
      CC link_S_v2 = X.link( S, true, true );
 
      THEN( "This link is again homeomorphic to a sphere and has euler characteristic 2" ) {
        REQUIRE( link_S_v2.euler() == 2 );
      }
    }
  }
}

References DGtal::CubicalComplex< TKSpace, TCellContainer >::close(), DGtal::CubicalComplex< TKSpace, TCellContainer >::euler(), GIVEN(), DGtal::KhalimskySpaceND< dim, TInteger >::init(), DGtal::CubicalComplex< TKSpace, TCellContainer >::insert(), DGtal::CubicalComplex< TKSpace, TCellContainer >::insertCell(), K, DGtal::CubicalComplex< TKSpace, TCellContainer >::link(), REQUIRE(), srand(), DGtal::KhalimskySpaceND< dim, TInteger >::uPointel(), and DGtal::KhalimskySpaceND< dim, TInteger >::uSpel().

SCENARIO() [5/6]

SCENARIO	(	"CubicalComplex< K3,std::unordered_map<> > collapse tests"	,
		""	[cubical_complex][collapse]
	)

Definition at line 195 of file testCubicalComplex.cpp.

{
  typedef KhalimskySpaceND<3>                       KSpace;
  typedef KSpace::Point                             Point;
  typedef KSpace::Cell                              Cell;
  typedef KSpace::Integer                           Integer;
  typedef std::unordered_map<Cell, CubicalCellData> Map;
  typedef CubicalComplex< KSpace, Map >             CC;
  typedef CC::CellMapIterator                       CellMapIterator;
 
  srand( 0 );
  KSpace K;
  K.init( Point( 0,0,0 ), Point( 512,512,512 ), true );
 
  GIVEN( "A closed cubical complex made of 3x3x3 voxels with their incident cells" ) {
    CC complex( K );
    std::vector<Cell> S;
    for ( Integer x = 0; x < 3; ++x )
      for ( Integer y = 0; y < 3; ++y )
        for ( Integer z = 0; z < 3; ++z )
          {
            S.push_back( K.uSpel( Point( x, y, z ) ) );
            complex.insertCell( S.back() );
          }
    complex.close();
    CAPTURE( complex.nbCells( 0 ) );
    CAPTURE( complex.nbCells( 1 ) );
    CAPTURE( complex.nbCells( 2 ) );
    CAPTURE( complex.nbCells( 3 ) );
 
    THEN( "It has Euler characteristic 1" ) {
      REQUIRE( complex.euler() == 1 );
    }
 
    WHEN( "Fixing two vertices of this big cube and collapsing it" ) {
      CellMapIterator it1 = complex.findCell( 0, K.uCell( Point( 0, 0, 0 ) ) );
      CellMapIterator it2 = complex.findCell( 0, K.uCell( Point( 4, 4, 4 ) ) );
      REQUIRE( it1 != complex.end( 0 ) );
      REQUIRE( it2 != complex.end( 0 ) );
      it1->second.data |= CC::FIXED;
      it2->second.data |= CC::FIXED;
      CC::DefaultCellMapIteratorPriority P;
      functions::collapse( complex, S.begin(), S.end(), P, false, true );
      CAPTURE( complex.nbCells( 0 ) );
      CAPTURE( complex.nbCells( 1 ) );
      CAPTURE( complex.nbCells( 2 ) );
      CAPTURE( complex.nbCells( 3 ) );
 
      THEN( "It keeps its topology so its euler characteristic is 1" ) {
       REQUIRE( complex.euler() == 1 );
      } AND_THEN( "It has no more 2-cells and 3-cells" ) {
        REQUIRE( complex.nbCells( 2 ) == 0 );
        REQUIRE( complex.nbCells( 3 ) == 0 );
      } AND_THEN( "It has only 0-cells and 1-cells" ) {
        REQUIRE( complex.nbCells( 0 ) > 0 );
        REQUIRE( complex.nbCells( 1 ) > 0 );
      }
    }
  }
}

References DGtal::CubicalComplex< TKSpace, TCellContainer >::begin(), CAPTURE(), DGtal::CubicalComplex< TKSpace, TCellContainer >::close(), DGtal::functions::collapse(), DGtal::CubicalComplex< TKSpace, TCellContainer >::end(), DGtal::CubicalComplex< TKSpace, TCellContainer >::euler(), DGtal::CubicalComplex< TKSpace, TCellContainer >::findCell(), GIVEN(), DGtal::KhalimskySpaceND< dim, TInteger >::init(), DGtal::CubicalComplex< TKSpace, TCellContainer >::insertCell(), K, DGtal::CubicalComplex< TKSpace, TCellContainer >::nbCells(), REQUIRE(), srand(), DGtal::KhalimskySpaceND< dim, TInteger >::uCell(), and DGtal::KhalimskySpaceND< dim, TInteger >::uSpel().

SCENARIO() [6/6]

SCENARIO	(	"CubicalComplex< K3,std::unordered_map<> > link tests"	,
		""	[cubical_complex][link]
	)

Definition at line 256 of file testCubicalComplex.cpp.

{
  typedef KhalimskySpaceND<3>                       KSpace;
  typedef KSpace::Point                             Point;
  typedef KSpace::Cell                              Cell;
  typedef KSpace::Integer                           Integer;
  typedef std::unordered_map<Cell, CubicalCellData> Map;
  typedef CubicalComplex< KSpace, Map >             CC;
 
  srand( 0 );
  KSpace K;
  K.init( Point( 0,0,0 ), Point( 512,512,512 ), true );
 
  GIVEN( "A closed cubical complex made of 10x10x10 voxels with their incident cells" ) {
    CC X( K );
    CC S( K );
    for ( Integer x = 0; x < 10; ++x )
      for ( Integer y = 0; y < 10; ++y )
        for ( Integer z = 0; z < 10; ++z )
          {
            Cell c = K.uSpel( Point( x, y, z ) );
            if ( x*y*z != 0 )
              S.insert( K.uPointel( Point( x, y, z ) ) );
            X.insertCell( c );
          }
    X.close();
    THEN( "It has Euler characteristic 1" ) {
      REQUIRE( X.euler() == 1 );
    }
 
    WHEN( "Computing the link of its inner pointels without hint" ) {
      CC link_S_v1 = X.link( S );
 
      THEN( "This link is homeomorphic to a sphere and has euler characteristic 2" ) {
        REQUIRE( link_S_v1.euler() == 2 );
      }
    }
 
    WHEN( "Computing the link of its inner pointels with full hints" ) {
      CC link_S_v2 = X.link( S, true, true );
 
      THEN( "This link is again homeomorphic to a sphere and has euler characteristic 2" ) {
        REQUIRE( link_S_v2.euler() == 2 );
      }
    }
  }
}

References DGtal::CubicalComplex< TKSpace, TCellContainer >::close(), DGtal::CubicalComplex< TKSpace, TCellContainer >::euler(), GIVEN(), DGtal::KhalimskySpaceND< dim, TInteger >::init(), DGtal::CubicalComplex< TKSpace, TCellContainer >::insert(), DGtal::CubicalComplex< TKSpace, TCellContainer >::insertCell(), K, DGtal::CubicalComplex< TKSpace, TCellContainer >::link(), REQUIRE(), srand(), DGtal::KhalimskySpaceND< dim, TInteger >::uPointel(), and DGtal::KhalimskySpaceND< dim, TInteger >::uSpel().

srand()

srand

(

0

)

Examples

geometry/volumes/distance/distancetransform3D.cpp.

Referenced by incTestComparison(), main(), randomSeeds(), randomTest30All(), randomTest52All(), randomTest62All(), SCENARIO(), test_get(), and test_setVal().

Variable Documentation

K

KSpace K

Examples

dec/exampleHeatLaplace.cpp, geometry/curves/estimation/exampleCurvature.cpp, geometry/curves/exampleRationalConvexity.cpp, geometry/meshes/curvature-comparator-ii-cnc-3d.cpp, geometry/meshes/digpoly-curvature-measures-cnc-3d.cpp, geometry/meshes/digpoly-curvature-measures-cnc-XY-3d.cpp, geometry/meshes/vol-curvature-measures-icnc-3d.cpp, geometry/meshes/vol-curvature-measures-icnc-XY-3d.cpp, geometry/volumes/fullConvexityAnalysis3D.cpp, geometry/volumes/fullConvexityLUT2D.cpp, geometry/volumes/fullConvexityShortestPaths3D.cpp, geometry/volumes/fullConvexitySphereGeodesics.cpp, geometry/volumes/fullConvexityThinning3D.cpp, io/boards/dgtalBoard3D-2-ks.cpp, io/boards/dgtalBoard3DTo2D-KSCell.cpp, io/viewDualSurface.cpp, io/viewers/viewer3D-10-interaction.cpp, io/viewers/viewer3D-11-extension.cpp, io/viewers/viewer3D-4bis-illustrationMode.cpp, topology/3dKSSurfaceExtraction.cpp, topology/area-estimation-with-digital-surface.cpp, topology/area-estimation-with-indexed-digital-surface.cpp, topology/ctopo-1-3d.cpp, topology/ctopo-1.cpp, topology/ctopo-1s-3d.cpp, topology/ctopo-fillContours.cpp, topology/cubical-complex-collapse.cpp, topology/cubical-complex-illustrations.cpp, topology/digitalSetToCubicalComplexes2D.cpp, topology/frontierAndBoundary.cpp, topology/khalimskySpaceScanner.cpp, topology/trackImplicitPolynomialSurfaceToOFF.cpp, and topology/volToOFF.cpp.

Definition at line 62 of file testCubicalComplex.cpp.

Referenced by accuracyTest(), ballGenerator(), centerSurfel(), cmpSCellsIfInside(), cmpUCellsIfInside(), DGtal::functions::const_middle(), estimatorOnShapeDigitization(), DGtal::Shortcuts< TKSpace >::getCellEmbedder(), DGtal::Shortcuts< TKSpace >::getCellRange(), getComplex(), DGtal::ShortcutsGeometry< TKSpace >::getCTrivialNormalVectors(), DGtal::ShortcutsGeometry< TKSpace >::getFirstPrincipalCurvatures(), DGtal::ShortcutsGeometry< TKSpace >::getFirstPrincipalDirections(), DGtal::ShortcutsGeometry< TKSpace >::getGaussianCurvatures(), DGtal::ShortcutsGeometry< TKSpace >::getIIGaussianCurvatures(), DGtal::ShortcutsGeometry< TKSpace >::getIIMeanCurvatures(), DGtal::ShortcutsGeometry< TKSpace >::getIINormalVectors(), DGtal::ShortcutsGeometry< TKSpace >::getIIPrincipalCurvaturesAndDirections(), DGtal::CellGeometryFunctions< TKSpace, i, N >::getIncidentCellsToPointels(), DGtal::CellGeometryFunctions< TKSpace, 1, 2 >::getIncidentCellsToPointels(), DGtal::CellGeometryFunctions< TKSpace, 1, 3 >::getIncidentCellsToPointels(), DGtal::CellGeometryFunctions< TKSpace, 2, 2 >::getIncidentCellsToPointels(), DGtal::CellGeometryFunctions< TKSpace, 2, 3 >::getIncidentCellsToPointels(), DGtal::CellGeometryFunctions< TKSpace, 3, 3 >::getIncidentCellsToPointels(), DGtal::CellGeometryFunctions< TKSpace, i, N >::getIncidentCellsToPoints(), DGtal::CellGeometryFunctions< TKSpace, 1, 2 >::getIncidentCellsToPoints(), DGtal::CellGeometryFunctions< TKSpace, 1, 3 >::getIncidentCellsToPoints(), DGtal::CellGeometryFunctions< TKSpace, 2, 2 >::getIncidentCellsToPoints(), DGtal::CellGeometryFunctions< TKSpace, 2, 3 >::getIncidentCellsToPoints(), DGtal::CellGeometryFunctions< TKSpace, 3, 3 >::getIncidentCellsToPoints(), DGtal::CellGeometryFunctions< TKSpace, i, N >::getIncidentKPointsToPoints(), DGtal::CellGeometryFunctions< TKSpace, 1, 2 >::getIncidentKPointsToPoints(), DGtal::CellGeometryFunctions< TKSpace, 1, 3 >::getIncidentKPointsToPoints(), DGtal::CellGeometryFunctions< TKSpace, 2, 2 >::getIncidentKPointsToPoints(), DGtal::CellGeometryFunctions< TKSpace, 2, 3 >::getIncidentKPointsToPoints(), DGtal::CellGeometryFunctions< TKSpace, 3, 3 >::getIncidentKPointsToPoints(), DGtal::Shortcuts< TKSpace >::getKSpace(), DGtal::ShortcutsGeometry< TKSpace >::getMeanCurvatures(), DGtal::ShortcutsGeometry< TKSpace >::getNormalVectors(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::getOutputScalarFieldV0(), DGtal::Shortcuts< TKSpace >::getPointelRange(), DGtal::ShortcutsGeometry< TKSpace >::getPositions(), DGtal::Shortcuts< TKSpace >::getPrimalCells(), DGtal::Shortcuts< TKSpace >::getPrimalVertices(), DGtal::ShortcutsGeometry< TKSpace >::getPrincipalCurvaturesAndDirections(), DGtal::Shortcuts< TKSpace >::getSCellEmbedder(), DGtal::ShortcutsGeometry< TKSpace >::getSecondPrincipalCurvatures(), DGtal::ShortcutsGeometry< TKSpace >::getSecondPrincipalDirections(), DGtal::ShortcutsGeometry< TKSpace >::getTrivialNormalVectors(), GIVEN(), main(), DGtal::Shortcuts< TKSpace >::makeDigitalSurface(), DGtal::Shortcuts< TKSpace >::makeIdxDigitalSurface(), DGtal::Shortcuts< TKSpace >::makeLightDigitalSurface(), DGtal::Shortcuts< TKSpace >::makeLightDigitalSurfaces(), DGtal::Shortcuts< TKSpace >::makePolygonalSurface(), DGtal::Shortcuts< TKSpace >::makeTriangulatedSurface(), Object3D(), DGtal::Shortcuts< TKSpace >::CellReader::operator()(), DGtal::Shortcuts< TKSpace >::SCellReader::operator()(), DGtal::Shortcuts< TKSpace >::CellWriter::operator()(), DGtal::Shortcuts< TKSpace >::SCellWriter::operator()(), DGtal::Shortcuts< TKSpace >::outputCellMapAsCSV(), DGtal::Shortcuts< TKSpace >::outputDualDigitalSurfaceAsObj(), DGtal::Shortcuts< TKSpace >::outputSCellMapAsCSV(), DGtal::Shortcuts< TKSpace >::outputSurfelsAsObj(), DGtal::NeighborhoodConvexityAnalyzer< TKSpace, K >::radius(), DGtal::Shortcuts< TKSpace >::saveOBJ(), DGtal::Shortcuts< TKSpace >::saveOFF(), SCENARIO(), TEST_CASE(), testBallQuad(), testCellDrawOnBoard(), testCellularGridSpaceNDCoFaces(), testCellularGridSpaceNDFaces(), testCombinatorialSurface(), testCompareEstimator(), testComputeInterior(), testCube(), testCurvature2d(), testDigitalSetBoundary(), testDigitalSurface(), testDigitalSurfaceBoostGraphInterface(), testDigitization(), testDirectIncidence(), testEmbedder(), testEstimatorCache(), testExplicitDigitalSurface(), testFaces(), testFindABel(), testFitting(), testGaussianCurvature3d(), testImplicitDigitalSurface(), DGtal::testImplicitDigitalSurface(), testIncidence(), testLightExplicitDigitalSurface(), testLightImplicitDigitalSurface(), DGtal::testLightImplicitDigitalSurface(), testLocalEstimatorFromFunctorAdapter(), testMeanCurvature3d(), testNeighborhood(), testObjectGraph(), testOrderingDigitalSurfaceFacesAroundVertex(), testPrincipalCurvatures3d(), testRaySurface(), testScan(), testSurfelAdjacency(), testTrueLocalEstimatorOnShapeDigitization(), testUmbrellaComputer(), and DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::updateSmallestEpsilonMap().

NBCELLS

const int NBCELLS = 1000

static

Definition at line 50 of file testCubicalComplex.cpp.

Referenced by GIVEN().