Geogram  Version 1.9.1-rc
A programming library of geometric algorithms
GEO::RestrictedVoronoiDiagram Class Referenceabstract

Computes a Restricted Voronoi Diagram (RVD). More...

#include <geogram/voronoi/RVD.h>

Inheritance diagram for GEO::RestrictedVoronoiDiagram:
GEO::Counted

Public Types

enum  RDTMode {
  RDT_SEEDS_ALWAYS =0 , RDT_MULTINERVE =1 , RDT_RVC_CENTROIDS =2 , RDT_PREFER_SEEDS =4 ,
  RDT_SELECT_NEAREST =8 , RDT_PROJECT_ON_SURFACE =16 , RDT_DONT_REPAIR =32
}
 Determines the operating mode of compute_RDT(). More...
 

Public Member Functions

coord_index_t dimension () const
 Gets the dimension used by this RestrictedVoronoiDiagram.
 
Delaunaydelaunay ()
 Gets the Delaunay triangulation.
 
virtual void set_delaunay (Delaunay *delaunay)
 Sets the Delaunay triangulation.
 
bool volumetric () const
 Tests whether volumetric mode is used.
 
virtual void set_volumetric (bool x)=0
 Sets volumetric mode. More...
 
bool compute_initial_sampling (double *p, index_t nb_points, bool verbose=false)
 Computes a random initial sampling in nD. More...
 
virtual bool compute_initial_sampling_on_surface (double *p, index_t nb_points, bool verbose)=0
 Computes a random initial sampling of the surface in nD. More...
 
virtual bool compute_initial_sampling_in_volume (double *p, index_t nb_points, bool verbose)=0
 Computes a random initial sampling of the volume in nD. More...
 
virtual void compute_centroids_on_surface (double *mg, double *m)=0
 Computes the centroids and masses of the Voronoi cells restricted to the surface. More...
 
virtual void compute_centroids_in_volume (double *mg, double *m)=0
 Computes the centroids and masses of the Voronoi cells restricted to the volume. More...
 
void compute_centroids (double *mg, double *m)
 Computes the centroids and masses of the restricted Voronoi cells. More...
 
virtual void compute_CVT_func_grad_on_surface (double &f, double *g)=0
 Computes the value and gradient of Lloyd's function (quantization noise power) on the surface. More...
 
virtual void compute_CVT_func_grad_in_volume (double &f, double *g)=0
 Computes the value and gradient of Lloyd's function (quantization noise power) in the volume. More...
 
void compute_CVT_func_grad (double &f, double *g)
 Computes the value and gradient of Lloyd's function (quantization noise power). More...
 
virtual void compute_integration_simplex_func_grad (double &f, double *g, IntegrationSimplex *F)=0
 Computes the value and gradient of an objective function over Voronoi cells decomposed into simplices. More...
 
virtual void project_points_on_surface (index_t nb_points, double *points, vec3 *nearest, bool do_project=false)=0
 Computes the projection of points onto the surface in nD space. More...
 
void project_points_on_surface (index_t nb_points, double *points, vector< vec3 > &nearest, bool do_project=false)
 Computes the projection of points onto the surface in nD space. More...
 
void project_points_on_surface (index_t nb_points, double *points, vector< double > &nearest, bool do_project=false)
 Computes the projection of points onto the surface in nD space. More...
 
virtual void compute_RDT (vector< index_t > &simplices, vector< double > &embedding, RDTMode mode=RDTMode(RDT_RVC_CENTROIDS|RDT_PREFER_SEEDS), const vector< bool > &seed_is_locked=vector< bool >(), MeshFacetsAABB *AABB=nullptr)=0
 Computes the restricted Delaunay triangulation. More...
 
void compute_RDT (Mesh &RDT, RDTMode mode=RDTMode(RDT_RVC_CENTROIDS|RDT_PREFER_SEEDS), const vector< bool > &seed_is_locked=vector< bool >(), MeshFacetsAABB *AABB=nullptr)
 Computes the restricted Delaunay triangulation. More...
 
