CVT.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_CVT
#define GEOGRAM_VORONOI_CVT
 
#include <geogram/basic/common.h>
#include <geogram/voronoi/RVD.h>
#include <geogram/voronoi/integration_simplex.h>
#include <geogram/mesh/mesh.h>
#include <geogram/delaunay/delaunay.h>
 
 
namespace GEO {
 
    class RestrictedVoronoiDiagram;
    class ProgressTask;
 
    class GEOGRAM_API CentroidalVoronoiTesselation {
 
        typedef CentroidalVoronoiTesselation thisclass;
 
    public:
    CentroidalVoronoiTesselation(
        Mesh* mesh,
        coord_index_t dimension = 0,
        const std::string& delaunay = "default"
    );
 
    CentroidalVoronoiTesselation(
        Mesh* mesh,
        const vector<vec3>& R3_embedding, coord_index_t dimension = 0,
        const std::string& delaunay = "default"
    );
 
    virtual ~CentroidalVoronoiTesselation();
 
    bool compute_initial_sampling(index_t nb_samples, bool verbose=false);
 
    void set_points(index_t nb_points, const double* points);
 
    void resize_points(index_t nb_points);
 
    virtual void Lloyd_iterations(index_t nb_iter);
 
    virtual void Newton_iterations(index_t nb_iter, index_t m = 7);
 
    void compute_surface(Mesh* mesh, bool multinerve = true);
 
    void compute_volume(Mesh* mesh);
 
    void set_show_iterations(bool x) {
        show_iterations_ = x;
    }
 
    void set_use_RVC_centroids(bool x) {
        use_RVC_centroids_ = x;
    }
 
    void set_constrained_cvt(bool x) {
        constrained_cvt_ = x;
    }
 
    Mesh* mesh() {
        return mesh_;
    }
 
    Delaunay* delaunay() {
        return delaunay_;
    }
 
    RestrictedVoronoiDiagram* RVD() {
        return RVD_;
    }
 
    void set_facets_range(index_t facets_begin, index_t facets_end) {
        RVD_->set_facets_range(facets_begin, facets_end);
    }
 
    void make_current() {
        geo_assert(instance_ == nullptr);
        instance_ = this;
    }
 
    void done_current() {
        geo_assert(instance_ == this);
        instance_ = nullptr;
    }
 
    public:
    static void funcgrad_CB(
        index_t n, double* x, double& f, double* g
    );
 
    static void newiteration_CB(
        index_t n, const double* x, double f, const double* g, double gnorm
    );
 
    void set_progress_logger(ProgressTask* progress) {
        progress_ = progress;
    }
 
    coord_index_t dimension() const {
        return dimension_;
    }
 
    index_t nb_points() const {
        return index_t(points_.size() / dimension_);
    }
 
    const vec3& R3_embedding(index_t p) const {
        return RVD_->R3_embedding(p);
    }
 
    double* embedding(index_t p) {
        geo_debug_assert(p < nb_points());
        return &(points_[0]) + dimension_ * p;
    }
 
    bool volumetric() const {
        return RVD_->volumetric();
    }
 
    void set_volumetric(bool x) {
        RVD_->set_volumetric(x);
    }
 
    bool point_is_locked(index_t i) const {
        geo_debug_assert(
            point_is_locked_.size() == 0 || i < point_is_locked_.size()
        );
        return point_is_locked_.size() != 0 && point_is_locked_[i];
    }
 
    void lock_point(index_t i) {
        geo_debug_assert(i < nb_points());
        if(point_is_locked_.size() != nb_points()) {
            point_is_locked_.resize(nb_points(), false);
        }
        point_is_locked_[i] = true;
    }
 
    void unlock_point(index_t i) {
        geo_debug_assert(i < nb_points());
        if(
            point_is_locked_.size() != nb_points()
        ) {
            point_is_locked_.resize(nb_points(), false);
        }
        point_is_locked_[i] = false;
    }
 
    void unlock_all_points() {
        point_is_locked_.clear();
    }
 
    protected:
    virtual void newiteration();
 
    virtual void funcgrad(index_t n, double* x, double& f, double* g);
 
    void constrain_points(double* g) const;
 
    void compute_R3_embedding();
 
    static CentroidalVoronoiTesselation* instance_;
    bool show_iterations_;
    coord_index_t dimension_;
    Delaunay_var delaunay_;
    RestrictedVoronoiDiagram_var RVD_;
    Mesh* mesh_;
 
    vector<double> points_;
    vector<vec3> points_R3_;
    vector<bool> point_is_locked_;
 
    ProgressTask* progress_;
    index_t cur_iter_;
    index_t nb_iter_;
 
    bool is_projection_;   
    bool constrained_cvt_;
    bool use_RVC_centroids_;
 
    IntegrationSimplex_var simplex_func_;
    private:
    CentroidalVoronoiTesselation(const thisclass& rhs);
 
    thisclass& operator= (const thisclass& rhs);
    };
}
 
#endif