geomodel_builder_gocad.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 <array>
#include <memory>

#include <geogram/basic/line_stream.h>

#include <ringmesh/basic/factory.h>

#include <ringmesh/geomodel/geomodel_builder_file.h>

namespace RINGMesh
{
    class GeoModelBuilderTSolid;
    class GeoModelBuilderTSolidImpl;
    class GeoModelBuilderML;
    struct VertexMap;
    struct TSolidLoadingStorage;
} // namespace RINGMesh

namespace RINGMesh
{
    void RINGMESH_API initialize_gocad_import_factories();

    class RINGMESH_API GeoModelBuilderGocad : public GeoModelBuilderFile< 3 >
    {
    public:
        GeoModelBuilderGocad( GeoModel3D& geomodel, std::string filename )
            : GeoModelBuilderFile( geomodel, std::move( filename ) ),
              file_line_( filename_ )
        {
            if( !file_line_.OK() )
            {
                throw RINGMeshException(
                    "I/O", "Failed to open file ", filename_ );
            }
        }

        void read_file();

    protected:
        virtual void read_line() = 0;

    protected:
        GEO::LineInput file_line_{ filename_ };
    };

    class GocadBaseParser
    {
        ringmesh_disable_copy_and_move( GocadBaseParser );

    public:
        virtual ~GocadBaseParser() = default;

    protected:
        GocadBaseParser(
            GeoModelBuilderGocad& gm_builder, GeoModel3D& geomodel )
            : builder_( gm_builder ), geomodel_( geomodel )
        {
        }

    protected:
        GeoModelBuilderGocad& builder_;
        GeoModel3D& geomodel_;
    };

    struct RINGMESH_API GocadLoadingStorage
    {
        GocadLoadingStorage();

        void end_polygon()
        {
            index_t nb_polygon_corners = static_cast< index_t >(
                cur_surf_polygon_corners_gocad_id_.size() );
            cur_surf_polygon_ptr_.push_back( nb_polygon_corners );
        }

        // The orientation of positive Z
        int z_sign_{ 1 };

        std::vector< vec3 > vertices_;

        std::vector< std::vector< double > > attributes_;

        // The vertices and the atoms
        index_t nb_attribute_fields_{ 0 };

        // Current interface index
        index_t cur_interface_{ NO_ID };

        // Current surface index
        index_t cur_surface_{ NO_ID };

        // List of polygon corners for the current surface (gocad indices)
        std::vector< index_t > cur_surf_polygon_corners_gocad_id_;

        // Starting indices (in cur_surf_polygons_corner_gocad_id_) of each
        // polygon of the current surface
        std::vector< index_t > cur_surf_polygon_ptr_;
    };

    class RINGMESH_API GocadLineParser : public GocadBaseParser
    {
    public:
        virtual void execute(
            GEO::LineInput& line, GocadLoadingStorage& load_storage ) = 0;

    protected:
        GocadLineParser(
            GeoModelBuilderGocad& gm_builder, GeoModel3D& geomodel )
            : GocadBaseParser( gm_builder, geomodel )
        {
        }
    };
    using GocadLineFactory = Factory< std::string,
        GocadLineParser,
        GeoModelBuilderGocad&,
        GeoModel3D& >;

    struct VertexMap
    {
        index_t gocad_vertex_id( index_t id ) const
        {
            ringmesh_assert( id < vertices_gocad_id_.size() );
            return vertices_gocad_id_[id];
        }

        index_t region_id( index_t id ) const
        {
            ringmesh_assert( id < vertices_region_id_.size() );
            return vertices_region_id_[id];
        }

        void add_new_region( index_t region_id, const std::string& region_name )
        {
            region_ids_.push_back( region_id );
            region_names_.push_back( region_name );
        }

        void record_vertex_with_its_region(
            index_t gocad_vertex_id, index_t region_id )
        {
            vertices_gocad_id_.push_back( gocad_vertex_id );
            vertices_region_id_.push_back( region_id );
        }

        index_t nb_regions() const
        {
            ringmesh_assert( region_names_.size() == region_ids_.size() );
            return static_cast< index_t >( region_ids_.size() );
        }

        std::tuple< bool, index_t > find_region_id_from_name(
            const std::string& region_name )
        {
            index_t region_id{ NO_ID };
            for( auto i : range( region_names_.size() ) )
            {
                if( region_name.compare( region_names_[i] ) == 0 )
                {
                    region_id = region_ids_[i];
                    ringmesh_assert( region_id != NO_ID );
                    return std::make_tuple( true, region_id );
                }
            }
            return std::make_tuple( false, region_id );
        }

        const std::vector< index_t >& get_regions() const
        {
            return region_ids_;
        }