virtual void compute_RVD (Mesh &M, coord_index_t dim=0, bool cell_borders_only=false, bool integration_simplices=false)=0
 Computes the restricted Voronoi diagram and stores it in a mesh. More...
 
virtual void compute_RVC (index_t i, Mesh &M, Mesh &result, bool copy_symbolic_info=false)=0
 Computes a restricted Voronoi cell. More...
 
virtual void for_each_polyhedron (RVDPolyhedronCallback &callback, bool symbolic=true, bool connected_comp_priority=true, bool parallel=false)=0
 Invokes a user callback for each intersection polyhedron of the restricted Voronoi diagram (volumetric mode only). More...
 
virtual void for_each_polygon (RVDPolygonCallback &callback, bool symbolic=true, bool connected_comp_priority=true, bool parallel=false)=0
 Invokes a user callback for each intersection polygon of the restricted Voronoi diagram (surfacic mode only). More...
 
virtual void set_check_SR (bool x)=0
 Specifies whether the "radius of security" criterion should be enforced.
 
virtual void set_exact_predicates (bool x)=0
 Specifies whether exact predicates should be used.
 
virtual bool exact_predicates () const =0
 Tests whether exact predicates are used.
 
virtual void create_threads ()=0
 Partitions the mesh and creates local storage for multithreaded implementation.
 
virtual void delete_threads ()=0
 Deletes all the local storage associated with the threads.
 
virtual void set_facets_range (index_t facets_begin, index_t facets_end)=0
 Restricts surfacic computations to a part of the input mesh. More...
 
virtual void set_tetrahedra_range (index_t tets_begin, index_t tets_end)=0
 Restricts volumetric computations to a part of the input mesh. More...
 
const vec3R3_embedding (index_t v) const
 Gets the mapping in R3 of a point. More...
 
Meshmesh ()
 Gets the input mesh.
 
virtual GEOGen::PointAllocatorpoint_allocator ()=0
 Gets the PointAllocator. More...
 
- Public Member Functions inherited from GEO::Counted
void ref () const
 Increments the reference count. More...
 
void unref () const
 Decrements the reference count. More...
 
bool is_shared () const
 Check if the object is shared. More...
 
int nb_refs () const
 Gets the number of references that point to this object. More...
 

Static Public Member Functions

static RestrictedVoronoiDiagramcreate (Delaunay *delaunay, Mesh *mesh, const double *R3_embedding, index_t R3_embedding_stride)
 Creates a RestrictedVoronoiDiagram. More...
 
static RestrictedVoronoiDiagramcreate (Delaunay *delaunay, Mesh *mesh)
 Creates a RestrictedVoronoiDiagram. More...
 
static RestrictedVoronoiDiagramcreate (Delaunay *delaunay, Mesh *mesh, const vector< vec3 > &R3_embedding)
 Creates a RestrictedVoronoiDiagram. More...
 
- Static Public Member Functions inherited from GEO::Counted
static void ref (const Counted *counted)
 Increments the reference count. More...
 
static void unref (const Counted *counted)
 Decrements the reference count. More...
 

Protected Member Functions

 RestrictedVoronoiDiagram (Delaunay *delaunay, Mesh *mesh, const double *R3_embedding, index_t R3_embedding_stride)
 This constructor is never called directly. More...
 
 ~RestrictedVoronoiDiagram () override
 RestrictedVoronoiDiagram destructor.
 
- Protected Member Functions inherited from GEO::Counted
 Counted ()
 Creates a reference counted object. More...
 
virtual ~Counted ()
 Destroys a reference counted object. More...
 

Protected Attributes

coord_index_t dimension_
 
Delaunaydelaunay_
 
Meshmesh_
 
const double * R3_embedding_base_
 
index_t R3_embedding_stride_
 
bool has_weights_
 
