Aim: represents a d-dimensional complex in a d-dimensional space with the following properties and restrictions: More...

#include <DGtal/geometry/volumes/ConvexCellComplex.h>

Public Types
typedef TPoint	Point

typedef std::size_t	Index

typedef std::size_t	Size

typedef Index	Cell

typedef std::pair< Index, bool >	Face

typedef Index	Vertex

typedef std::vector< Index >	IndexRange

typedef std::vector< Vertex >	VertexRange

typedef std::vector< Face >	FaceRange

typedef Point::Coordinate	Scalar

typedef PointVector< dimension, Scalar >	Vector

typedef PointVector< dimension, double >	RealPoint

typedef PointVector< dimension, double >	RealVector

Public Member Functions
Standard services
	ConvexCellComplex ()
	Defaut constructor. More...

void	clear ()
	Clears the complex (as if it was just default constructed). More...

Size	nbCells () const

Size	nbFaces () const

Size	nbVertices () const

Primal structure topology services
Cell	infiniteCell () const

bool	isInfinite (const Cell c) const

Face	opposite (const Face f) const

const FaceRange &	cellFaces (const Cell c) const

const VertexRange &	cellVertices (const Cell c) const

const std::vector< VertexRange > &	allCellVertices () const

VertexRange	faceVertices (const Face f) const

Cell	faceCell (const Face f) const

VertexRange	faceComplementVertices (const Face f) const

Primal structure geometry services
std::vector< Point >	cellVertexPositions (const Cell c) const

std::vector< Point >	faceVertexPositions (const Face f) const

Point	position (const Vertex v) const

RealPoint	toReal (const Point p) const

template<typename LatticePoint >
LatticePoint	toLattice (const RealPoint p, double factor=1.0) const

RealPoint	cellBarycenter (const Cell c) const

template<typename LatticePolytope >
LatticePolytope	cellLatticePolytope (const Cell c, const double factor=1.0) const

const Vector &	faceNormal (const Face f) const

Scalar	faceIntercept (const Face f) const

bool	hasFaceGeometry () const

void	requireFaceGeometry ()
	Forces the computation of face geometry. More...

void	unrequireFaceGeometry ()
	Release ressources allocated to face geometry. More...

Interface
void	selfDisplay (std::ostream &out) const

bool	isValid () const

Data Fields
Data for primal structure
std::vector< FaceRange >	cell_faces
	Tells if the face geometry has been computed. More...

std::vector< VertexRange >	cell_vertices
	Tells if the face geometry has been computed. More...

std::vector< Cell >	true_face_cell
	Tells if the face geometry has been computed. More...

std::vector< Cell >	false_face_cell
	Tells if the face geometry has been computed. More...

std::vector< VertexRange >	true_face_vertices
	Tells if the face geometry has been computed. More...

std::vector< Point >	vertex_position
	Tells if the face geometry has been computed. More...

bool	has_face_geometry
	Tells if the face geometry has been computed. More...

std::vector< Vector >	true_face_normal
	Contains the outward oriented normal of each 'true' face. More...

std::vector< Scalar >	true_face_intercept
	Contains the intercept of each 'true' face. More...

Static Public Attributes
static const Dimension	dimension = TPoint::dimension

static const Index	INFINITE_CELL = (Index) -1

Protected Member Functions
Protected services
void	computeCellVertices (const Cell c) const

void	computeFaceGeometry ()
	Computes for each face its outward oriented normal vector. More...

std::pair< Vector, Scalar >	computeHalfSpace (const VertexRange &v) const

void	reorderFaceVertices (Index f)

Detailed Description

template<typename TPoint>
struct DGtal::ConvexCellComplex< TPoint >

Aim: represents a d-dimensional complex in a d-dimensional space with the following properties and restrictions:

Description of template class 'ConvexCellComplex'

- all cells (maximal and below) are convex

k-cells span a k-dimensional affine space
cells are convex, their geometry is described by their vertices
the boundary of each d-cell is composed of d-1-cells, called faces
each face is shared by two d-cells (one can be infinite), but are viewed with opposite orientation from each d-cell
each vertex hold its position
cells may be spherical (their vertices are cospherical) if the complex comes from a Delaunay triangulation.

All cells are indexed per dimension, starting from 0, hence:

vertices are numbered from 0 to nbVertices()-1
faces are numbered from 0 to nbFaces()-1
cells are numbered from 0 to nbCells()-1 (the infinite cell is not in this range).

The ConvexCellComplex is used to represent the Delaunay decomposition into convex cells of a range of points. It is built with ConvexityHelper functions like ConvexityHelper::computeDelaunayCellComplex.

Template Parameters

TPoint an arbitrary model of Point.

See also: moduleQuickHull

Examples: geometry/tools/exampleLatticeBallDelaunay3D.cpp, geometry/tools/exampleQuickHull3D.cpp, and geometry/tools/exampleRationalBallDelaunay3D.cpp.

Definition at line 85 of file ConvexCellComplex.h.

Member Typedef Documentation

◆ Cell

template<typename TPoint >

typedef Index DGtal::ConvexCellComplex< TPoint >::Cell

Definition at line 93 of file ConvexCellComplex.h.

◆ Face

template<typename TPoint >

typedef std::pair< Index, bool > DGtal::ConvexCellComplex< TPoint >::Face

Definition at line 94 of file ConvexCellComplex.h.

◆ FaceRange

template<typename TPoint >

typedef std::vector< Face > DGtal::ConvexCellComplex< TPoint >::FaceRange

