geomodel_builder_geometry.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 <ringmesh/geomodel/geomodel.h>
#include <ringmesh/geomodel/geomodel_mesh_entity.h>

namespace RINGMesh
{
    FORWARD_DECLARATION_DIMENSION_CLASS( GeoModelBuilderBase );
    FORWARD_DECLARATION_DIMENSION_CLASS( GeoModelBuilder );

    ALIAS_2D_AND_3D( GeoModelBuilder );
} // namespace RINGMesh

namespace RINGMesh
{
    template < index_t DIMENSION >
    class RINGMESH_API GeoModelBuilderGeometryBase
    {
        ringmesh_disable_copy_and_move( GeoModelBuilderGeometryBase );
        ringmesh_template_assert_2d_or_3d( DIMENSION );
        friend class GeoModelBuilderBase< DIMENSION >;
        friend class GeoModelBuilder< DIMENSION >;

    public:
        virtual ~GeoModelBuilderGeometryBase() = default;

        void clear_geomodel_mesh();
        void change_mesh_data_structure(
            const gmme_id& id, const MeshType type )
        {
            GeoModelMeshEntityAccess< DIMENSION > gmme_access(
                geomodel_access_.modifiable_mesh_entity( id ) );
            gmme_access.change_mesh_data_structure( type );
        }

        std::unique_ptr< PointSetMeshBuilder< DIMENSION > >
            create_corner_builder( index_t corner_id )
        {
            gmme_id id( Corner< DIMENSION >::type_name_static(), corner_id );
            GeoModelMeshEntity< DIMENSION >& corner =
                geomodel_access_.modifiable_mesh_entity( id );
            GeoModelMeshEntityAccess< DIMENSION > corner_access( corner );
            auto& corner_mesh = dynamic_cast< PointSetMesh< DIMENSION >& >(
                *corner_access.modifiable_mesh() );
            return PointSetMeshBuilder< DIMENSION >::create_builder(
                corner_mesh );
        }

        std::unique_ptr< LineMeshBuilder< DIMENSION > > create_line_builder(
            index_t line_id )
        {
            gmme_id id( Line< DIMENSION >::type_name_static(), line_id );
            GeoModelMeshEntity< DIMENSION >& line =
                geomodel_access_.modifiable_mesh_entity( id );
            GeoModelMeshEntityAccess< DIMENSION > line_access( line );
            auto& line_mesh = dynamic_cast< LineMesh< DIMENSION >& >(
                *line_access.modifiable_mesh() );
            return LineMeshBuilder< DIMENSION >::create_builder( line_mesh );
        }

        std::unique_ptr< SurfaceMeshBuilder< DIMENSION > >
            create_surface_builder( index_t surface_id )
        {
            gmme_id id( Surface< DIMENSION >::type_name_static(), surface_id );
            GeoModelMeshEntity< DIMENSION >& surface =
                geomodel_access_.modifiable_mesh_entity( id );
            GeoModelMeshEntityAccess< DIMENSION > surface_access( surface );
            auto& surface_mesh = dynamic_cast< SurfaceMesh< DIMENSION >& >(
                *surface_access.modifiable_mesh() );
            return SurfaceMeshBuilder< DIMENSION >::create_builder(
                surface_mesh );
        }

        virtual void copy_meshes( const GeoModel< DIMENSION >& from );
        void copy_meshes( const GeoModel< DIMENSION >& from,
            const MeshEntityType& entity_type );
        void copy_mesh(
            const GeoModel< DIMENSION >& from, const gmme_id& mesh_entity );

        void assign_mesh_to_entity(
            const MeshBase< DIMENSION >& mesh, const gmme_id& to );

        void set_mesh_entity_vertex( const gmme_id& entity_id,
            index_t v,
            const vecn< DIMENSION >& point,
            bool update );

        void set_mesh_entity_vertices( const gmme_id& entity_id,
            const std::vector< vecn< DIMENSION > >& points,
            bool clear );

        void set_corner( index_t corner_id, const vecn< DIMENSION >& point );
        void set_line(
            index_t line_id, const std::vector< vecn< DIMENSION > >& vertices );
        void set_surface_geometry( index_t surface_id,
            const std::vector< vecn< DIMENSION > >& surface_vertices,
            const std::vector< index_t >& surface_polygons,
            const std::vector< index_t >& surface_polygon_ptr );

        void set_mesh_entity_vertex(
            const gmme_id& entity_id, index_t v, index_t geomodel_vertex );

        void set_mesh_entity_vertices( const gmme_id& entity_id,
            const std::vector< index_t >& geomodel_vertices,
            bool clear );

        void set_corner( index_t corner_id, index_t geomodel_vertex_id );

        void set_line(
            index_t line_id, const std::vector< index_t >& unique_vertices );

        void set_surface_geometry( index_t surface_id,
            const std::vector< index_t >& polygons,
            const std::vector< index_t >& polygon_ptr );

        void set_surface_element_geometry( index_t surface_id,
            index_t polygon_id,
            const std::vector< index_t >& corners );

        index_t create_mesh_entity_vertices(
            const gmme_id& entity_id, index_t nb_vertices );