Attribute< double > vertex_weight_
 
signed_index_t facets_begin_
 
signed_index_t facets_end_
 
signed_index_t tets_begin_
 
signed_index_t tets_end_
 
bool volumetric_
 

Detailed Description

Computes a Restricted Voronoi Diagram (RVD).

A Restricted Voronoi Diagram is the intersection between a surface mesh and a Voronoi diagram, possibly embedded in high-dimensional space. This class is used (mostly) by CentroidalVoronoiTesselation (CVT), that distributes points uniformly over a surface. This class does all the geometric work for CVT.

Note
This class is mainly a wrapper around the generic implementation GEOGen::RestrictedVoronoiDiagram.
See also
CentroidalVoronoiTesselation
GEOGen::RestrictedVoronoiDiagram

Definition at line 89 of file RVD.h.

Member Enumeration Documentation

◆ RDTMode

Determines the operating mode of compute_RDT().

The flags can be combined with the 'bitwise or' (|) operator.

Enumerator
RDT_SEEDS_ALWAYS 

Always use Delaunay seeds as vertex geometry.

RDT_MULTINERVE 

If set, the dual of the connected components of the restricted Voronoi diagram is computed.

RDT_RVC_CENTROIDS 

If set, the vertices are generated at the centroids of the restricted Voronoi cells, instead of using the seeds.

RDT_PREFER_SEEDS 

If set, the seeds are used whenever possible, i.e. whenever a restricted Voronoi cell has a single connected component.

RDT_SELECT_NEAREST 

If set, then the algorithm selects among the seed and the restricted voronoi cell centroid the one that is nearest to the surface. Important: before using this mode, the surface mesh needs to be reordered with Morton order (see GEO::mesh_reorder).

RDT_PROJECT_ON_SURFACE 

If set, then all the vertices are projected onto the surface. Important: before using this mode, the surface mesh needs to be reordered with Morton order (see GEO::mesh_reorder).

RDT_DONT_REPAIR 

If set, the generated mesh is not repaired. As a result, triangles may be not properly oriented.

Definition at line 430 of file RVD.h.

Constructor & Destructor Documentation

◆ RestrictedVoronoiDiagram()

GEO::RestrictedVoronoiDiagram::RestrictedVoronoiDiagram ( Delaunay delaunay,
Mesh mesh,
const double *  R3_embedding,
index_t  R3_embedding_stride 
)
protected

This constructor is never called directly.

Use one of the three versions of create() instead.

Member Function Documentation

◆ compute_centroids()

void GEO::RestrictedVoronoiDiagram::compute_centroids ( double *  mg,
double *  m 
)
inline

Computes the centroids and masses of the restricted Voronoi cells.

Depending on the volumetric() flag, the Voronoi cells are restricted to the surface (facets of the mesh) or to the volume (tetrahedra of the mesh). This function is used by Lloyd relaxation in CentroidalVoronoiTesselation.

Parameters
[out]mg(size = dimension()*delaunay()->nb_vertices()) : stores for each point the mass times the centroid of the restricted voronoi cell.
[out]m(size = delaunay()->nb_vertices()) : stores for each point the mass of the restricted voronoi cell.

Definition at line 284 of file RVD.h.

◆ compute_centroids_in_volume()

virtual void GEO::RestrictedVoronoiDiagram::compute_centroids_in_volume ( double *  mg,
double *  m 
)
pure virtual

Computes the centroids and masses of the Voronoi cells restricted to the volume.

This function is used by Lloyd relaxation in CentroidalVoronoiTesselation.

Parameters
[out]mg(size = dimension()*delaunay()->nb_vertices()) : stores for each point the mass times the centroid of the restricted voronoi cell.
[out]m(size = delaunay()->nb_vertices()) : stores for each point the mass of the restricted voronoi cell.

◆ compute_centroids_on_surface()

virtual void GEO::RestrictedVoronoiDiagram::compute_centroids_on_surface ( double *  mg,
double *  m 
)
pure virtual