Definition at line 98 of file ConvexCellComplex.h.

◆ Index

template<typename TPoint >

typedef std::size_t DGtal::ConvexCellComplex< TPoint >::Index

Definition at line 89 of file ConvexCellComplex.h.

◆ IndexRange

template<typename TPoint >

typedef std::vector< Index > DGtal::ConvexCellComplex< TPoint >::IndexRange

Definition at line 96 of file ConvexCellComplex.h.

◆ Point

template<typename TPoint >

typedef TPoint DGtal::ConvexCellComplex< TPoint >::Point

Definition at line 88 of file ConvexCellComplex.h.

◆ RealPoint

template<typename TPoint >

typedef PointVector< dimension, double > DGtal::ConvexCellComplex< TPoint >::RealPoint

Definition at line 102 of file ConvexCellComplex.h.

◆ RealVector

template<typename TPoint >

typedef PointVector< dimension, double > DGtal::ConvexCellComplex< TPoint >::RealVector

Definition at line 103 of file ConvexCellComplex.h.

◆ Scalar

template<typename TPoint >

typedef Point::Coordinate DGtal::ConvexCellComplex< TPoint >::Scalar

Definition at line 100 of file ConvexCellComplex.h.

◆ Size

template<typename TPoint >

typedef std::size_t DGtal::ConvexCellComplex< TPoint >::Size

Definition at line 90 of file ConvexCellComplex.h.

◆ Vector

template<typename TPoint >

typedef PointVector< dimension, Scalar > DGtal::ConvexCellComplex< TPoint >::Vector

Definition at line 101 of file ConvexCellComplex.h.

◆ Vertex

template<typename TPoint >

typedef Index DGtal::ConvexCellComplex< TPoint >::Vertex

Definition at line 95 of file ConvexCellComplex.h.

◆ VertexRange

template<typename TPoint >

typedef std::vector< Vertex > DGtal::ConvexCellComplex< TPoint >::VertexRange

Definition at line 97 of file ConvexCellComplex.h.

Constructor & Destructor Documentation

◆ ConvexCellComplex()

template<typename TPoint >

DGtal::ConvexCellComplex< TPoint >::ConvexCellComplex ( )

inline

Defaut constructor.

Definition at line 111 of file ConvexCellComplex.h.

112 { clear(); }

DGtal::ConvexCellComplex::clear

void clear()

Clears the complex (as if it was just default constructed).

Definition: ConvexCellComplex.h:115

References DGtal::ConvexCellComplex< TPoint >::clear().

Member Function Documentation

◆ allCellVertices()

template<typename TPoint >

const std::vector< VertexRange > & DGtal::ConvexCellComplex< TPoint >::allCellVertices ( ) const

inline

Returns: the range of vertex ranges giving for each cell its vertices.

Definition at line 181 of file ConvexCellComplex.h.

    {
      if ( cell_vertices.empty() )
        cell_vertices.resize( nbCells() );
      for ( Index c = 0; c < nbCells(); ++c )
        if ( cell_vertices[ c ].empty() )
          computeCellVertices( c );
      return cell_vertices;
    }

References DGtal::ConvexCellComplex< TPoint >::cell_vertices, DGtal::ConvexCellComplex< TPoint >::computeCellVertices(), and DGtal::ConvexCellComplex< TPoint >::nbCells().

◆ cellBarycenter()

template<typename TPoint >

RealPoint DGtal::ConvexCellComplex< TPoint >::cellBarycenter ( const Cell c ) const

inline

Parameters

[in] c any valid cell

Returns: the cell barycenter.

Examples: geometry/tools/exampleLatticeBallDelaunay3D.cpp, and geometry/tools/exampleRationalBallDelaunay3D.cpp.

Definition at line 286 of file ConvexCellComplex.h.

    {
      ASSERT( ! isInfinite( c ) );
      RealPoint b;
      const auto& vtcs = cellVertices( c );
      for ( auto v : vtcs )
        b += toReal( position( v ) );
      return b / vtcs.size();
    }

References DGtal::ConvexCellComplex< TPoint >::cellVertices(), DGtal::ConvexCellComplex< TPoint >::isInfinite(), DGtal::ConvexCellComplex< TPoint >::position(), and DGtal::ConvexCellComplex< TPoint >::toReal().

Referenced by main().

◆ cellFaces()

template<typename TPoint >

const FaceRange & DGtal::ConvexCellComplex< TPoint >::cellFaces ( const Cell c ) const

inline

Parameters

[in] c any valid cell

Returns: its range of faces.

Examples: geometry/tools/exampleLatticeBallDelaunay3D.cpp, and geometry/tools/exampleRationalBallDelaunay3D.cpp.

Definition at line 161 of file ConvexCellComplex.h.

162 { return cell_faces[ c ]; }

DGtal::ConvexCellComplex::cell_faces

std::vector< FaceRange > cell_faces

Tells if the face geometry has been computed.

Definition: ConvexCellComplex.h:376

References DGtal::ConvexCellComplex< TPoint >::cell_faces.

Referenced by DGtal::ConvexCellComplex< TPoint >::cellLatticePolytope(), DGtal::ConvexCellComplex< TPoint >::computeFaceGeometry(), and main().

◆ cellLatticePolytope()

template<typename TPoint >

template<typename LatticePolytope >

LatticePolytope DGtal::ConvexCellComplex< TPoint >::cellLatticePolytope	(	const Cell	c,
		const double	factor = `1.0`
	)		const