        index_t create_surface_polygon(
            index_t surface_id, const std::vector< index_t >& vertex_indices );

        void delete_mesh_entity_mesh( const gmme_id& E_id );
        virtual void delete_mesh_entity_isolated_vertices(
            const gmme_id& E_id );
        void delete_mesh_entity_vertices(
            const gmme_id& E_id, const std::vector< bool >& to_delete );
        void delete_corner_vertex( index_t corner_id );
        void delete_line_edges( index_t line_id,
            const std::vector< bool >& to_delete,
            bool remove_isolated_vertices );
        void delete_surface_polygons( index_t surface_id,
            const std::vector< bool >& to_delete,
            bool remove_isolated_vertices );

        void set_surface_element_adjacency( index_t surface_id,
            index_t polygon_id,
            const std::vector< index_t >& adjacents );

        void compute_surface_adjacencies(
            index_t surface_id, bool recompute_adjacency = true );

        void cut_surfaces_by_internal_lines();

        void cut_surface_by_line( index_t surface_id, index_t line_id );

    protected:
        GeoModelBuilderGeometryBase( GeoModelBuilder< DIMENSION >& builder,
            GeoModel< DIMENSION >& geomodel );

        void duplicate_surface_vertices_along_line(
            index_t surface_id, index_t line_id );
        /*
         * @brief Resets the adjacencies for all Surface polygons adjacent to
         * the Line
         * @return The number of disconnection done
         * @pre All the edges of the Line are edges of at least one polygon of
         * the Surface
         */
        index_t disconnect_surface_polygons_along_line_edges(
            index_t surface_id, index_t line_id );

        void update_polygon_vertex( index_t surface_id,
            const std::vector< index_t >& polygons,
            index_t old_vertex,
            index_t new_vertex );

    protected:
        GeoModelBuilder< DIMENSION >& builder_;
        GeoModel< DIMENSION >& geomodel_;
        GeoModelAccess< DIMENSION > geomodel_access_;
    };

    ALIAS_2D_AND_3D( GeoModelBuilderGeometryBase );

    template < index_t DIMENSION >
    class RINGMESH_API GeoModelBuilderGeometry final
        : public GeoModelBuilderGeometryBase< DIMENSION >
    {
        friend class GeoModelBuilderBase< DIMENSION >;
        friend class GeoModelBuilder< DIMENSION >;

    protected:
        GeoModelBuilderGeometry( GeoModelBuilder< DIMENSION >& builder,
            GeoModel< DIMENSION >& geomodel )
            : GeoModelBuilderGeometryBase< DIMENSION >( builder, geomodel )
        {
        }
    };

    template <>
    class RINGMESH_API GeoModelBuilderGeometry< 3 > final
        : public GeoModelBuilderGeometryBase< 3 >
    {
        friend class GeoModelBuilderBase< 3 >;
        friend class GeoModelBuilder< 3 >;

    public:
        std::unique_ptr< VolumeMeshBuilder3D > create_region_builder(
            index_t region_id )
        {
            gmme_id id( Region3D::type_name_static(), region_id );
            GeoModelMeshEntity3D& region =
                geomodel_access_.modifiable_mesh_entity( id );
            GeoModelMeshEntityAccess3D region_access( region );
            VolumeMesh3D& region_mesh = dynamic_cast< VolumeMesh3D& >(
                *region_access.modifiable_mesh() );
            return VolumeMeshBuilder3D::create_builder( region_mesh );
        }

        void copy_meshes( const GeoModel3D& geomodel ) override;

        void set_region_element_geometry( index_t region_id,
            index_t cell_id,
            const std::vector< index_t >& corners );

        void set_region_geometry( index_t region_id,
            const std::vector< vec3 >& points,
            const std::vector< index_t >& tetras );

        index_t create_region_cell( index_t region_id,
            CellType type,
            const std::vector< index_t >& vertex_indices );

        index_t create_region_cells(
            index_t region_id, CellType type, index_t nb_cells );

        void delete_region_cells( index_t region_id,
            const std::vector< bool >& to_delete,
            bool remove_isolated_vertices );

        void compute_region_adjacencies(
            index_t region_id, bool recompute_adjacency = true );

        void cut_regions_by_internal_surfaces();

        void cut_region_by_surface( index_t region_id, index_t surface_id );

        void delete_mesh_entity_isolated_vertices(
            const gmme_id& E_id ) override;

    protected:
        GeoModelBuilderGeometry(
            GeoModelBuilder3D& builder, GeoModel3D& geomodel )
            : GeoModelBuilderGeometryBase< 3 >( builder, geomodel )
        {
        }

        void assign_region_tet_mesh(
            index_t region_id, const std::vector< index_t >& tet_vertices );

        void update_cell_vertex( index_t region_id,
            const std::vector< index_t >& cells,
            index_t old_vertex,
            index_t new_vertex );

        void duplicate_region_vertices_along_surface(
            index_t region_id, index_t surface_id );

        index_t disconnect_region_cells_along_surface_polygons(
            index_t region_id, index_t surface_id );
    };
} // namespace RINGMesh