Computes the centroids and masses of the Voronoi cells restricted to the surface.

This function is used by Lloyd relaxation in CentroidalVoronoiTesselation.

Parameters
[out]mg(size = dimension()*delaunay()->nb_vertices()) : stores for each point the mass times the centroid of the restricted voronoi cell.
[out]m(size = delaunay()->nb_vertices()) : stores for each point the mass of the restricted voronoi cell.

◆ compute_CVT_func_grad()

void GEO::RestrictedVoronoiDiagram::compute_CVT_func_grad ( double &  f,
double *  g 
)
inline

Computes the value and gradient of Lloyd's function (quantization noise power).

Does computations either on the surface (triangles of the mesh) or in the volume (tetrahedra of the mesh), depending on the volumetric() flag. This function is used by Newton optimization in CentroidalVoronoiTesselation.

Parameters
[out]fthe computed value of the quantization noise power.
[out]g(size = dimension()*delaunay()->nb_vertices()) : the gradient of the quantization noise power.

Definition at line 335 of file RVD.h.

◆ compute_CVT_func_grad_in_volume()

virtual void GEO::RestrictedVoronoiDiagram::compute_CVT_func_grad_in_volume ( double &  f,
double *  g 
)
pure virtual

Computes the value and gradient of Lloyd's function (quantization noise power) in the volume.

This function is used by Newton optimization in CentroidalVoronoiTesselation.

Parameters
[out]fthe computed value of the quantization noise power.
[out]g(size = dimension()*delaunay()->nb_vertices()) : the gradient of the quantization noise power.

◆ compute_CVT_func_grad_on_surface()

virtual void GEO::RestrictedVoronoiDiagram::compute_CVT_func_grad_on_surface ( double &  f,
double *  g 
)
pure virtual

Computes the value and gradient of Lloyd's function (quantization noise power) on the surface.

This function is used by Newton optimization in CentroidalVoronoiTesselation.

Parameters
[out]fthe computed value of the quantization noise power.
[out]g(size = dimension()*delaunay()->nb_vertices()) : the gradient of the quantization noise power.

◆ compute_initial_sampling()

bool GEO::RestrictedVoronoiDiagram::compute_initial_sampling ( double *  p,
index_t  nb_points,
bool  verbose = false 
)
inline

Computes a random initial sampling in nD.

Depending on the value of the volumetric() flag, this functions samples either the triangles or the tetrahedra of the mesh. The coordinates of the computed points are stored in array p which must be large enough to contain dimension()*nb_points point coordinates.

Parameters
[out]pstores the computed points.
[in]nb_pointsnumber of points to compute
[in]verboseif set, display message

Definition at line 193 of file RVD.h.

◆ compute_initial_sampling_in_volume()

virtual bool GEO::RestrictedVoronoiDiagram::compute_initial_sampling_in_volume ( double *  p,
index_t  nb_points,
bool  verbose 
)
pure virtual

Computes a random initial sampling of the volume in nD.

This function is used to initialize a CentroidalVoronoiTesselation. The coordinates of the computed points are stored in array p which must be large enough to contain dimension()*nb_points point coordinates.

Parameters
[out]pstores the computed points
[in]nb_pointsnumber of points to compute
[in]verboseif set, display message

◆ compute_initial_sampling_on_surface()

virtual bool GEO::RestrictedVoronoiDiagram::compute_initial_sampling_on_surface ( double *  p,
index_t  nb_points,
bool  verbose 
)
pure virtual

Computes a random initial sampling of the surface in nD.

This function is used to initialize a CentroidalVoronoiTesselation. The coordinates of the computed points are stored in array p which must be large enough to contain dimension()*nb_points point coordinates.

Parameters
[out]pstores the computed points
[in]nb_pointsnumber of points to compute
[in]verboseif set, display message

◆ compute_integration_simplex_func_grad()