inline

Precondition: hasFaceGeometry() == true

Parameters

[in]	c	any valid cell
[in]	factor	the dilation applied to all points before integer conversion

Returns: the corresponding polytope

Definition at line 302 of file ConvexCellComplex.h.

    {
      ASSERT( hasFaceGeometry() );
      ASSERT( ! isInfinite( c ) );
      typedef typename LatticePolytope::Point     LatticePoint;
      typedef typename LatticePolytope::HalfSpace HalfSpace;
      typedef typename LatticePolytope::Domain    Domain;
      const auto vtcs = cellVertices( c );
      std::vector< LatticePoint > pts;
      for ( auto v : vtcs )
        pts.push_back( toLattice< LatticePoint >( position ( v ), factor ) );
      LatticePoint l = pts[ 0 ];
      LatticePoint u = pts[ 0 ];
      for ( const auto& p : pts ) {
        l = l.inf( p );
        u = u.sup( p );
      }
      Domain domain( l, u );
      std::vector< HalfSpace > HS;
      for ( auto f : cellFaces( c ) ) {
        HS.emplace_back( faceNormal( f ), faceIntercept( f ) );
      }
      return LatticePolytope( domain, HS.cbegin(), HS.cend(), false );
    }

References DGtal::ConvexCellComplex< TPoint >::cellFaces(), DGtal::ConvexCellComplex< TPoint >::cellVertices(), domain, DGtal::ConvexCellComplex< TPoint >::faceIntercept(), DGtal::ConvexCellComplex< TPoint >::faceNormal(), DGtal::ConvexCellComplex< TPoint >::hasFaceGeometry(), DGtal::ConvexCellComplex< TPoint >::isInfinite(), and DGtal::ConvexCellComplex< TPoint >::position().

◆ cellVertexPositions()

template<typename TPoint >

std::vector< Point > DGtal::ConvexCellComplex< TPoint >::cellVertexPositions ( const Cell c ) const

inline

Parameters

[in] c any valid cell (non infinite)

Returns: the range of positions of all cell vertices

Definition at line 233 of file ConvexCellComplex.h.

    {
      ASSERT( ! isInfinite( c ) );
      const auto vtcs = cellVertices( c );
      std::vector< Point > pts( vtcs.size() );
      std::transform( vtcs.cbegin(), vtcs.cend(), pts.begin(),
                      [&] ( Vertex v ) { return this->position( v ); } );
      return pts;
    }

References DGtal::ConvexCellComplex< TPoint >::cellVertices(), and DGtal::ConvexCellComplex< TPoint >::isInfinite().

◆ cellVertices()

template<typename TPoint >

const VertexRange & DGtal::ConvexCellComplex< TPoint >::cellVertices ( const Cell c ) const

inline

Lazy computation of cell vertices from face vertices if they were not given.

Parameters

[in] c any (finite) cell

Returns: its vertices

Examples: geometry/tools/exampleLatticeBallDelaunay3D.cpp, and geometry/tools/exampleRationalBallDelaunay3D.cpp.

Definition at line 169 of file ConvexCellComplex.h.

    {
      ASSERT( c != INFINITE_CELL && c < nbCells() );
      ASSERT( ! cell_vertices.empty() );
      if ( cell_vertices.empty() )
        cell_vertices.resize( nbCells() );
      if ( cell_vertices[ c ].empty() )
        computeCellVertices( c );
      return cell_vertices[ c ];
    }

References DGtal::ConvexCellComplex< TPoint >::cell_vertices, DGtal::ConvexCellComplex< TPoint >::computeCellVertices(), DGtal::ConvexCellComplex< TPoint >::INFINITE_CELL, and DGtal::ConvexCellComplex< TPoint >::nbCells().

Referenced by DGtal::ConvexCellComplex< TPoint >::cellBarycenter(), DGtal::ConvexCellComplex< TPoint >::cellLatticePolytope(), DGtal::ConvexCellComplex< TPoint >::cellVertexPositions(), DGtal::ConvexCellComplex< TPoint >::computeFaceGeometry(), DGtal::ConvexCellComplex< TPoint >::faceComplementVertices(), and main().

◆ clear()

template<typename TPoint >

void DGtal::ConvexCellComplex< TPoint >::clear ( )

inline

Clears the complex (as if it was just default constructed).

Definition at line 115 of file ConvexCellComplex.h.

    {
      cell_faces.clear();
      cell_vertices.clear();
      true_face_cell.clear();
      false_face_cell.clear();
      true_face_vertices.clear();
      vertex_position.clear();
      has_face_geometry = false;
      true_face_normal.clear();
      true_face_intercept.clear();
    }

References DGtal::ConvexCellComplex< TPoint >::cell_faces, DGtal::ConvexCellComplex< TPoint >::cell_vertices, DGtal::ConvexCellComplex< TPoint >::false_face_cell, DGtal::ConvexCellComplex< TPoint >::has_face_geometry, DGtal::ConvexCellComplex< TPoint >::true_face_cell, DGtal::ConvexCellComplex< TPoint >::true_face_intercept, DGtal::ConvexCellComplex< TPoint >::true_face_normal, DGtal::ConvexCellComplex< TPoint >::true_face_vertices, and DGtal::ConvexCellComplex< TPoint >::vertex_position.

Referenced by DGtal::ConvexCellComplex< TPoint >::ConvexCellComplex().

◆ computeCellVertices()

template<typename TPoint >