        void get_tetra_corners_with_this_region_id( index_t region_id,
            std::vector< index_t >& region_tetra_corners_local ) const
        {
            index_t counter{ 0 };
            for( auto tetra_region_id : vertices_region_id_ )
            {
                if( tetra_region_id == region_id )
                {
                    region_tetra_corners_local.push_back(
                        local_id( vertices_gocad_id_[counter] ) );
                }
                counter++;
            }
        }

        void get_vertices_attributes_list_from_gocad_ids(
            const std::vector< std::vector< double > >& stored_attributes,
            index_t region_id,
            const std::map< index_t, index_t >& lighttsolid_atom_map,
            std::vector< std::vector< double > >& region_tetra_attributes )
            const
        {
            ringmesh_assert(
                stored_attributes.size() == gocad_ids2region_ids_.size() );
            for( auto gocad_id : range( stored_attributes.size() ) )
            {
                if( gocad_ids2region_ids_[gocad_id] == region_id )
                {
                    if( lighttsolid_atom_map.find( gocad_id )
                        == lighttsolid_atom_map.end() )
                    {
                        region_tetra_attributes.push_back(
                            stored_attributes[gocad_id] );
                    }
                    else
                    {
                        index_t corresponding_gocad_id{
                            lighttsolid_atom_map.find( gocad_id )->second
                        };
                        if( region( corresponding_gocad_id )
                            != region( gocad_id ) )
                        {
                            region_tetra_attributes.push_back(
                                stored_attributes[corresponding_gocad_id] );
                        }
                    }
                }
                gocad_id++;
            }
        }

        struct RegionLocalVertex
        {
            RegionLocalVertex( vec3 vertex, index_t local_id )
                : tetra_vertex( std::move( vertex ) ), local_id( local_id )
            {
            }
            vec3 tetra_vertex{};
            index_t local_id{ NO_ID };
        };

        std::vector< RegionLocalVertex >
            get_vertices_list_and_local_ids_from_gocad_ids(
                const std::vector< vec3 >& stored_vertices,
                const index_t region_id,
                const std::map< index_t, index_t >& lighttsolid_atom_map /*,
             std::vector< vec3 >& region_tetra_vertices,
             std::vector< index_t >& local_ids */ ) const
        {
            ringmesh_assert(
                stored_vertices.size() == gocad_ids2region_ids_.size() );
            std::vector< RegionLocalVertex > region_tetra_vertices;
            for( auto gocad_id : range( stored_vertices.size() ) )
            {
                if( gocad_ids2region_ids_[gocad_id] == region_id )
                {
                    if( lighttsolid_atom_map.find( gocad_id )
                        == lighttsolid_atom_map.end() )
                    {
                        region_tetra_vertices.emplace_back(
                            stored_vertices[gocad_id], gocad_id );
                    }
                    else
                    {
                        index_t corresponding_gocad_id{
                            lighttsolid_atom_map.find( gocad_id )->second
                        };
                        if( region( corresponding_gocad_id )
                            != region( gocad_id ) )
                        {
                            region_tetra_vertices.emplace_back(
                                stored_vertices[corresponding_gocad_id],
                                gocad_id );
                        }
                    }
                }
                gocad_id++;
            }
            return region_tetra_vertices;
        }

        index_t local_id( index_t gocad_vertex_id ) const
        {
            ringmesh_assert( gocad_vertex_id < gocad_ids2local_ids_.size() );
            return gocad_ids2local_ids_[gocad_vertex_id];
        }

        index_t region( index_t gocad_vertex_id ) const
        {
            ringmesh_assert( gocad_vertex_id < gocad_ids2region_ids_.size() );
            return gocad_ids2region_ids_[gocad_vertex_id];
        }

        void add_vertex( index_t local_vertex_id, index_t region_id )
        {
            gocad_ids2local_ids_.push_back( local_vertex_id );
            gocad_ids2region_ids_.push_back( region_id );
        }

        void reserve( index_t capacity )
        {
            gocad_ids2local_ids_.reserve( capacity );
            gocad_ids2region_ids_.reserve( capacity );
        }

        void reserve_nb_vertices( index_t capacity )
        {
            vertices_gocad_id_.reserve( capacity );
            vertices_region_id_.reserve( capacity );
        }

        void fill_with_lighttsolid_region_ids()
        {
            ringmesh_assert(
                vertices_gocad_id_.size() == vertices_region_id_.size() );
            size_t lighttsolid_vertices_nb = vertices_gocad_id_.size();
            size_t lighttsolid_region_nb = nb_regions();

            // For every region ...
            for( auto region_index : range( lighttsolid_region_nb ) )
            {
                // we want to record the region ids of the LightTSolid vertices
                // ...
                for( auto lighttsolid_vertices_id :
                    range( lighttsolid_vertices_nb ) )
                {
                    // that are in this region.
                    if( region_id( lighttsolid_vertices_id ) == region_index )
                    {
                        index_t gocad_vertex_i{ gocad_vertex_id(
                            lighttsolid_vertices_id ) };

                        gocad_ids2region_ids_[gocad_vertex_i] =
                            region_id( lighttsolid_vertices_id );
                    }
                }
            }
        }

