TetGenInterface.h

Go to the documentation of this file.

 
#pragma once
 
#include <vector>
 
// GeoLib
#include "GeoLib/Point.h"
#include "GeoLib/GEOObjects.h"
 
// forward declaration of class Node and Element
namespace MeshLib
{
    class Node;
    class Element;
    class Mesh;
}
 
namespace FileIO
{
class TetGenInterface final
{
public:
    TetGenInterface();
 
    bool readTetGenGeometry (std::string const& geo_fname,
                             GeoLib::GEOObjects &geo_objects);
 
    MeshLib::Mesh* readTetGenMesh (std::string const& nodes_fname,
                                   std::string const& ele_fname);
 
    static bool writeTetGenSmesh(
        const std::string& file_name,
        const GeoLib::GEOObjects& geo_objects,
        const std::string& geo_name,
        const std::vector<GeoLib::Point>& attribute_points);
 
    bool writeTetGenSmesh(const std::string &file_name,
                          const MeshLib::Mesh &mesh,
                          std::vector<MeshLib::Node> &attribute_points) const;
 
private:
    std::size_t getNFacets(std::ifstream &input);
 
    bool parseSmeshFacets(std::ifstream &input,
                          std::vector<GeoLib::Surface*> &surfaces,
                          const std::vector<GeoLib::Point*> &points,
                          const std::vector<std::size_t> &pnt_id_map);
 
    bool readNodesFromStream(std::ifstream& ins,
                             std::vector<MeshLib::Node*>& nodes);
 
    static bool parseNodesFileHeader(std::string const& line,
                                     std::size_t& n_nodes,
                                     std::size_t& dim,
                                     std::size_t& n_attributes,
                                     bool& boundary_markers);
    bool parseNodes(std::ifstream &ins,
                    std::vector<MeshLib::Node*> &nodes,
                    std::size_t n_nodes,
                    std::size_t dim);
 
    bool readElementsFromStream(std::ifstream& ins,
                                std::vector<MeshLib::Element*>& elements,
                                std::vector<int>& materials,
                                const std::vector<MeshLib::Node*>& nodes) const;
    static bool parseElementsFileHeader(std::string& line,
                                        std::size_t& n_tets,
                                        std::size_t& n_nodes_per_tet,
                                        bool& region_attribute);
    bool parseElements(std::ifstream& ins,
                       std::vector<MeshLib::Element*> &elements,
                       std::vector<int> &materials,
                       const std::vector<MeshLib::Node*> &nodes,
                       std::size_t n_tets,
                       std::size_t n_nodes_per_tet,
                       bool region_attribute) const;
 
    void write2dElements(std::ofstream &out,
                         const MeshLib::Mesh &mesh) const;
 
    void write3dElements(std::ofstream &out,
                         const MeshLib::Mesh &mesh,
                         std::vector<MeshLib::Node> &attribute_points) const;
 
    static void writeElementToFacets(std::ofstream& out,
                                     const MeshLib::Element& element,
                                     unsigned& element_count,
                                     std::string const& matId);
 
    bool _zero_based_idx{false};
 
    bool _boundary_markers{false};
};
}  // namespace FileIO