void DGtal::ConvexCellComplex< TPoint >::computeCellVertices ( const Cell c ) const

inlineprotected

computes the vertices of a given cell c upon request.

Parameters

c	any valid cell

Definition at line 432 of file ConvexCellComplex.h.

    {
      std::set< Vertex > vertices;
      for ( auto f : cell_faces[ c ] )
        vertices.insert( true_face_vertices[ f.first ].cbegin(),
                         true_face_vertices[ f.first ].cend() );
      cell_vertices[ c ] = VertexRange( vertices.cbegin(), vertices.cend() );
    }

References DGtal::ConvexCellComplex< TPoint >::cell_faces, DGtal::ConvexCellComplex< TPoint >::cell_vertices, and DGtal::ConvexCellComplex< TPoint >::true_face_vertices.

Referenced by DGtal::ConvexCellComplex< TPoint >::allCellVertices(), and DGtal::ConvexCellComplex< TPoint >::cellVertices().

◆ computeFaceGeometry()

template<typename TPoint >

void DGtal::ConvexCellComplex< TPoint >::computeFaceGeometry ( )

inlineprotected

Computes for each face its outward oriented normal vector.

Definition at line 442 of file ConvexCellComplex.h.

    {
      true_face_normal   .resize( nbFaces() );
      true_face_intercept.resize( nbFaces() );
      // Compute normals and intercepts
      for ( Index f = 0; f < nbFaces(); ++f ) {
        std::tie( true_face_normal[ f ], true_face_intercept[ f ] )
          = computeHalfSpace( true_face_vertices[ f ] );
        if ( true_face_normal[ f ] == Vector::zero )
          trace.error() << "[ConvexCellComplex::computeFaceGeometry]"
                        << " null normal vector at face " << f << std::endl;
      }
      // Orient them consistently
      for ( Index c = 0; c < nbCells(); c++ ) {
        const auto& c_vtcs = cellVertices( c );
        for ( auto f : cellFaces( c ) ) {
          if ( ! f.second ) continue; // process only 'true' faces
          const   auto ov = faceComplementVertices( f );
          ASSERT( ! ov.empty() );
          const Vector  N = true_face_normal   [ f.first ];
          const Scalar nu = true_face_intercept[ f.first ];
          const Scalar iv = N.dot( position( ov.front() ) );
          if ( ( iv - nu ) > 0 ) {
            // Should be inside
            true_face_normal   [ f.first ] = -N;
            true_face_intercept[ f.first ] = -nu;
            std::reverse( true_face_vertices[ f.first ].begin(),
                          true_face_vertices[ f.first ].end() );
          }
          reorderFaceVertices( f.first );
        }
      }
      has_face_geometry = true;
    }

Referenced by DGtal::ConvexCellComplex< TPoint >::requireFaceGeometry().

◆ computeHalfSpace()

template<typename TPoint >

std::pair< Vector, Scalar > DGtal::ConvexCellComplex< TPoint >::computeHalfSpace ( const VertexRange & v ) const

inlineprotected

Parameters

v	a range of vertices of size() >= dimension

Returns: the pair normal/intercept of the face.

Definition at line 480 of file ConvexCellComplex.h.

    {
      typedef DGtal::SimpleMatrix< Scalar, dimension, dimension > Matrix;
      Matrix A;
      Vector N;
      Scalar c;
      for ( int i = 1; i < dimension; i++ )
        for ( int j = 0; j < dimension; j++ )
          A.setComponent( i-1, j, position( v[ i ] )[ j ] - position( v[ 0 ] )[ j ] );
      for ( int j = 0; j < dimension; j++ )
        N[ j ] = A.cofactor( dimension-1, j );
      c = N.dot( position( v[ 0 ] ) );
      return std::make_pair( N, c );
    }

References DGtal::ConvexCellComplex< TPoint >::dimension, DGtal::PointVector< dim, TEuclideanRing, TContainer >::dot(), and DGtal::ConvexCellComplex< TPoint >::position().

Referenced by DGtal::ConvexCellComplex< TPoint >::computeFaceGeometry().

◆ faceCell()

template<typename TPoint >

Cell DGtal::ConvexCellComplex< TPoint >::faceCell ( const Face f ) const

inline

Parameters

[in] f any face

Returns: its associated cell (or INFINITE_CELL)

Definition at line 202 of file ConvexCellComplex.h.

    {
      return f.second ? true_face_cell[ f.first ] : false_face_cell[ f.first ];
    }

References DGtal::ConvexCellComplex< TPoint >::false_face_cell, and DGtal::ConvexCellComplex< TPoint >::true_face_cell.

Referenced by DGtal::ConvexCellComplex< TPoint >::faceComplementVertices().

◆ faceComplementVertices()

template<typename TPoint >

VertexRange DGtal::ConvexCellComplex< TPoint >::faceComplementVertices ( const Face f ) const

inline

Parameters

[in] f any face

Returns: the vertices within the cell containing f that are not in f.

Definition at line 211 of file ConvexCellComplex.h.

    {
      VertexRange result;
      const Cell c = faceCell( f );
      if ( isInfinite( c ) ) return result;
      const auto& c_vtcs = cellVertices( c );
      auto        f_vtcs = true_face_vertices[ f.first ];
      std::sort( f_vtcs.begin(), f_vtcs.end() );
      for ( auto v : c_vtcs )
        if ( ! std::binary_search( f_vtcs.cbegin(), f_vtcs.cend(), v ) )
          result.push_back( v );
      return result;
    }

