DGtal::ConvexCellComplex< TPoint > Struct Template Reference

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.
void	clear ()
	Clears the complex (as if it was just default constructed).
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.
void	unrequireFaceGeometry ()
	Release ressources allocated to face geometry.
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.
std::vector< VertexRange >	cell_vertices
	Tells if the face geometry has been computed.
std::vector< Cell >	true_face_cell
	Tells if the face geometry has been computed.
std::vector< Cell >	false_face_cell
	Tells if the face geometry has been computed.
std::vector< VertexRange >	true_face_vertices
	Tells if the face geometry has been computed.
std::vector< Point >	vertex_position
	Tells if the face geometry has been computed.
bool	has_face_geometry
	Tells if the face geometry has been computed.
std::vector< Vector >	true_face_normal
	Contains the outward oriented normal of each 'true' face.
std::vector< Scalar >	true_face_intercept
	Contains the intercept of each 'true' face.

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.
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

Examples

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

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.

    { clear(); }

References 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 cell_vertices, computeCellVertices(), and 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 cellVertices(), isInfinite(), position(), DGtal::PointVector< dim, TEuclideanRing, TContainer >::size(), and 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.

    { return cell_faces[ c ]; }

References cell_faces.

Referenced by cellLatticePolytope(), 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 cellFaces(), cellVertices(), domain, faceIntercept(), faceNormal(), hasFaceGeometry(), isInfinite(), position(), and toLattice().

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 cellVertices(), and 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 cell_vertices, computeCellVertices(), INFINITE_CELL, and nbCells().

Referenced by cellBarycenter(), cellLatticePolytope(), cellVertexPositions(), 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 cell_faces, cell_vertices, false_face_cell, has_face_geometry, true_face_cell, true_face_intercept, true_face_normal, true_face_vertices, and vertex_position.

Referenced by 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 cell_faces, cell_vertices, and true_face_vertices.

Referenced by allCellVertices(), and 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 ); //not used
        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;
    }

References cellFaces(), computeHalfSpace(), DGtal::PointVector< dim, TEuclideanRing, TContainer >::dot(), faceComplementVertices(), has_face_geometry, nbCells(), nbFaces(), position(), reorderFaceVertices(), DGtal::trace, true_face_intercept, true_face_normal, true_face_vertices, and DGtal::PointVector< dimension, Scalar >::zero.

Referenced by 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 dimension, DGtal::PointVector< dim, TEuclideanRing, TContainer >::dot(), and position().

Referenced by 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 false_face_cell, and true_face_cell.

Referenced by 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 cellVertices(), faceCell(), isInfinite(), and true_face_vertices.

Referenced by 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 hasFaceGeometry(), nbFaces(), and true_face_intercept.

Referenced by 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 hasFaceGeometry(), nbFaces(), and true_face_normal.

Referenced by 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 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 true_face_vertices.

Referenced by 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.

    { return has_face_geometry; } 

References has_face_geometry.

Referenced by cellLatticePolytope(), faceIntercept(), faceNormal(), requireFaceGeometry(), and 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.

    { return INFINITE_CELL; }

References 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.

    { return c == INFINITE_CELL; }

References INFINITE_CELL.

Referenced by cellBarycenter(), cellLatticePolytope(), cellVertexPositions(), and 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 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.

    { return cell_faces.size(); }

References cell_faces.

Referenced by allCellVertices(), cellVertices(), computeFaceGeometry(), isValid(), main(), and 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.

    { return true_face_cell.size(); }

References true_face_cell.

Referenced by computeFaceGeometry(), faceIntercept(), faceNormal(), and 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.

    { return vertex_position.size(); }

References vertex_position.

Referenced by 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.

    { 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 vertex_position.

Referenced by cellBarycenter(), cellLatticePolytope(), computeFaceGeometry(), 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 dimension, true_face_normal, and true_face_vertices.

Referenced by 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 computeFaceGeometry(), and 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 dimension, hasFaceGeometry(), nbCells(), nbFaces(), and 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 dimension.

Referenced by cellLatticePolytope().

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 dimension.

Referenced by 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 has_face_geometry, true_face_intercept, and 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 cellFaces(), clear(), computeCellVertices(), and 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 allCellVertices(), cellVertices(), clear(), and computeCellVertices().

dimension

template<typename TPoint>

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

static

Definition at line 86 of file ConvexCellComplex.h.

Referenced by computeHalfSpace(), reorderFaceVertices(), selfDisplay(), toLattice(), and 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 clear(), and 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 clear(), computeFaceGeometry(), hasFaceGeometry(), and 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 cellVertices(), infiniteCell(), and 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 clear(), faceCell(), and 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 clear(), computeFaceGeometry(), faceIntercept(), and 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 clear(), computeFaceGeometry(), faceNormal(), reorderFaceVertices(), and 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 clear(), computeCellVertices(), computeFaceGeometry(), faceComplementVertices(), faceVertices(), and 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 clear(), nbVertices(), and position().

---

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

• ConvexCellComplex.h