virtual void GEO::RestrictedVoronoiDiagram::compute_integration_simplex_func_grad ( double &  f,
double *  g,
IntegrationSimplex F 
)
pure virtual

Computes the value and gradient of an objective function over Voronoi cells decomposed into simplices.

This function is used by Newton optimization in CentroidalVoronoiTesselation.

Parameters
[out]fthe value of the objective function
[out]gthe gradient of the objective function
[in,out]Fthe object that computes the objective function and its gradients over a simplex. The contribution of each simplex is added to the gradient referenced by F.

◆ compute_RDT() [1/2]

void GEO::RestrictedVoronoiDiagram::compute_RDT ( Mesh RDT,
RDTMode  mode = RDTMode(RDT_RVC_CENTROIDS|RDT_PREFER_SEEDS),
const vector< bool > &  seed_is_locked = vector< bool >(),
MeshFacetsAABB AABB = nullptr 
)

Computes the restricted Delaunay triangulation.

Parameters
[out]RDTthe computed restricted Delaunay triangulation
[in]modespecifies how vertices geometry is generated in surfacic mode (seeds or restricted Voronoi cells centroids)
[in]seed_is_lockedif set, specifies which seed is locked (size = delaunay()->nb_vertices()). Locked seeds are not replaced with the restricted Voronoi cell centroid
[in]AABBused if one of (RDT_RVC_PROJECT_ON_SURFACE, RDT_SELECT_NEAREST) is set in mode. If needed but not specified, then a temporary one is created.

◆ compute_RDT() [2/2]

virtual void GEO::RestrictedVoronoiDiagram::compute_RDT ( vector< index_t > &  simplices,
vector< double > &  embedding,
RDTMode  mode = RDTMode(RDT_RVC_CENTROIDS|RDT_PREFER_SEEDS),
const vector< bool > &  seed_is_locked = vector< bool >(),
MeshFacetsAABB AABB = nullptr 
)
pure virtual

Computes the restricted Delaunay triangulation.

Parameters
[out]simplicesthe indices of all triangles vertices (or tetrahedra vertices in volumetric mode)
[out]embeddingthe nD embedding of all vertices
[in]modespecifies how vertices geometry is generated in surfacic mode (seeds or restricted Voronoi cells centroids)
[in]seed_is_lockedif set, specifies which seed is locked (size = delaunay()->nb_vertices()). Locked seeds are not replaced with the restricted Voronoi cell centroid.
[in]AABBused if one of (RDT_RVC_PROJECT_ON_SURFACE, RDT_SELECT_NEAREST) is set in mode. If needed but not specified, then a temporary one is created.

◆ compute_RVC()

virtual void GEO::RestrictedVoronoiDiagram::compute_RVC ( index_t  i,
Mesh M,
Mesh result,
bool  copy_symbolic_info = false 
)
pure virtual

Computes a restricted Voronoi cell.

A restricted Voronoi cell is the intersection between a Voronoi cell and a mesh.

Parameters
[in]ithe index of the Voronoi cell
[in]Mthe mesh the Voronoi cell will be restricted to. All its vertices should be of degree 3 (i.e., incident to exactly three facets). In volumetric mode, the surfacic part of the mesh corresponds to the boundary of a volume. In surfacic mode, the mesh is a set of polygonal facets.
[out]resulton exit, contains the intersection of the Voronoi cell i and the mesh M
[in]copy_symbolic_infoif true, symbolic information is copied. An attribute "id" is attached to the facets. The value of id[f] is either 1 + the index of the Voronoi vertex that generated with i the bisector that created the facet, or -1-g if the facet was an original facet of mesh M, where g is the index of the original facet in M.
Note
For now, only volumetric mode is implemented.

◆ compute_RVD()

virtual void GEO::RestrictedVoronoiDiagram::compute_RVD ( Mesh M,
coord_index_t  dim = 0,
bool  cell_borders_only = false,
bool  integration_simplices = false 
)
pure virtual