References DGtal::ConvexCellComplex< TPoint >::cellVertices(), DGtal::ConvexCellComplex< TPoint >::faceCell(), DGtal::ConvexCellComplex< TPoint >::isInfinite(), and DGtal::ConvexCellComplex< TPoint >::true_face_vertices.

Referenced by DGtal::ConvexCellComplex< TPoint >::computeFaceGeometry().

◆ faceIntercept()

template<typename TPoint >

Scalar DGtal::ConvexCellComplex< TPoint >::faceIntercept ( const Face f ) const

inline

Precondition: hasFaceGeometry() == true

Parameters

[in] f any face

Returns: its intercept.

Definition at line 341 of file ConvexCellComplex.h.

    {
      ASSERT( hasFaceGeometry() );
      ASSERT( f.first < nbFaces() );
      if ( f.second ) return  true_face_intercept[ f.first ];
      else            return -true_face_intercept[ f.first ];
    }

References DGtal::ConvexCellComplex< TPoint >::hasFaceGeometry(), DGtal::ConvexCellComplex< TPoint >::nbFaces(), and DGtal::ConvexCellComplex< TPoint >::true_face_intercept.

Referenced by DGtal::ConvexCellComplex< TPoint >::cellLatticePolytope().

◆ faceNormal()

template<typename TPoint >

const Vector & DGtal::ConvexCellComplex< TPoint >::faceNormal ( const Face f ) const

inline

Precondition: hasFaceGeometry() == true

Parameters

[in] f any face

Returns: its normal oriented outward its enclosing cell.

Definition at line 330 of file ConvexCellComplex.h.

    {
      ASSERT( hasFaceGeometry() );
      ASSERT( f.first < nbFaces() );
      if ( f.second ) return  true_face_normal[ f.first ];
      else            return -true_face_normal[ f.first ];
    }

References DGtal::ConvexCellComplex< TPoint >::hasFaceGeometry(), DGtal::ConvexCellComplex< TPoint >::nbFaces(), and DGtal::ConvexCellComplex< TPoint >::true_face_normal.

Referenced by DGtal::ConvexCellComplex< TPoint >::cellLatticePolytope().

◆ faceVertexPositions()

template<typename TPoint >

std::vector< Point > DGtal::ConvexCellComplex< TPoint >::faceVertexPositions ( const Face f ) const

inline

Parameters

[in] f any face

Returns: the range of positions of all face vertices

Definition at line 245 of file ConvexCellComplex.h.

    {
      const auto vtcs = faceVertices( f );
      std::vector< Point > pts( vtcs.size() );
      std::transform( vtcs.cbegin(), vtcs.cend(), pts.begin(),
                      [&] ( Vertex v ) { return this->position( v ); } );
      return pts;
    }

References DGtal::ConvexCellComplex< TPoint >::faceVertices().

◆ faceVertices()

template<typename TPoint >

VertexRange DGtal::ConvexCellComplex< TPoint >::faceVertices ( const Face f ) const

inline

Parameters

[in] f any face

Returns: its vertices (in order depending on the side of the face)

Examples: geometry/tools/exampleLatticeBallDelaunay3D.cpp, and geometry/tools/exampleRationalBallDelaunay3D.cpp.

Definition at line 193 of file ConvexCellComplex.h.

    {
      if ( f.second ) return true_face_vertices[ f.first ];
      return VertexRange( true_face_vertices[ f.first ].crbegin(),
                          true_face_vertices[ f.first ].crend() );
    }

References DGtal::ConvexCellComplex< TPoint >::true_face_vertices.

Referenced by DGtal::ConvexCellComplex< TPoint >::faceVertexPositions(), and main().

◆ hasFaceGeometry()

template<typename TPoint >

bool DGtal::ConvexCellComplex< TPoint >::hasFaceGeometry ( ) const

inline

Returns: 'true' iff the face geometry is computed.

Definition at line 350 of file ConvexCellComplex.h.

351 { return has_face_geometry; }

References DGtal::ConvexCellComplex< TPoint >::has_face_geometry.

Referenced by DGtal::ConvexCellComplex< TPoint >::cellLatticePolytope(), DGtal::ConvexCellComplex< TPoint >::faceIntercept(), DGtal::ConvexCellComplex< TPoint >::faceNormal(), DGtal::ConvexCellComplex< TPoint >::requireFaceGeometry(), and DGtal::ConvexCellComplex< TPoint >::selfDisplay().

◆ infiniteCell()

template<typename TPoint >

Cell DGtal::ConvexCellComplex< TPoint >::infiniteCell ( ) const

inline

Returns: the index of the infinite cell.

Definition at line 145 of file ConvexCellComplex.h.

146 { return INFINITE_CELL; }

References DGtal::ConvexCellComplex< TPoint >::INFINITE_CELL.

◆ isInfinite()

template<typename TPoint >

bool DGtal::ConvexCellComplex< TPoint >::isInfinite ( const Cell c ) const

inline

Parameters

[in] c any cell

Returns: 'true' is the cell is infinite

Definition at line 150 of file ConvexCellComplex.h.

151 { return c == INFINITE_CELL; }

References DGtal::ConvexCellComplex< TPoint >::INFINITE_CELL.

Referenced by DGtal::ConvexCellComplex< TPoint >::cellBarycenter(), DGtal::ConvexCellComplex< TPoint >::cellLatticePolytope(), DGtal::ConvexCellComplex< TPoint >::cellVertexPositions(), and DGtal::ConvexCellComplex< TPoint >::faceComplementVertices().

