RVD.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2000-2022 Inria
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  * Redistributions of source code must retain the above copyright notice,
 *  this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright notice,
 *  this list of conditions and the following disclaimer in the documentation
 *  and/or other materials provided with the distribution.
 *  * Neither the name of the ALICE Project-Team nor the names of its
 *  contributors may be used to endorse or promote products derived from this
 *  software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 *
 *  Contact: Bruno Levy
 *
 *     https://www.inria.fr/fr/bruno-levy
 *
 *     Inria,
 *     Domaine de Voluceau,
 *     78150 Le Chesnay - Rocquencourt
 *     FRANCE
 *
 */
 
#ifndef GEOGRAM_VORONOI_RVD
#define GEOGRAM_VORONOI_RVD
 
#include <geogram/basic/common.h>
#include <geogram/mesh/index.h>
#include <geogram/mesh/mesh.h>
#include <geogram/basic/geometry.h>
#include <geogram/basic/smart_pointer.h>
#include <geogram/basic/counted.h>
#include <geogram/basic/attributes.h>
 
#include <vector>
 
namespace GEOGen {
    class PointAllocator;
}
 
namespace GEO {
 
    class Delaunay;
    class Map;
    class IntegrationSimplex;
    class MeshFacetsAABB;
    class RVDPolyhedronCallback;
    class RVDPolygonCallback;
 
    class GEOGRAM_API RestrictedVoronoiDiagram : public Counted {
    public:
        static RestrictedVoronoiDiagram* create(
            Delaunay* delaunay, Mesh* mesh,
            const double* R3_embedding, index_t R3_embedding_stride
        );
 
        static RestrictedVoronoiDiagram* create(
            Delaunay* delaunay, Mesh* mesh
        ) {
            return create(
                delaunay, mesh,
                (mesh->vertices.nb() > 0) ? mesh->vertices.point_ptr(0) : nullptr,
                mesh->vertices.dimension()
            );
        }
 
        static RestrictedVoronoiDiagram* create(
            Delaunay* delaunay, Mesh* mesh,
            const vector<vec3>& R3_embedding
        ) {
            return create(delaunay, mesh, R3_embedding[0].data(), 3);
        }
 
        coord_index_t dimension() const {
            return dimension_;
        }
 
        Delaunay* delaunay() {
            return delaunay_;
        }
 
        virtual void set_delaunay(Delaunay* delaunay);
 
        bool volumetric() const {
            return volumetric_;
        }
 
        virtual void set_volumetric(bool x) = 0;
 
        bool compute_initial_sampling(
            double* p, index_t nb_points, bool verbose = false
        ) {
            bool result = true;
            if(volumetric()) {
                result = compute_initial_sampling_in_volume(
                    p, nb_points, verbose
                );
            } else {
                result = compute_initial_sampling_on_surface(
                    p, nb_points, verbose
                );
            }
            return result;
        }
 
        virtual bool compute_initial_sampling_on_surface(
            double* p, index_t nb_points, bool verbose
        ) = 0;
 
        virtual bool compute_initial_sampling_in_volume(
            double* p, index_t nb_points, bool verbose
        ) = 0;
 
        virtual void compute_centroids_on_surface(double* mg, double* m) = 0;
 
        virtual void compute_centroids_in_volume(double* mg, double* m) = 0;
 
        void compute_centroids(double* mg, double* m) {
            if(volumetric()) {
                compute_centroids_in_volume(mg, m);
            } else {
                compute_centroids_on_surface(mg, m);
            }
        }
 
        virtual void compute_CVT_func_grad_on_surface(double& f, double* g) = 0;
 
        virtual void compute_CVT_func_grad_in_volume(double& f, double* g) = 0;
 
        void compute_CVT_func_grad(double& f, double* g) {
            if(volumetric()) {
                compute_CVT_func_grad_in_volume(f, g);
            } else {
                compute_CVT_func_grad_on_surface(f, g);
            }
        }
 
        virtual void compute_integration_simplex_func_grad(
            double& f, double* g, IntegrationSimplex* F
        )=0;
 
        virtual void project_points_on_surface(
            index_t nb_points, double* points,
            vec3* nearest, bool do_project = false
        ) = 0;
 
        void project_points_on_surface(
            index_t nb_points, double* points,
            vector<vec3>& nearest, bool do_project = false
        ) {
            nearest.resize(nb_points);
            project_points_on_surface(
                nb_points, points, &nearest[0], do_project
            );
        }
 
        void project_points_on_surface(
            index_t nb_points, double* points,
            vector<double>& nearest, bool do_project = false
        ) {
            nearest.resize(nb_points * 3);
            project_points_on_surface(
                nb_points, points, (vec3*) (&nearest[0]), do_project
            );
        }
 
 
        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
        };
 
 
        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;
 
        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
        );
 
        virtual void compute_RVD(
            Mesh& M,
            coord_index_t dim = 0,
            bool cell_borders_only = false,
            bool integration_simplices = false
        ) = 0;
 
 
        virtual void compute_RVC(
            index_t i,
            Mesh& M,
            Mesh& result,
            bool copy_symbolic_info=false
        ) = 0;
 
 
        virtual void for_each_polyhedron(
            RVDPolyhedronCallback& callback,
            bool symbolic = true,
            bool connected_comp_priority = true,
            bool parallel = false
        ) = 0;
 
        virtual void for_each_polygon(
            RVDPolygonCallback& callback,
            bool symbolic = true,
            bool connected_comp_priority = true,
            bool parallel = false
        ) = 0;
 
 
        virtual void set_check_SR(bool x) = 0;
 
        virtual void set_exact_predicates(bool x) = 0;
 
        virtual bool exact_predicates() const = 0;
 
        virtual void create_threads() = 0;
 
        virtual void delete_threads() = 0;
 
        virtual void set_facets_range(
            index_t facets_begin, index_t facets_end
        ) = 0;
 
        virtual void set_tetrahedra_range(
            index_t tets_begin, index_t tets_end
        ) = 0;
 
        const vec3& R3_embedding(index_t v) const {
            geo_debug_assert(v < mesh_->vertices.nb());
            return *(const vec3*) (R3_embedding_base_ + v * R3_embedding_stride_);
        }
 
        Mesh* mesh() {
            return mesh_;
        }
 
        virtual GEOGen::PointAllocator* point_allocator() = 0;
 
    protected:
        RestrictedVoronoiDiagram(
            Delaunay* delaunay, Mesh* mesh,
            const double* R3_embedding, index_t R3_embedding_stride
        );
 
        ~RestrictedVoronoiDiagram() override;
 
    protected:
        coord_index_t dimension_;
        Delaunay* delaunay_;
        Mesh* mesh_;
        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_;
    };
 
    typedef SmartPointer<RestrictedVoronoiDiagram>
    RestrictedVoronoiDiagram_var;
}
 
#endif