Computes the restricted Voronoi diagram and stores it in a mesh.

Parameters
[out]Mthe computed restricted Voronoi diagram
[in]dimif different from 0, use only the first dim coordinates
[in]cell_borders_onlyin volumetric mode, computes only the surfacic borders of the volumetric cells (for visualization purpose)
[in]integration_simplicesin volumetric mode, if set, the generated tetrahedra systematically have the Voronoi seed as the first vertex. As a consequence, the mesh is not necessarily geometrically correct (it may have inverted elements), but it is algebraically correct (the sum of signed volumes corresponds the the total volume of each cell).

◆ create() [1/3]

static RestrictedVoronoiDiagram* GEO::RestrictedVoronoiDiagram::create ( Delaunay delaunay,
Mesh mesh 
)
inlinestatic

Creates a RestrictedVoronoiDiagram.

The dimension is determined by mesh->dimension(). The first three coordinates of each vertex are supposed to be x,y,z. (if it is not the case, use create(Delaunay*,Mesh*,const double*, index_t) or create(Delaunay*,Mesh*,const vector<vec3>&) instead).

Parameters
[in]delaunaythe Delaunay triangulation that defines the Voronoi diagram.
[in]meshthe mesh that restricts the Voronoi diagram

Definition at line 120 of file RVD.h.

◆ create() [2/3]

static RestrictedVoronoiDiagram* GEO::RestrictedVoronoiDiagram::create ( Delaunay delaunay,
Mesh mesh,
const double *  R3_embedding,
index_t  R3_embedding_stride 
)
static

Creates a RestrictedVoronoiDiagram.

The dimension is determined by mesh->dimension().

Parameters
[in]delaunaythe Delaunay triangulation that defines the Voronoi diagram.
[in]meshthe mesh that restricts the Voronoi diagram
[in]R3_embeddinggives for each vertex its mapping in 3D space.
[in]R3_embedding_stridegives the stride between two consecutive vertices in R3_embedding

◆ create() [3/3]

static RestrictedVoronoiDiagram* GEO::RestrictedVoronoiDiagram::create ( Delaunay delaunay,
Mesh mesh,
const vector< vec3 > &  R3_embedding 
)
inlinestatic

Creates a RestrictedVoronoiDiagram.

Use this function if the nD coordinates of each mesh vertex are completely unrelated with x,y,z. The dimension is determined by mesh->dimension().

Parameters
[in]delaunaythe Delaunay triangulation that defines the Voronoi diagram.
[in]meshthe mesh that restricts the Voronoi diagram
[in]R3_embeddinggives for each vertex its mapping in 3D space.

Definition at line 142 of file RVD.h.

◆ for_each_polygon()

virtual void GEO::RestrictedVoronoiDiagram::for_each_polygon ( RVDPolygonCallback callback,
bool  symbolic = true,
bool  connected_comp_priority = true,
bool  parallel = false 
)
pure virtual

Invokes a user callback for each intersection polygon of the restricted Voronoi diagram (surfacic mode only).

Each intersection polygon is defined as the intersection between a Voronoi cell and a triangle.

Parameters
[in]callbackthe set of user callbacks, as an instance of a class derived from RVDPolygonCallback.
[in]symbolicif true, generate symbolic information in the vertices
[in]connected_comp_priorityif true, generate polyhedron intersections associated with the same Voronoi seed in order.
[in]parallelif true, tentatively parallelize computation.

◆ for_each_polyhedron()

virtual void GEO::RestrictedVoronoiDiagram::for_each_polyhedron ( RVDPolyhedronCallback callback,
bool  symbolic = true,
bool  connected_comp_priority = true,
bool  parallel = false 
)
pure virtual

Invokes a user callback for each intersection polyhedron of the restricted Voronoi diagram (volumetric mode only).

Each intersection polyhedron is defined as the intersection between a Voronoi cell and a tetrahedron.