        void fill_with_lighttsolid_local_ids()
        {
            ringmesh_assert(
                vertices_gocad_id_.size() == vertices_region_id_.size() );
            size_t lighttsolid_vertices_nb = vertices_gocad_id_.size();
            size_t lighttsolid_region_nb = nb_regions();

            // For every region ...
            for( auto rgion_id : range( lighttsolid_region_nb ) )
            {
                // we want to record the local ids of the LightTSolid vertices
                // ...
                const auto& local_ids = local_ids_[rgion_id];
                for( auto lighttsolid_vertices_id :
                    range( lighttsolid_vertices_nb ) )
                {
                    // that are in this region.
                    if( region_id( lighttsolid_vertices_id ) == rgion_id )
                    {
                        index_t gocad_vertex_i{ gocad_vertex_id(
                            lighttsolid_vertices_id ) };
                        for( auto local_id : range( local_ids.size() ) )
                        {
                            index_t gocad_id{ local_ids[local_id] };
                            if( gocad_id == gocad_vertex_i )
                            {
                                gocad_ids2local_ids_[gocad_vertex_i] = local_id;
                            }
                        }
                    }
                }
            }
        }

        void deal_with_same_region_atoms(
            const std::map< index_t, index_t >& lighttsolid_atom_map )
        {
            for( const std::pair< index_t, index_t >& pair :
                lighttsolid_atom_map )
            {
                if( region( pair.first ) == region( pair.second ) )
                {
                    gocad_ids2local_ids_[pair.first] =
                        gocad_ids2local_ids_[pair.second];
                }
            }
        }

    public:
        std::vector< std::vector< index_t > > local_ids_;

    private:
        std::vector< index_t > vertices_gocad_id_;
        std::vector< index_t > vertices_region_id_;

        std::vector< index_t > region_ids_;
        std::vector< std::string > region_names_;

    private:
        std::vector< index_t > gocad_ids2local_ids_;
        std::vector< index_t > gocad_ids2region_ids_;
    };

    struct TSolidLoadingStorage : public GocadLoadingStorage
    {
        // Current region index
        index_t cur_region_{ NO_ID };

        // Map between gocad and GeoModel vertex indices
        VertexMap vertex_map_;

        // Region tetrahedron corners
        std::vector< index_t > tetra_corners_{};

        // Names of the attributes for the TSolid
        std::vector< std::string > vertex_attribute_names_{};

        // Dimensions of the attributes for the TSolid
        std::vector< index_t > vertex_attribute_dims_{};

        index_t cur_gocad_vrtx_id1_{ NO_ID };
        index_t cur_gocad_vrtx_id2_{ NO_ID };
        index_t cur_gocad_vrtx_id3_{ NO_ID };
        index_t cur_gocad_vrtx_id4_{ NO_ID };

        std::map< index_t, index_t > lighttsolid_atom_map_{};

        // The vertices and the atoms
        index_t nb_vertices_{ 0 };
    };

    class TSolidLineParser : public GocadBaseParser
    {
    public:
        virtual void execute(
            GEO::LineInput& line, TSolidLoadingStorage& load_storage ) = 0;
        virtual void execute_light(
            GEO::LineInput& line, TSolidLoadingStorage& load_storage ) = 0;

    protected:
        TSolidLineParser(
            GeoModelBuilderTSolid& gm_builder, GeoModel3D& geomodel );
    };
    using TSolidLineFactory = Factory< std::string,
        TSolidLineParser,
        GeoModelBuilderTSolid&,
        GeoModel3D& >;

    class RINGMESH_API GeoModelBuilderTSolid final : public GeoModelBuilderGocad
    {
    public:
        static const index_t NB_TYPE = 2;
        enum struct TSolidType
        {
            TSOLID,
            LIGHT_TSOLID
        };
        GeoModelBuilderTSolid( GeoModel3D& geomodel, std::string filename );

    private:
        void read_number_of_vertices();
        void read_type();
        void load_file() final;
        void read_file();

        void read_line() final;

        void compute_surface_internal_borders( index_t surface_id,
            const std::vector< std::unique_ptr< NNSearch3D > >& surface_nns,
            const std::vector< Box3D >& surface_boxes );

