mesh_builder.h

Go to the documentation of this file.

/*
 * Copyright (c) 2012-2017, Association Scientifique pour la Geologie et ses
 * Applications (ASGA). 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 ASGA 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 ASGA 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.
 *
 *     http://www.ring-team.org
 *
 *     RING Project
 *     Ecole Nationale Superieure de Geologie - GeoRessources
 *     2 Rue du Doyen Marcel Roubault - TSA 70605
 *     54518 VANDOEUVRE-LES-NANCY
 *     FRANCE
 */

#pragma once

#include <ringmesh/basic/common.h>

#include <memory>
#include <numeric>

#include <geogram/mesh/mesh_repair.h>

#include <ringmesh/basic/factory.h>

#include <ringmesh/mesh/mesh.h>

namespace RINGMesh
{
    FORWARD_DECLARATION_DIMENSION_CLASS( GeoModel );
} // namespace RINGMesh

namespace RINGMesh
{
    template < index_t DIMENSION >
    class MeshBaseBuilder
    {
        ringmesh_disable_copy_and_move( MeshBaseBuilder );
        ringmesh_template_assert_2d_or_3d( DIMENSION );

    public:
        virtual ~MeshBaseBuilder() = default;
        void copy( const MeshBase< DIMENSION >& rhs, bool copy_attributes )
        {
            do_copy( rhs, copy_attributes );
            clear_vertex_linked_objects();
        }

        virtual void load_mesh( const std::string& filename ) = 0;
        void clear( bool keep_attributes, bool keep_memory )
        {
            do_clear( keep_attributes, keep_memory );
            clear_vertex_linked_objects();
        }
        void repair( GEO::MeshRepairMode mode, double colocate_epsilon )
        {
            do_repair( mode, colocate_epsilon );
            clear_vertex_linked_objects();
        }
        void set_vertex( index_t v_id, const vecn< DIMENSION >& vertex )
        {
            do_set_vertex( v_id, vertex );
            clear_vertex_linked_objects();
        }
        index_t create_vertex()
        {
            index_t index = do_create_vertex();
            clear_vertex_linked_objects();
            return index;
        }
        index_t create_vertex( const vecn< DIMENSION >& vertex )
        {
            index_t index = create_vertex();
            set_vertex( index, vertex );
            return index;
        }
        index_t create_vertices( index_t nb )
        {
            index_t index = do_create_vertices( nb );
            clear_vertex_linked_objects();
            return index;
        }

        void assign_vertices( const std::vector< double >& point_coordinates )
        {
            do_assign_vertices( point_coordinates );
            clear_vertex_linked_objects();
        }

        void delete_vertices( const std::vector< bool >& to_delete )
        {
            do_delete_vertices( to_delete );
            clear_vertex_linked_objects();
        }
        void clear_vertices( bool keep_attributes, bool keep_memory )
        {
            do_clear_vertices( keep_attributes, keep_memory );
            clear_vertex_linked_objects();
        }
        void permute_vertices( const std::vector< index_t >& permutation )
        {
            do_permute_vertices( permutation );
            clear_vertex_linked_objects();
        }
        static std::unique_ptr< MeshBaseBuilder< DIMENSION > > create_builder(
            MeshBase< DIMENSION >& mesh );

    protected:
        explicit MeshBaseBuilder( MeshBase< DIMENSION >& mesh )
            : mesh_base_( mesh )
        {
        }

        void delete_vertex_nn_search()
        {
            mesh_base_.vertex_nn_search_.reset();
        }

        virtual void clear_vertex_linked_objects() = 0;

    private:
        virtual void do_copy(
            const MeshBase< DIMENSION >& rhs, bool copy_attributes ) = 0;
        virtual void do_clear( bool keep_attributes, bool keep_memory ) = 0;
        virtual void do_repair(
            GEO::MeshRepairMode mode, double colocate_epsilon ) = 0;
        virtual void do_set_vertex(
            index_t v_id, const vecn< DIMENSION >& vertex ) = 0;
        virtual index_t do_create_vertex() = 0;
        virtual index_t do_create_vertices( index_t nb ) = 0;
        virtual void do_assign_vertices(
            const std::vector< double >& point_coordinates ) = 0;
        virtual void do_delete_vertices(
            const std::vector< bool >& to_delete ) = 0;
        virtual void do_clear_vertices(
            bool keep_attributes, bool keep_memory ) = 0;
        virtual void do_permute_vertices(
            const std::vector< index_t >& permutation ) = 0;

    protected:
        MeshBase< DIMENSION >& mesh_base_;
    };