◆ isValid()

template<typename TPoint >

bool DGtal::ConvexCellComplex< TPoint >::isValid ( ) const

inline

Checks the validity/consistency of the object.

Returns: 'true' if the object is valid (at least one cell), 'false' otherwise.

Definition at line 419 of file ConvexCellComplex.h.

    {
      return nbCells() != 0;
    }

References DGtal::ConvexCellComplex< TPoint >::nbCells().

◆ nbCells()

template<typename TPoint >

Size DGtal::ConvexCellComplex< TPoint >::nbCells ( ) const

inline

Returns: the number of finite cells with maximal dimension

Examples: geometry/tools/exampleLatticeBallDelaunay3D.cpp, and geometry/tools/exampleRationalBallDelaunay3D.cpp.

Definition at line 129 of file ConvexCellComplex.h.

130 { return cell_faces.size(); }

References DGtal::ConvexCellComplex< TPoint >::cell_faces.

Referenced by DGtal::ConvexCellComplex< TPoint >::allCellVertices(), DGtal::ConvexCellComplex< TPoint >::cellVertices(), DGtal::ConvexCellComplex< TPoint >::computeFaceGeometry(), DGtal::ConvexCellComplex< TPoint >::isValid(), main(), and DGtal::ConvexCellComplex< TPoint >::selfDisplay().

◆ nbFaces()

template<typename TPoint >

Size DGtal::ConvexCellComplex< TPoint >::nbFaces ( ) const

inline

Returns: the number of unoriented cells of codimension 1

Definition at line 132 of file ConvexCellComplex.h.

133 { return true_face_cell.size(); }

References DGtal::ConvexCellComplex< TPoint >::true_face_cell.

Referenced by DGtal::ConvexCellComplex< TPoint >::computeFaceGeometry(), DGtal::ConvexCellComplex< TPoint >::faceIntercept(), DGtal::ConvexCellComplex< TPoint >::faceNormal(), and DGtal::ConvexCellComplex< TPoint >::selfDisplay().

◆ nbVertices()

template<typename TPoint >

Size DGtal::ConvexCellComplex< TPoint >::nbVertices ( ) const

inline

Returns: the number of vertices

Definition at line 135 of file ConvexCellComplex.h.

136 { return vertex_position.size(); }

References DGtal::ConvexCellComplex< TPoint >::vertex_position.

Referenced by DGtal::ConvexCellComplex< TPoint >::selfDisplay().

◆ opposite()

template<typename TPoint >

Face DGtal::ConvexCellComplex< TPoint >::opposite ( const Face f ) const

inline

Parameters

[in] f any face

Returns: its opposite face

Definition at line 156 of file ConvexCellComplex.h.

157 { return std::make_pair( f.first, ! f.second ); }

◆ position()

template<typename TPoint >

Point DGtal::ConvexCellComplex< TPoint >::position ( const Vertex v ) const

inline

Parameters

[in] v any vertex

Returns: the vertex position

Examples: geometry/tools/exampleLatticeBallDelaunay3D.cpp, and geometry/tools/exampleRationalBallDelaunay3D.cpp.

Definition at line 256 of file ConvexCellComplex.h.

    {
      return vertex_position[ v ];
    }

References DGtal::ConvexCellComplex< TPoint >::vertex_position.

Referenced by DGtal::ConvexCellComplex< TPoint >::cellBarycenter(), DGtal::ConvexCellComplex< TPoint >::cellLatticePolytope(), DGtal::ConvexCellComplex< TPoint >::computeFaceGeometry(), DGtal::ConvexCellComplex< TPoint >::computeHalfSpace(), and main().

◆ reorderFaceVertices()

template<typename TPoint >

void DGtal::ConvexCellComplex< TPoint >::reorderFaceVertices ( Index f )

inlineprotected

Given a face index f, reorder all its vertices so that they are oriented consistently with respect to the normal.

Parameters

f	any valid face index

Note: the order of points is consistent if, picking any d-simplex in order in this range, their associated half-spaces have all the same orientation.

Definition at line 503 of file ConvexCellComplex.h.

    {
      VertexRange& result = true_face_vertices[ f ];
      Vector       N      = true_face_normal  [ f ];
      // Sort a facet such that its points, taken in order, have
      // always the same orientation of the facet.  More precisely,
      // facets span a `dimension-1` vector space. There are thus
      // dimension-2 fixed points, and the last ones (at least two)
      // may be reordered.
      VertexRange splx( dimension );
      for ( Dimension k = 0; k < dimension-2; k++ )
        splx[ k ] = result[ k ];
      std::sort( result.begin()+dimension-2, result.end(),
                 [&] ( Index i, Index j )
                 {
                   splx[ dimension-2 ] = i;
                   splx[ dimension-1 ] = j;
                   const auto H = computeHalfSpace( splx );
                   const auto orient = N.dot( H.first );
                   return orient > 0;
                 } );
    }

References DGtal::ConvexCellComplex< TPoint >::dimension, DGtal::ConvexCellComplex< TPoint >::true_face_normal, and DGtal::ConvexCellComplex< TPoint >::true_face_vertices.

Referenced by DGtal::ConvexCellComplex< TPoint >::computeFaceGeometry().

◆ requireFaceGeometry()

template<typename TPoint >

void DGtal::ConvexCellComplex< TPoint >::requireFaceGeometry ( )

inline

Forces the computation of face geometry.

