MeshRevision.h

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <limits>
#include <string>
#include <vector>
 
#include "MeshLib/Properties.h"
 
// forward declaration
namespace MeshLib
{
class Mesh;
class Node;
class Element;
}  // namespace MeshLib
 
namespace MeshLib
{
class MeshRevision
{
public:
    explicit MeshRevision(MeshLib::Mesh& mesh);
 
    virtual ~MeshRevision() = default;
 
    unsigned getNumberOfCollapsableNodes(
        double eps = std::numeric_limits<double>::epsilon()) const;
 
    std::vector<std::size_t> collapseNodeIndices(double eps) const;
 
    MeshLib::Mesh* simplifyMesh(const std::string& new_mesh_name, double eps,
                                unsigned min_elem_dim = 1) const;
 
private:
    std::vector<MeshLib::Node*> constructNewNodesArray(
        const std::vector<std::size_t>& id_map) const;
 
    static unsigned getNumberOfUniqueNodes(
        MeshLib::Element const* const element);
 
    MeshLib::Properties copyProperties(
        MeshLib::Properties const& props,
        std::vector<std::size_t> const& node_ids,
        std::vector<std::size_t> const& elem_ids) const;
 
    std::size_t subdivideElement(
        MeshLib::Element const* const element,
        std::vector<MeshLib::Node*> const& nodes,
        std::vector<MeshLib::Element*>& elements) const;
 
    // Revises an element by removing collapsed nodes, using the nodes vector
    // from the result mesh.
    std::size_t reduceElement(MeshLib::Element const* const element,
                              unsigned n_unique_nodes,
                              const std::vector<MeshLib::Node*>& nodes,
                              std::vector<MeshLib::Element*>& elements,
                              unsigned min_elem_dim) const;
 
    void cleanUp(std::vector<MeshLib::Node*>& nodes,
                 std::vector<MeshLib::Element*>& new_elements) const;
 
    unsigned subdivideQuad(MeshLib::Element const* const quad,
                           const std::vector<MeshLib::Node*>& nodes,
                           std::vector<MeshLib::Element*>& new_elements) const;
 
    unsigned subdivideHex(MeshLib::Element const* const hex,
                          const std::vector<MeshLib::Node*>& nodes,
                          std::vector<MeshLib::Element*>& new_elements) const;
 
    unsigned subdividePyramid(
        MeshLib::Element const* const pyramid,
        const std::vector<MeshLib::Node*>& nodes,
        std::vector<MeshLib::Element*>& new_elements) const;
 
    unsigned subdividePrism(MeshLib::Element const* const prism,
                            const std::vector<MeshLib::Node*>& nodes,
                            std::vector<MeshLib::Element*>& new_elements) const;
 
    MeshLib::Element* constructLine(
        MeshLib::Element const* const element,
        const std::vector<MeshLib::Node*>& nodes) const;
    MeshLib::Element* constructTri(
        MeshLib::Element const* const element,
        const std::vector<MeshLib::Node*>& nodes) const;
    MeshLib::Element* constructFourNodeElement(
        MeshLib::Element const* const element,
        const std::vector<MeshLib::Node*>& nodes,
        unsigned min_elem_dim = 1) const;
 
    unsigned reduceHex(MeshLib::Element const* const org_elem,
                       unsigned n_unique_nodes,
                       const std::vector<MeshLib::Node*>& nodes,
                       std::vector<MeshLib::Element*>& new_elements,
                       unsigned min_elem_dim) const;
    void reducePyramid(MeshLib::Element const* const org_elem,
                       unsigned n_unique_nodes,
                       const std::vector<MeshLib::Node*>& nodes,
                       std::vector<MeshLib::Element*>& new_elements,
                       unsigned min_elem_dim) const;
    unsigned reducePrism(MeshLib::Element const* const org_elem,
                         unsigned n_unique_nodes,
                         std::vector<MeshLib::Node*> const& nodes,
                         std::vector<MeshLib::Element*>& new_elements,
                         unsigned min_elem_dim) const;
 
    // In an element with 5 unique nodes, return the node that will be the top
    // of the resulting pyramid
    static unsigned findPyramidTopNode(
        MeshLib::Element const& element,
        std::array<std::size_t, 4> const& base_node_ids);
 
    static unsigned lutHexDiametralNode(unsigned id);
 
    static std::array<unsigned, 4> lutHexCuttingQuadNodes(unsigned id1,
                                                          unsigned id2);
 
    static std::pair<unsigned, unsigned> lutHexBackNodes(unsigned i, unsigned j,
                                                         unsigned k,
                                                         unsigned l);
 
    static unsigned lutPrismThirdNode(unsigned id1, unsigned id2);
 
    Mesh& _mesh;
 
    static const std::array<unsigned, 8> _hex_diametral_nodes;
};
 
}  // namespace MeshLib