    ALIAS_2D_AND_3D( MeshBaseBuilder );

    template < index_t DIMENSION >
    class PointSetMeshBuilder : public MeshBaseBuilder< DIMENSION >
    {
    public:
        static std::unique_ptr< PointSetMeshBuilder< DIMENSION > >
            create_builder( PointSetMesh< DIMENSION >& mesh );

        virtual void remove_isolated_vertices()
        {
            // All vertices are isolated in a Mesh0D
        }

    protected:
        explicit PointSetMeshBuilder( PointSetMesh< DIMENSION >& mesh )
            : MeshBaseBuilder< DIMENSION >( mesh ), pointset_mesh_( mesh )
        {
        }

    private:
        void clear_vertex_linked_objects() final
        {
            this->delete_vertex_nn_search();
        }

    protected:
        PointSetMesh< DIMENSION >& pointset_mesh_;
    };

    ALIAS_2D_AND_3D( PointSetMeshBuilder );

    template < index_t DIMENSION >
    using PointSetMeshBuilderFactory = Factory< MeshType,
        PointSetMeshBuilder< DIMENSION >,
        PointSetMesh< DIMENSION >& >;

    ALIAS_2D_AND_3D( PointSetMeshBuilderFactory );

    template < index_t DIMENSION >
    class LineMeshBuilder : public MeshBaseBuilder< DIMENSION >
    {
    public:
        static std::unique_ptr< LineMeshBuilder > create_builder(
            LineMesh< DIMENSION >& mesh );

        void create_edge( index_t v1_id, index_t v2_id )
        {
            do_create_edge( v1_id, v2_id );
            clear_edge_linked_objects();
        }
        index_t create_edges( index_t nb_edges )
        {
            index_t index = do_create_edges( nb_edges );
            clear_edge_linked_objects();
            return index;
        }
        void set_edge_vertex(
            const EdgeLocalVertex& edge_local_vertex, index_t vertex_id )
        {
            do_set_edge_vertex( edge_local_vertex, vertex_id );
            clear_edge_linked_objects();
        }
        void delete_edges( const std::vector< bool >& to_delete,
            bool remove_isolated_vertices )
        {
            do_delete_edges( to_delete );
            if( remove_isolated_vertices )
            {
                this->remove_isolated_vertices();
            }
            clear_edge_linked_objects();
        }
        void clear_edges( bool keep_attributes, bool keep_memory )
        {
            do_clear_edges( keep_attributes, keep_memory );
            clear_edge_linked_objects();
        }
        void permute_edges( const std::vector< index_t >& permutation )
        {
            do_permute_edges( permutation );
            clear_edge_linked_objects();
        }

        void remove_isolated_vertices()
        {
            std::vector< bool > to_delete( line_mesh_.nb_vertices(), true );
            for( auto e : range( line_mesh_.nb_edges() ) )
            {
                for( auto v : range( 2 ) )
                {
                    index_t vertex_id =
                        line_mesh_.edge_vertex( ElementLocalVertex( e, v ) );
                    to_delete[vertex_id] = false;
                }
            }
            this->delete_vertices( to_delete );
        }

    protected:
        explicit LineMeshBuilder( LineMesh< DIMENSION >& mesh )
            : MeshBaseBuilder< DIMENSION >( mesh ), line_mesh_( mesh )
        {
        }

    private:
        void delete_edge_nn_search()
        {
            line_mesh_.edge_nn_search_.reset();
        }

        void clear_vertex_linked_objects() override
        {
            this->delete_vertex_nn_search();
            clear_edge_linked_objects();
        }

        void clear_edge_linked_objects()
        {
            delete_edge_nn_search();
        }

        virtual void do_create_edge( index_t v1_id, index_t v2_id ) = 0;
        virtual index_t do_create_edges( index_t nb_edges ) = 0;
        virtual void do_set_edge_vertex(
            const EdgeLocalVertex& edge_local_vertex, index_t vertex_id ) = 0;
        virtual void do_delete_edges(
            const std::vector< bool >& to_delete ) = 0;
        virtual void do_clear_edges(
            bool keep_attributes, bool keep_memory ) = 0;
        virtual void do_permute_edges(
            const std::vector< index_t >& permutation ) = 0;

    protected:
        LineMesh< DIMENSION >& line_mesh_;
    };

    ALIAS_2D_AND_3D( LineMeshBuilder );

    template < index_t DIMENSION >
    using LineMeshBuilderFactory = Factory< MeshType,
        LineMeshBuilder< DIMENSION >,
        LineMesh< DIMENSION >& >;