Parameters
[in]callbackthe set of user callbacks, as an instance of a class derived from RVDPolyhedronCallback.
[in]symbolicif true, generate symbolic information in the vertices
[in]connected_comp_priorityif true, generate polyhedron intersections associated with the same Voronoi seed in order.
[in]parallelif true, tentatively parallelize computation.

◆ point_allocator()

virtual GEOGen::PointAllocator* GEO::RestrictedVoronoiDiagram::point_allocator ( )
pure virtual

Gets the PointAllocator.

Returns
a pointer to the PointAllocator, used to create the new vertices generated by intersections.

◆ project_points_on_surface() [1/3]

virtual void GEO::RestrictedVoronoiDiagram::project_points_on_surface ( index_t  nb_points,
double *  points,
vec3 nearest,
bool  do_project = false 
)
pure virtual

Computes the projection of points onto the surface in nD space.

Parameters
[in]nb_pointsnumber of points to projects
[in]pointsarray of the coordinates of the points to project. Must contain at least dimension()*nb_points coordinates.
[out]nearest(size=nb_points) the computed projections mapped to 3D space.
[in]do_projectif set, the input points are moved and projected onto the surface, else only the 3D projections are computed, without changing the input.

◆ project_points_on_surface() [2/3]

void GEO::RestrictedVoronoiDiagram::project_points_on_surface ( index_t  nb_points,
double *  points,
vector< double > &  nearest,
bool  do_project = false 
)
inline

Computes the projection of points onto the surface in nD space.

Parameters
[in]nb_pointsnumber of points to projects
[in]pointsarray of the coordinates of the points to project. Must contain at least dimension()*nb_points coordinates.
[out]nearestthe computed projections mapped to 3D space.
[in]do_projectif set, the input points are moved and projected onto the surface, else only the 3D projections are computed, without changing the input.

Definition at line 413 of file RVD.h.

◆ project_points_on_surface() [3/3]

void GEO::RestrictedVoronoiDiagram::project_points_on_surface ( index_t  nb_points,
double *  points,
vector< vec3 > &  nearest,
bool  do_project = false 
)
inline

Computes the projection of points onto the surface in nD space.

Parameters
[in]nb_pointsnumber of points to projects
[in]pointsarray of the coordinates of the points to project. Must contain at least dimension()*nb_points coordinates.
[out]nearestthe computed projections mapped to 3D space.
[in]do_projectif set, the input points are moved and projected onto the surface, else only the 3D projections are computed, without changing the input.

Definition at line 390 of file RVD.h.

◆ R3_embedding()

const vec3& GEO::RestrictedVoronoiDiagram::R3_embedding ( index_t  v) const
inline

Gets the mapping in R3 of a point.

Parameters
[in]vindex of the point
Returns
a const reference to the mapping in R3 of the point

Definition at line 683 of file RVD.h.

◆ set_facets_range()

virtual void GEO::RestrictedVoronoiDiagram::set_facets_range ( index_t  facets_begin,
index_t  facets_end 
)
pure virtual

Restricts surfacic computations to a part of the input mesh.

The part of the input mesh should be specified as a contiguous range of facet indices.

Parameters
[in]facets_beginfirst facet in the range
[in]facets_endone past last facet in the range

◆ set_tetrahedra_range()

virtual void GEO::RestrictedVoronoiDiagram::set_tetrahedra_range ( index_t  tets_begin,
index_t  tets_end 
)
pure virtual

Restricts volumetric computations to a part of the input mesh.

The part of the input mesh should be specified as a contiguous range of tetrahedra indices.

Parameters
[in]tets_beginfirst tetrahedron in the range
[in]tets_endone past last tetrahedron in the range

◆ set_volumetric()

virtual void GEO::RestrictedVoronoiDiagram::set_volumetric ( bool  x)
pure virtual

Sets volumetric mode.

Parameters
[in]xif true, volumetric mode is used, otherwise surfacic mode is used.

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