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 "DGtal/topology/CubicalComplexFunctions.h"
#include "DGtalCatch.h"

Include dependency graph for testCubicalComplex.cpp:

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 59 of file testCubicalComplex.cpp.

Cell

typedef KSpace::Cell Cell

Examples:

dec/exampleDiscreteExteriorCalculusSolve.cpp, dec/examplePropagation.cpp, geometry/surfaces/dvcm-3d.cpp, topology/cubical-complex-collapse.cpp, and topology/khalimskySpaceScanner.cpp.

Definition at line 57 of file testCubicalComplex.cpp.

CellMapConstIterator

typedef CC::CellMapConstIterator CellMapConstIterator

Examples:

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

Definition at line 60 of file testCubicalComplex.cpp.

Map

typedef std::map< Cell, CubicalCellData > Map

Examples:

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

Definition at line 58 of file testCubicalComplex.cpp.

Point

typedef KSpace::Point Point

Initial value:

{
  typedef KhalimskySpaceND<3>                       KSpace

Definition at line 54 of file testCubicalComplex.cpp.

Function Documentation

GIVEN()

GIVEN

(

"A cubical complex with random 3-cells"

)

Definition at line 71 of file testCubicalComplex.cpp.

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(), nbBdry(), nbBdry2(), NBCELLS, DGtal::CubicalComplex< TKSpace, TCellContainer >::nbCells(), nbCoFaces(), nbFaces(), nbFaces2(), and REQUIRE().

Referenced by SCENARIO(), and TEST_CASE_METHOD().

                                                   {
    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 = 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 );
            int 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 );
            int 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 );
            int 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 );
            int 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" ) {
  }

init()

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

nbBdry()

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

Referenced by GIVEN(), and SCENARIO().

nbBdry2()

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

Referenced by GIVEN(), and SCENARIO().

nbCoFaces()

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

Referenced by GIVEN(), and SCENARIO().

nbFaces()

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

Referenced by GIVEN(), and SCENARIO().

nbFaces2()

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

Referenced by GIVEN(), and SCENARIO().

SCENARIO() [1/6]

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

Definition at line 196 of file testCubicalComplex.cpp.

References CAPTURE(), DGtal::CubicalComplex< TKSpace, TCellContainer >::close(), DGtal::CubicalComplex< TKSpace, TCellContainer >::end(), DGtal::CubicalComplex< TKSpace, TCellContainer >::euler(), DGtal::CubicalComplex< TKSpace, TCellContainer >::findCell(), GIVEN(), DGtal::CubicalComplex< TKSpace, TCellContainer >::insertCell(), K, DGtal::CubicalComplex< TKSpace, TCellContainer >::nbCells(), REQUIRE(), and srand().

Referenced by SCENARIO().

{
  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 );
      }
    }
  }
}

SCENARIO() [2/6]

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

Definition at line 257 of file testCubicalComplex.cpp.

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 >::euler(), DGtal::CubicalComplex< TKSpace, TCellContainer >::faces(), GIVEN(), DGtal::CubicalComplex< TKSpace, TCellContainer >::insert(), DGtal::CubicalComplex< TKSpace, TCellContainer >::insertCell(), K, DGtal::CubicalComplex< TKSpace, TCellContainer >::link(), nbBdry(), nbBdry2(), NBCELLS, DGtal::CubicalComplex< TKSpace, TCellContainer >::nbCells(), nbCoFaces(), nbFaces(), nbFaces2(), REQUIRE(), SCENARIO(), and srand().

{
  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 );
      }
    }
  }
}

SCENARIO() [3/6]

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

Definition at line 455 of file testCubicalComplex.cpp.

References CAPTURE(), DGtal::CubicalComplex< TKSpace, TCellContainer >::close(), DGtal::CubicalComplex< TKSpace, TCellContainer >::end(), DGtal::CubicalComplex< TKSpace, TCellContainer >::euler(), DGtal::CubicalComplex< TKSpace, TCellContainer >::findCell(), GIVEN(), DGtal::CubicalComplex< TKSpace, TCellContainer >::insertCell(), K, DGtal::CubicalComplex< TKSpace, TCellContainer >::nbCells(), REQUIRE(), and srand().

{
  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 );
      }
    }
  }
}

SCENARIO() [4/6]

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

Definition at line 516 of file testCubicalComplex.cpp.

References DGtal::CubicalComplex< TKSpace, TCellContainer >::close(), DGtal::CubicalComplex< TKSpace, TCellContainer >::euler(), GIVEN(), DGtal::CubicalComplex< TKSpace, TCellContainer >::insert(), DGtal::CubicalComplex< TKSpace, TCellContainer >::insertCell(), K, DGtal::CubicalComplex< TKSpace, TCellContainer >::link(), REQUIRE(), and srand().

{
  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 );
      }
    }
  }
}

SCENARIO() [5/6]

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

Definition at line 564 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() [6/6]

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

Definition at line 577 of file testCubicalComplex.cpp.

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

{
  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;

  using namespace DGtal::functions;

  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 );
}

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:

geometry/curves/estimation/exampleCurvature.cpp, io/boards/dgtalBoard3D-2-ks.cpp, io/boards/dgtalBoard3DTo2D-KSCell.cpp, io/viewDualSurface.cpp, io/viewers/viewer3D-10-interaction.cpp, io/viewers/viewer3D-4bis-illustrationMode.cpp, topology/3dKSSurfaceExtraction.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 63 of file testCubicalComplex.cpp.

Referenced by accuracyTest(), ballGenerator(), estimatorOnShapeDigitization(), main(), Object3D(), DGtal::functions::operator>=(), SCENARIO(), TEST_CASE(), testBallQuad(), testCombinatorialSurface(), testCompareEstimator(), testComputeInterior(), testCube(), testCurvature2d(), testDigitalSetBoundary(), testDigitalSurface(), testDigitalSurfaceBoostGraphInterface(), testDigitization(), testEmbedder(), testEstimatorCache(), testExplicitDigitalSurface(), testFindABel(), testFitting(), testGaussianCurvature3d(), DGtal::testImplicitDigitalSurface(), testImplicitDigitalSurface(), testLightExplicitDigitalSurface(), DGtal::testLightImplicitDigitalSurface(), testLightImplicitDigitalSurface(), testLocalEstimatorFromFunctorAdapter(), testMeanCurvature3d(), testObjectGraph(), testPrincipalCurvatures3d(), testRaySurface(), testTrueLocalEstimatorOnShapeDigitization(), and testUmbrellaComputer().

NBCELLS

const int NBCELLS = 1000

static

Definition at line 51 of file testCubicalComplex.cpp.

Referenced by GIVEN(), and SCENARIO().