    ALIAS_2D_AND_3D( LineMeshBuilderFactory );

    template < index_t DIMENSION >
    class SurfaceMeshBuilder : public MeshBaseBuilder< DIMENSION >
    {
    public:
        static std::unique_ptr< SurfaceMeshBuilder< DIMENSION > >
            create_builder( SurfaceMesh< DIMENSION >& mesh );

        void create_polygons( const std::vector< index_t >& polygons,
            const std::vector< index_t >& polygon_ptr )
        {
            do_create_polygons( polygons, polygon_ptr );
            clear_polygon_linked_objects();
        }
        index_t create_polygon( const std::vector< index_t >& vertices )
        {
            index_t index = do_create_polygon( vertices );
            clear_polygon_linked_objects();
            return index;
        }
        index_t create_triangles( index_t nb_triangles )
        {
            index_t index = do_create_triangles( nb_triangles );
            clear_polygon_linked_objects();
            return index;
        }
        index_t create_quads( index_t nb_quads )
        {
            index_t index = do_create_quads( nb_quads );
            clear_polygon_linked_objects();
            return index;
        }
        void set_polygon_vertex(
            const PolygonLocalEdge& polygon_local_edge, index_t vertex_id )
        {
            do_set_polygon_vertex( polygon_local_edge, vertex_id );
            clear_polygon_linked_objects();
        }
        void set_polygon_adjacent(
            const PolygonLocalEdge& polygon_local_edge, index_t specifies )
        {
            do_set_polygon_adjacent( polygon_local_edge, specifies );
        }
        void clear_polygons( bool keep_attributes, bool keep_memory )
        {
            do_clear_polygons( keep_attributes, keep_memory );
            clear_polygon_linked_objects();
        }
        void connect_polygons()
        {
            std::vector< index_t > polygons_to_connect(
                surface_mesh_.nb_polygons() );
            std::iota(
                polygons_to_connect.begin(), polygons_to_connect.end(), 0 );
            connect_polygons( polygons_to_connect );
        }
        void connect_polygons(
            const std::vector< index_t >& polygons_to_connect )
        {
            index_t nb_local_vertices = 0;
            for( auto polygon : polygons_to_connect )
            {
                nb_local_vertices +=
                    this->surface_mesh_.nb_polygon_vertices( polygon );
            }

            std::vector< ElementLocalVertex > polygon_vertices;
            polygon_vertices.reserve( nb_local_vertices );
            for( auto polygon : polygons_to_connect )
            {
                for( auto v : range(
                         this->surface_mesh_.nb_polygon_vertices( polygon ) ) )
                {
                    polygon_vertices.emplace_back( polygon, v );
                }
            }

            std::vector< index_t > next_local_vertex_around_vertex(
                nb_local_vertices, NO_ID );
            std::vector< index_t > vertex2polygon_local_vertex(
                this->surface_mesh_.nb_vertices(), NO_ID );
            index_t local_vertex_count = 0;
            for( auto polygon : polygons_to_connect )
            {
                for( auto v = 0;
                     v < this->surface_mesh_.nb_polygon_vertices( polygon );
                     v++, local_vertex_count++ )
                {
                    index_t vertex = this->surface_mesh_.polygon_vertex(
                        ElementLocalVertex( polygon, v ) );
                    next_local_vertex_around_vertex[local_vertex_count] =
                        vertex2polygon_local_vertex[vertex];
                    vertex2polygon_local_vertex[vertex] = local_vertex_count;
                }
            }

            local_vertex_count = 0;
            for( auto polygon : polygons_to_connect )
            {
                for( index_t v = 0;
                     v < this->surface_mesh_.nb_polygon_vertices( polygon );
                     v++, local_vertex_count++ )
                {
                    if( !this->surface_mesh_.is_edge_on_border(
                            PolygonLocalEdge( polygon, v ) ) )
                    {
                        continue;
                    }
                    index_t vertex = this->surface_mesh_.polygon_vertex(
                        ElementLocalVertex( polygon, v ) );
                    index_t next_vertex = this->surface_mesh_.polygon_vertex(
                        this->surface_mesh_.next_polygon_vertex(
                            ElementLocalVertex( polygon, v ) ) );
                    for( auto local_vertex =
                             vertex2polygon_local_vertex[next_vertex];
                         local_vertex != NO_ID;
                         local_vertex =
                             next_local_vertex_around_vertex[local_vertex] )
                    {
                        if( local_vertex == local_vertex_count )
                        {
                            continue;
                        }
                        index_t adj_polygon =
                            polygon_vertices[local_vertex].element_id_;
                        index_t adj_local_vertex =
                            polygon_vertices[local_vertex].local_vertex_id_;
                        index_t adj_next_vertex =
                            this->surface_mesh_.polygon_vertex(
                                this->surface_mesh_.next_polygon_vertex(
                                    ElementLocalVertex(
                                        adj_polygon, adj_local_vertex ) ) );
                        if( adj_next_vertex == vertex )
                        {
                            this->set_polygon_adjacent(
                                PolygonLocalEdge( polygon, v ), adj_polygon );
                            this->set_polygon_adjacent(
                                PolygonLocalEdge(
                                    adj_polygon, adj_local_vertex ),
                                polygon );
                            break;
                        }
                    }
                }
            }
        }