Examples: geometry/tools/exampleLatticeBallDelaunay3D.cpp, and geometry/tools/exampleRationalBallDelaunay3D.cpp.

Definition at line 354 of file ConvexCellComplex.h.

    {
      if ( ! hasFaceGeometry() )
        computeFaceGeometry();
    }

References DGtal::ConvexCellComplex< TPoint >::computeFaceGeometry(), and DGtal::ConvexCellComplex< TPoint >::hasFaceGeometry().

Referenced by main().

◆ selfDisplay()

template<typename TPoint >

void DGtal::ConvexCellComplex< TPoint >::selfDisplay ( std::ostream & out ) const

inline

Writes/Displays the object on an output stream.

Parameters

out	the output stream where the object is written.

Definition at line 405 of file ConvexCellComplex.h.

    {
      out << "[ConvexCellComplex<" << dimension << ">"
          << " #C=" << nbCells()
          << " #F=" << nbFaces()
          << " #V=" << nbVertices();
      if ( hasFaceGeometry() ) out << " hasFaceGeometry";
      out << " ]";
    }

References DGtal::ConvexCellComplex< TPoint >::dimension, DGtal::ConvexCellComplex< TPoint >::hasFaceGeometry(), DGtal::ConvexCellComplex< TPoint >::nbCells(), DGtal::ConvexCellComplex< TPoint >::nbFaces(), and DGtal::ConvexCellComplex< TPoint >::nbVertices().

◆ toLattice()

template<typename TPoint >

template<typename LatticePoint >

LatticePoint DGtal::ConvexCellComplex< TPoint >::toLattice	(	const RealPoint	p,
		double	factor = `1.0`
	)		const

inline

Parameters

[in]	p	any real point
[in]	factor	the dilation applied to point p before integer conversion

Returns: its embedding in the real Euclidean space.

Definition at line 275 of file ConvexCellComplex.h.

    {
      LatticePoint x;
      for ( Dimension k = 0; k < dimension; ++k )
        x[ k ] = (typename LatticePoint::Coordinate) round( p[ k ] * factor );
      return x;
    }

References DGtal::ConvexCellComplex< TPoint >::dimension.

◆ toReal()

template<typename TPoint >

RealPoint DGtal::ConvexCellComplex< TPoint >::toReal ( const Point p ) const

inline

Parameters

[in] p any point

Returns: its embedding in the real Euclidean space.

Examples: geometry/tools/exampleLatticeBallDelaunay3D.cpp.

Definition at line 263 of file ConvexCellComplex.h.

    {
      RealPoint x;
      for ( Dimension k = 0; k < dimension; ++k )
        x[ k ] = (double) p[ k ];
      return x;
    }

References DGtal::ConvexCellComplex< TPoint >::dimension.

Referenced by DGtal::ConvexCellComplex< TPoint >::cellBarycenter(), and main().

◆ unrequireFaceGeometry()

template<typename TPoint >

void DGtal::ConvexCellComplex< TPoint >::unrequireFaceGeometry ( )

inline

Release ressources allocated to face geometry.

Definition at line 361 of file ConvexCellComplex.h.

    {
      has_face_geometry = false;
      true_face_normal.clear();
      true_face_intercept.clear();
    }

References DGtal::ConvexCellComplex< TPoint >::has_face_geometry, DGtal::ConvexCellComplex< TPoint >::true_face_intercept, and DGtal::ConvexCellComplex< TPoint >::true_face_normal.

Field Documentation

◆ cell_faces

template<typename TPoint >

std::vector< FaceRange > DGtal::ConvexCellComplex< TPoint >::cell_faces

Tells if the face geometry has been computed.

Definition at line 376 of file ConvexCellComplex.h.

Referenced by DGtal::ConvexCellComplex< TPoint >::cellFaces(), DGtal::ConvexCellComplex< TPoint >::clear(), DGtal::ConvexCellComplex< TPoint >::computeCellVertices(), and DGtal::ConvexCellComplex< TPoint >::nbCells().

◆ cell_vertices

template<typename TPoint >

std::vector< VertexRange > DGtal::ConvexCellComplex< TPoint >::cell_vertices

mutable

Tells if the face geometry has been computed.

Definition at line 378 of file ConvexCellComplex.h.

Referenced by DGtal::ConvexCellComplex< TPoint >::allCellVertices(), DGtal::ConvexCellComplex< TPoint >::cellVertices(), DGtal::ConvexCellComplex< TPoint >::clear(), and DGtal::ConvexCellComplex< TPoint >::computeCellVertices().

◆ dimension

template<typename TPoint >

const Dimension DGtal::ConvexCellComplex< TPoint >::dimension = TPoint::dimension

static

Definition at line 86 of file ConvexCellComplex.h.

Referenced by DGtal::ConvexCellComplex< TPoint >::computeHalfSpace(), DGtal::ConvexCellComplex< TPoint >::reorderFaceVertices(), DGtal::ConvexCellComplex< TPoint >::selfDisplay(), DGtal::ConvexCellComplex< TPoint >::toLattice(), and DGtal::ConvexCellComplex< TPoint >::toReal().

◆ false_face_cell

template<typename TPoint >

std::vector< Cell > DGtal::ConvexCellComplex< TPoint >::false_face_cell

Tells if the face geometry has been computed.

Definition at line 382 of file ConvexCellComplex.h.

Referenced by DGtal::ConvexCellComplex< TPoint >::clear(), and DGtal::ConvexCellComplex< TPoint >::faceCell().

◆ has_face_geometry