        void compute_polygon_edge_centers_nn_and_surface_boxes(
            std::vector< std::unique_ptr< NNSearch3D > >& surface_nns,
            std::vector< Box3D >& surface_boxes ) const;

        void compute_surfaces_internal_borders();

    protected:
        TSolidLoadingStorage tsolid_load_storage_;

    private:
        TSolidType file_type_{ TSolidType::TSOLID };
        std::array< std::unique_ptr< GeoModelBuilderTSolidImpl >, NB_TYPE >
            type_impl_;

        friend class RINGMesh::GocadLineParser;
    };

    class GeoModelBuilderTSolidImpl
    {
        ringmesh_disable_copy_and_move( GeoModelBuilderTSolidImpl );

    public:
        GeoModelBuilderTSolidImpl( GeoModelBuilderTSolid& builder,
            GeoModel3D& geomodel,
            GEO::LineInput& file_line,
            TSolidLoadingStorage& tsolid_load_storage )
            : builder_( builder ),
              geomodel_( geomodel ),
              file_line_( file_line ),
              tsolid_load_storage_( tsolid_load_storage )
        {
        }
        virtual ~GeoModelBuilderTSolidImpl() = default;

        virtual void read_line() = 0;

    protected:
        GeoModelBuilderTSolid& builder_;
        GeoModel3D& geomodel_;
        GEO::LineInput& file_line_;
        TSolidLoadingStorage& tsolid_load_storage_;
    };

    class GeoModelBuilderTSolidImpl_TSolid final
        : public GeoModelBuilderTSolidImpl
    {
    public:
        GeoModelBuilderTSolidImpl_TSolid( GeoModelBuilderTSolid& builder,
            GeoModel3D& geomodel,
            GEO::LineInput& file_line,
            TSolidLoadingStorage& tsolid_load_storage )
            : GeoModelBuilderTSolidImpl(
                  builder, geomodel, file_line, tsolid_load_storage )
        {
        }

        void read_line() override
        {
            std::string keyword = file_line_.field( 0 );
            std::unique_ptr< TSolidLineParser > tsolid_parser =
                TSolidLineFactory::create( keyword, this->builder_, geomodel_ );
            if( tsolid_parser )
            {
                tsolid_parser->execute( file_line_, tsolid_load_storage_ );
            }
            else
            {
                std::unique_ptr< GocadLineParser > gocad_parser =
                    GocadLineFactory::create(
                        keyword, this->builder_, geomodel_ );
                if( gocad_parser )
                {
                    gocad_parser->execute( file_line_, tsolid_load_storage_ );
                }
            }
        }
    };

    class GeoModelBuilderTSolidImpl_LightTSolid final
        : public GeoModelBuilderTSolidImpl
    {
    public:
        GeoModelBuilderTSolidImpl_LightTSolid( GeoModelBuilderTSolid& builder,
            GeoModel3D& geomodel,
            GEO::LineInput& file_line,
            TSolidLoadingStorage& tsolid_load_storage )
            : GeoModelBuilderTSolidImpl(
                  builder, geomodel, file_line, tsolid_load_storage )
        {
        }

        void read_line() override
        {
            std::string keyword = file_line_.field( 0 );
            std::unique_ptr< TSolidLineParser > tsolid_parser =
                TSolidLineFactory::create( keyword, this->builder_, geomodel_ );
            if( tsolid_parser )
            {
                tsolid_parser->execute_light(
                    file_line_, tsolid_load_storage_ );
            }
            else
            {
                std::unique_ptr< GocadLineParser > gocad_parser =
                    GocadLineFactory::create(
                        keyword, this->builder_, geomodel_ );
                if( gocad_parser )
                {
                    gocad_parser->execute( file_line_, tsolid_load_storage_ );
                }
            }
        }
    };

    struct MLLoadingStorage : public GocadLoadingStorage
    {
        MLLoadingStorage();

        bool is_header_read_{ false };

        index_t tface_vertex_ptr_{ 0 };
    };
    class MLLineParser : public GocadBaseParser
    {
    public:
        virtual void execute(
            GEO::LineInput& line, MLLoadingStorage& load_storage ) = 0;

    protected:
        MLLineParser( GeoModelBuilderML& gm_builder, GeoModel3D& geomodel );
    };
    using MLLineFactory =
        Factory< std::string, MLLineParser, GeoModelBuilderML&, GeoModel3D& >;

    class RINGMESH_API GeoModelBuilderML final : public GeoModelBuilderGocad
    {
    public:
        GeoModelBuilderML( GeoModel3D& geomodel, std::string filename )
            : GeoModelBuilderGocad( geomodel, std::move( filename ) )
        {
        }

    private:
        void load_file() final;

        void read_line() final;

    private:
        MLLoadingStorage ml_load_storage_;
    };

} // namespace RINGMesh