        void permute_polygons( const std::vector< index_t >& permutation )
        {
            do_permute_polygons( permutation );
            clear_polygon_linked_objects();
        }
        void delete_polygons( const std::vector< bool >& to_delete,
            bool remove_isolated_vertices )
        {
            do_delete_polygons( to_delete );
            if( remove_isolated_vertices )
            {
                this->remove_isolated_vertices();
            }
            clear_polygon_linked_objects();
        }

        virtual void remove_small_connected_components(
            double min_area, index_t min_polygons ) = 0;
        virtual void triangulate(
            const SurfaceMeshBase< DIMENSION >& surface_in ) = 0;
        void remove_isolated_vertices()
        {
            std::vector< bool > to_delete( surface_mesh_.nb_vertices(), true );
            for( auto p : range( surface_mesh_.nb_polygons() ) )
            {
                for( auto v : range( surface_mesh_.nb_polygon_vertices( p ) ) )
                {
                    index_t vertex_id = surface_mesh_.polygon_vertex(
                        ElementLocalVertex( p, v ) );
                    to_delete[vertex_id] = false;
                }
            }
            this->delete_vertices( to_delete );
        }

    protected:
        explicit SurfaceMeshBuilder( SurfaceMeshBase< DIMENSION >& mesh )
            : MeshBaseBuilder< DIMENSION >( mesh ), surface_mesh_( mesh )
        {
        }

    private:
        void delete_polygon_nn_search()
        {
            surface_mesh_.nn_search_.reset();
        }

        void delete_polygon_aabb()
        {
            surface_mesh_.polygon_aabb_.reset();
        }

        void clear_vertex_linked_objects() override
        {
            this->delete_vertex_nn_search();
            clear_polygon_linked_objects();
        }

        void clear_polygon_linked_objects()
        {
            delete_polygon_aabb();
            delete_polygon_nn_search();
        }
        virtual void do_create_polygons( const std::vector< index_t >& polygons,
            const std::vector< index_t >& polygon_ptr ) = 0;
        virtual index_t do_create_polygon(
            const std::vector< index_t >& vertices ) = 0;
        virtual index_t do_create_triangles( index_t nb_triangles ) = 0;
        virtual index_t do_create_quads( index_t nb_quads ) = 0;
        virtual void do_set_polygon_vertex(
            const PolygonLocalEdge& polygon_local_edge, index_t vertex_id ) = 0;
        virtual void do_set_polygon_adjacent(
            const PolygonLocalEdge& polygon_local_edge, index_t specifies ) = 0;
        virtual void do_clear_polygons(
            bool keep_attributes, bool keep_memory ) = 0;

        virtual void do_permute_polygons(
            const std::vector< index_t >& permutation ) = 0;
        virtual void do_delete_polygons(
            const std::vector< bool >& to_delete ) = 0;

    protected:
        SurfaceMeshBase< DIMENSION >& surface_mesh_;
    };

    ALIAS_2D_AND_3D( SurfaceMeshBuilder );

    template < index_t DIMENSION >
    using SurfaceMeshBuilderFactory = Factory< MeshType,
        SurfaceMeshBuilder< DIMENSION >,
        SurfaceMesh< DIMENSION >& >;

    ALIAS_2D_AND_3D( SurfaceMeshBuilderFactory );

    template < index_t DIMENSION >
    class VolumeMeshBuilder : public MeshBaseBuilder< DIMENSION >
    {
        static_assert( DIMENSION == 3, "DIMENSION template should be 3" );

    public:
        static std::unique_ptr< VolumeMeshBuilder< DIMENSION > > create_builder(
            VolumeMesh< DIMENSION >& mesh );