template<typename TPoint >

bool DGtal::ConvexCellComplex< TPoint >::has_face_geometry

Tells if the face geometry has been computed.

Definition at line 389 of file ConvexCellComplex.h.

Referenced by DGtal::ConvexCellComplex< TPoint >::clear(), DGtal::ConvexCellComplex< TPoint >::computeFaceGeometry(), DGtal::ConvexCellComplex< TPoint >::hasFaceGeometry(), and DGtal::ConvexCellComplex< TPoint >::unrequireFaceGeometry().

◆ INFINITE_CELL

template<typename TPoint >

const Index DGtal::ConvexCellComplex< TPoint >::INFINITE_CELL = (Index) -1

static

Definition at line 92 of file ConvexCellComplex.h.

Referenced by DGtal::ConvexCellComplex< TPoint >::cellVertices(), DGtal::ConvexCellComplex< TPoint >::infiniteCell(), and DGtal::ConvexCellComplex< TPoint >::isInfinite().

◆ true_face_cell

template<typename TPoint >

std::vector< Cell > DGtal::ConvexCellComplex< TPoint >::true_face_cell

Tells if the face geometry has been computed.

Definition at line 380 of file ConvexCellComplex.h.

Referenced by DGtal::ConvexCellComplex< TPoint >::clear(), DGtal::ConvexCellComplex< TPoint >::faceCell(), and DGtal::ConvexCellComplex< TPoint >::nbFaces().

◆ true_face_intercept

template<typename TPoint >

std::vector< Scalar > DGtal::ConvexCellComplex< TPoint >::true_face_intercept

Contains the intercept of each 'true' face.

Definition at line 393 of file ConvexCellComplex.h.

Referenced by DGtal::ConvexCellComplex< TPoint >::clear(), DGtal::ConvexCellComplex< TPoint >::computeFaceGeometry(), DGtal::ConvexCellComplex< TPoint >::faceIntercept(), and DGtal::ConvexCellComplex< TPoint >::unrequireFaceGeometry().

◆ true_face_normal

template<typename TPoint >

std::vector< Vector > DGtal::ConvexCellComplex< TPoint >::true_face_normal

Contains the outward oriented normal of each 'true' face.

Definition at line 391 of file ConvexCellComplex.h.

Referenced by DGtal::ConvexCellComplex< TPoint >::clear(), DGtal::ConvexCellComplex< TPoint >::computeFaceGeometry(), DGtal::ConvexCellComplex< TPoint >::faceNormal(), DGtal::ConvexCellComplex< TPoint >::reorderFaceVertices(), and DGtal::ConvexCellComplex< TPoint >::unrequireFaceGeometry().

◆ true_face_vertices

template<typename TPoint >

std::vector< VertexRange > DGtal::ConvexCellComplex< TPoint >::true_face_vertices

Tells if the face geometry has been computed.

Definition at line 384 of file ConvexCellComplex.h.

Referenced by DGtal::ConvexCellComplex< TPoint >::clear(), DGtal::ConvexCellComplex< TPoint >::computeCellVertices(), DGtal::ConvexCellComplex< TPoint >::computeFaceGeometry(), DGtal::ConvexCellComplex< TPoint >::faceComplementVertices(), DGtal::ConvexCellComplex< TPoint >::faceVertices(), and DGtal::ConvexCellComplex< TPoint >::reorderFaceVertices().

◆ vertex_position

template<typename TPoint >

std::vector< Point > DGtal::ConvexCellComplex< TPoint >::vertex_position

Tells if the face geometry has been computed.

Definition at line 386 of file ConvexCellComplex.h.

Referenced by DGtal::ConvexCellComplex< TPoint >::clear(), DGtal::ConvexCellComplex< TPoint >::nbVertices(), and DGtal::ConvexCellComplex< TPoint >::position().

The documentation for this struct was generated from the following file:

ConvexCellComplex.h

Public Types

Public Member Functions

Data Fields

Static Public Attributes

Protected Member Functions

Detailed Description

Member Typedef Documentation

◆ Cell

◆ Face

◆ FaceRange

◆ Index

◆ IndexRange

◆ Point

◆ RealPoint

◆ RealVector

◆ Scalar

◆ Size

◆ Vector

◆ Vertex

◆ VertexRange

Constructor & Destructor Documentation

◆ ConvexCellComplex()

Member Function Documentation

◆ allCellVertices()

◆ cellBarycenter()

◆ cellFaces()

◆ cellLatticePolytope()

◆ cellVertexPositions()

◆ cellVertices()

◆ clear()

◆ computeCellVertices()

◆ computeFaceGeometry()

◆ computeHalfSpace()

◆ faceCell()

◆ faceComplementVertices()

◆ faceIntercept()

◆ faceNormal()

◆ faceVertexPositions()

◆ faceVertices()

◆ hasFaceGeometry()

◆ infiniteCell()

◆ isInfinite()

◆ isValid()

◆ nbCells()

◆ nbFaces()

◆ nbVertices()

◆ opposite()

◆ position()

◆ reorderFaceVertices()

◆ requireFaceGeometry()

◆ selfDisplay()

◆ toLattice()

◆ toReal()

◆ unrequireFaceGeometry()

Field Documentation

◆ cell_faces

◆ cell_vertices

◆ dimension

◆ false_face_cell

◆ has_face_geometry

◆ INFINITE_CELL

◆ true_face_cell

◆ true_face_intercept

◆ true_face_normal

◆ true_face_vertices

◆ vertex_position