integration_simplex.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_INTEGRATION_SIMPLEX
#define GEOGRAM_VORONOI_INTEGRATION_SIMPLEX
 
#include <geogram/basic/common.h>
#include <geogram/basic/numeric.h>
#include <geogram/basic/counted.h>
#include <geogram/basic/smart_pointer.h>
#include <geogram/basic/geometry.h>
#include <geogram/basic/thread_sync.h>
 
namespace GEOGen {
    class Vertex;
}
 
namespace GEO {
 
    class Mesh;
 
    class GEOGRAM_API IntegrationSimplex : public Counted {
 
    public:
 
        ~IntegrationSimplex() override;
 
        virtual double eval(
            index_t center_vertex_index,
            const GEOGen::Vertex& v0,
            const GEOGen::Vertex& v1,
            const GEOGen::Vertex& v2,
            index_t t,
            index_t t_adj = index_t(-1),
            index_t v_adj = index_t(-1)
        ) = 0;
 
 
        void set_points_and_gradient(
            coord_index_t dimension,
            index_t nb_points,
            const double* points,
            double* g,
            Process::SpinLockArray* spinlocks=nullptr
        ) {
            nb_points_ = nb_points;
            points_stride_ = index_t(dimension);
            points_ = points;
            g_ = g;
            spinlocks_ = spinlocks;
        }
 
        bool volumetric() const {
            return volumetric_;
        }
 
        bool background_mesh_has_varying_attribute() const {
            return varying_background_;
        }
 
        virtual void reset_thread_local_storage();
 
    protected:
        IntegrationSimplex(
            const Mesh& mesh,
            bool volumetric,
            index_t nb_frames,
            index_t nb_comp_per_frame,
            const double* frames
        );
 
 
        const double* point(index_t i) const {
            geo_debug_assert(i < nb_points_);
            return points_ + i * points_stride_;
        }
 
        const double* frame(index_t i) const {
            geo_debug_assert(i < nb_frames_);
            return frames_ + i * nb_comp_per_frame_;
        }
 
 
    protected:
        const Mesh& mesh_;
        bool volumetric_;
        index_t nb_points_;
        index_t points_stride_;
        const double* points_;
        double* g_;
        index_t nb_frames_;
        index_t nb_comp_per_frame_;
        const double* frames_;
        Process::SpinLockArray* spinlocks_;
        bool varying_background_;
    };
 
    typedef SmartPointer<IntegrationSimplex>
    IntegrationSimplex_var;
 
}
 
#endif