        index_t create_cells( index_t nb_cells, CellType type )
        {
            index_t index = do_create_cells( nb_cells, type );
            clear_cell_linked_objects();
            return index;
        }
        /*
         * \brief Copies a tets mesh into this Mesh.
         * \details Cells adjacence are not computed.
         *   cell and corner attributes are zeroed.
         * \param[in] tets cells to vertex links
         * (using vector::swap).
         */
        void assign_cell_tet_mesh( const std::vector< index_t >& tets )
        {
            do_assign_cell_tet_mesh( tets );
            clear_cell_linked_objects();
        }
        void set_cell_vertex(
            const ElementLocalVertex& cell_local_vertex, index_t vertex_id )
        {
            do_set_cell_vertex( cell_local_vertex, vertex_id );
            clear_cell_linked_objects();
        }
        void set_cell_corner_vertex_index(
            index_t corner_index, index_t vertex_index )
        {
            do_set_cell_corner_vertex_index( corner_index, vertex_index );
            clear_cell_linked_objects();
        }
        void set_cell_adjacent(
            const CellLocalFacet& cell_local_facet, index_t cell_adjacent )
        {
            do_set_cell_adjacent( cell_local_facet, cell_adjacent );
        }

        virtual void connect_cells() = 0;

        void clear_cells( bool keep_attributes, bool keep_memory )
        {
            do_clear_cells( keep_attributes, keep_memory );
            clear_cell_linked_objects();
        }
        void permute_cells( const std::vector< index_t >& permutation )
        {
            do_permute_cells( permutation );
            clear_cell_linked_objects();
        }
        void delete_cells( const std::vector< bool >& to_delete,
            bool remove_isolated_vertices )
        {
            do_delete_cells( to_delete );
            if( remove_isolated_vertices )
            {
                this->remove_isolated_vertices();
            }
            clear_cell_linked_objects();
        }

        void remove_isolated_vertices()
        {
            std::vector< bool > to_delete( volume_mesh_.nb_vertices(), true );
            for( auto c : range( volume_mesh_.nb_cells() ) )
            {
                for( auto v : range( volume_mesh_.nb_cell_vertices( c ) ) )
                {
                    index_t vertex_id =
                        volume_mesh_.cell_vertex( ElementLocalVertex( c, v ) );
                    to_delete[vertex_id] = false;
                }
            }
            this->delete_vertices( to_delete );
        }

    protected:
        explicit VolumeMeshBuilder( VolumeMesh< DIMENSION >& mesh )
            : MeshBaseBuilder< DIMENSION >( mesh ), volume_mesh_( mesh )
        {
        }

    private:
        void delete_cell_nn_search()
        {
            volume_mesh_.cell_nn_search_.reset();
            volume_mesh_.cell_facet_nn_search_.reset();
        }

        void delete_cell_aabb()
        {
            volume_mesh_.cell_aabb_.reset();
        }

        void clear_vertex_linked_objects() override
        {
            this->delete_vertex_nn_search();
            clear_cell_linked_objects();
        }

        void clear_cell_linked_objects()
        {
            delete_cell_aabb();
            delete_cell_nn_search();
        }

        virtual index_t do_create_cells( index_t nb_cells, CellType type ) = 0;
        /*
         * \brief Copies a tets mesh into this Mesh.
         * \details Cells adjacence are not computed.
         *   cell and corner attributes are zeroed.
         * \param[in] tets cells to vertex links
         * (using vector::swap).
         */
        virtual void do_assign_cell_tet_mesh(
            const std::vector< index_t >& tets ) = 0;
        virtual void do_set_cell_vertex(
            const ElementLocalVertex& cell_local_vertex,
            index_t vertex_id ) = 0;
        virtual void do_set_cell_corner_vertex_index(
            index_t corner_index, index_t vertex_index ) = 0;
        virtual void do_set_cell_adjacent(
            const CellLocalFacet& cell_local_facet, index_t cell_adjacent ) = 0;
        virtual void do_clear_cells(
            bool keep_attributes, bool keep_memory ) = 0;
        virtual void do_permute_cells(
            const std::vector< index_t >& permutation ) = 0;
        virtual void do_delete_cells(
            const std::vector< bool >& to_delete ) = 0;

    protected:
        VolumeMesh< DIMENSION >& volume_mesh_;
    };

    using VolumeMeshBuilder3D = VolumeMeshBuilder< 3 >;

    template < index_t DIMENSION >
    using VolumeMeshBuilderFactory = Factory< MeshType,
        VolumeMeshBuilder< DIMENSION >,
        VolumeMesh< DIMENSION >& >;

    using VolumeMeshBuilderFactory3D = VolumeMeshBuilderFactory< 3 >;
} // namespace RINGMesh