Detailed Description

Collapses nodes with a distance smaller min_distance and reduces elements accordingly.

Definition at line 24 of file MeshRevision.h.

#include <MeshRevision.h>

Collaboration diagram for MeshToolsLib::MeshRevision:

Public Member Functions
	MeshRevision (MeshLib::Mesh &mesh)
unsigned	getNumberOfCollapsibleNodes (double eps=std::numeric_limits< double >::epsilon()) const
	Returns the number of potentially collapsible nodes.
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 Member Functions
std::vector< MeshLib::Node * >	constructNewNodesArray (const std::vector< std::size_t > &id_map) const

Private Attributes
MeshLib::Mesh &	_mesh
	The original mesh used for constructing the class.

Constructor & Destructor Documentation

◆ MeshRevision()

MeshToolsLib::MeshRevision::MeshRevision ( MeshLib::Mesh & mesh )

explicit

Constructor

Parameters

mesh	The mesh which is being revised. Note that node IDs in mesh are changed during computation but are reset after the algorithms implemented here are finished

Definition at line 979 of file MeshRevision.cpp.

979: _mesh(mesh) {}

MeshToolsLib::MeshRevision::_mesh

MeshLib::Mesh & _mesh

The original mesh used for constructing the class.

Definition MeshRevision.h:64

References _mesh.

Member Function Documentation

◆ collapseNodeIndices()

std::vector< std::size_t > MeshToolsLib::MeshRevision::collapseNodeIndices ( double eps ) const

Designates nodes to be collapsed by setting their ID to the index of the node they will get merged with.

Definition at line 1068 of file MeshRevision.cpp.

{
    const std::vector<MeshLib::Node*>& nodes(_mesh.getNodes());
    const std::size_t nNodes(_mesh.getNumberOfNodes());
    std::vector<std::size_t> id_map(nNodes);
    const double half_eps(eps / 2.0);
    const double sqr_eps(eps * eps);
    std::iota(id_map.begin(), id_map.end(), 0);
 
    GeoLib::Grid<MeshLib::Node> const grid(nodes.begin(), nodes.end(), 64);
 
    for (std::size_t k = 0; k < nNodes; ++k)
    {
        MeshLib::Node const* const node(nodes[k]);
        if (node->getID() != k)
        {
            continue;
        }
        std::vector<std::vector<MeshLib::Node*> const*> const node_vectors(
            grid.getPntVecsOfGridCellsIntersectingCube(*node, half_eps));
 
        const std::size_t nVectors(node_vectors.size());
        for (std::size_t i = 0; i < nVectors; ++i)
        {
            const std::vector<MeshLib::Node*>& cell_vector(*node_vectors[i]);
            const std::size_t nGridCellNodes(cell_vector.size());
            for (std::size_t j = 0; j < nGridCellNodes; ++j)
            {
                MeshLib::Node const* const test_node(cell_vector[j]);
                // are node indices already identical (i.e. nodes will be
                // collapsed)
                if (id_map[node->getID()] == id_map[test_node->getID()])
                {
                    continue;
                }
 
                // if test_node has already been collapsed to another node x,
                // ignore it (if the current node would need to be collapsed
                // with x it would already have happened when x was tested)
                if (test_node->getID() != id_map[test_node->getID()])
                {
                    continue;
                }
 
                // calc distance
                if (MathLib::sqrDist(*node, *test_node) < sqr_eps)
                {
                    WARN("nodes {} and {} can be collapsed", *node, *test_node);
                    id_map[test_node->getID()] = node->getID();
                }
            }
        }
    }
    return id_map;
}

References _mesh, MathLib::Point3dWithID::getID(), GeoLib::Grid< POINT >::getPntVecsOfGridCellsIntersectingCube(), MathLib::sqrDist(), and WARN().

Referenced by getNumberOfCollapsibleNodes(), MeshAnalysisDialog::on_startButton_pressed(), and simplifyMesh().

◆ constructNewNodesArray()

std::vector< MeshLib::Node * > MeshToolsLib::MeshRevision::constructNewNodesArray ( const std::vector< std::size_t > & id_map ) const

private

Constructs a new node vector for the resulting mesh by removing all nodes whose ID indicates they need to be merged/removed.

Definition at line 1125 of file MeshRevision.cpp.

{
    const std::vector<MeshLib::Node*>& nodes(_mesh.getNodes());
    const std::size_t nNodes(nodes.size());
    std::vector<MeshLib::Node*> new_nodes;
    new_nodes.reserve(nNodes);
    for (std::size_t k = 0; k < nNodes; ++k)
    {
        // all nodes that have not been collapsed with other nodes are copied
        // into new array
        if (nodes[k]->getID() == id_map[k])
        {
            std::size_t const id(new_nodes.size());
            new_nodes.push_back(new MeshLib::Node(
                (*nodes[k])[0], (*nodes[k])[1], (*nodes[k])[2], id));
            nodes[k]->setID(id);  // the node in the old array gets the index of
                                  // the same node in the new array
        }
        // the other nodes are not copied and get the index of the nodes they
        // will have been collapsed with
        else
        {
            nodes[k]->setID(nodes[id_map[k]]->getID());
        }
    }
    return new_nodes;
}

References _mesh.

Referenced by simplifyMesh().

◆ getNumberOfCollapsibleNodes()

unsigned MeshToolsLib::MeshRevision::getNumberOfCollapsibleNodes ( double eps = std::numeric_limits<double>::epsilon() ) const

Returns the number of potentially collapsible nodes.

Definition at line 981 of file MeshRevision.cpp.

{
    std::vector<std::size_t> const id_map = collapseNodeIndices(eps);
    std::size_t const nNodes = id_map.size();
    unsigned count(0);
    for (std::size_t i = 0; i < nNodes; ++i)
    {
        if (i != id_map[i])
        {
            count++;
        }
    }
    return count;
}

References collapseNodeIndices().

Referenced by MeshToolsLib::MeshValidation::existCollapsibleNodes().

◆ simplifyMesh()

MeshLib::Mesh * MeshToolsLib::MeshRevision::simplifyMesh	(	const std::string &	new_mesh_name,
		double	eps,
		unsigned	min_elem_dim = 1 ) const

Create a new mesh where all nodes with a distance < eps from each other are collapsed. Elements are adjusted accordingly and elements with nonplanar faces are subdivided into geometrically correct elements.

Parameters

new_mesh_name	New name.
eps	Minimum distance for nodes not to be collapsed
min_elem_dim	Minimum dimension of elements to be inserted into new mesh (i.e. min_elem_dim=3 will prevent the new mesh to contain 2D elements)

Definition at line 996 of file MeshRevision.cpp.

{
    if (this->_mesh.getNumberOfElements() == 0)
    {
        return nullptr;
    }
 
    std::vector<MeshLib::Element*> const& elements(this->_mesh.getElements());
    auto const node_ids = collapseNodeIndices(eps);
    std::vector<MeshLib::Node*> new_nodes =
        this->constructNewNodesArray(node_ids);
    std::vector<MeshLib::Element*> new_elements;
    std::vector<std::size_t> element_ids;
 
    for (std::size_t k(0); k < elements.size(); ++k)
    {
        MeshLib::Element const* const elem(elements[k]);
        unsigned const n_unique_nodes(getNumberOfUniqueNodes(elem));
        if (n_unique_nodes == elem->getNumberOfBaseNodes() &&
            elem->getDimension() >= min_elem_dim)
        {
            ElementErrorCode const e = elem->validate();
            if (e[ElementErrorFlag::NonCoplanar])
            {
                std::size_t const n_new_elements(
                    subdivideElement(elem, new_nodes, new_elements));
                if (n_new_elements == 0)
                {
                    ERR("Element {:d} has unknown element type.", k);
                    _mesh.resetNodeIDs();
                    BaseLib::cleanupVectorElements(new_nodes, new_elements);
                    return nullptr;
                }
                element_ids.insert(element_ids.end(), n_new_elements, k);
            }
            else
            {
                new_elements.push_back(MeshLib::copyElement(elem, new_nodes));
                element_ids.push_back(k);
            }
        }
        else if (n_unique_nodes < elem->getNumberOfBaseNodes() &&
                 n_unique_nodes > 1)
        {
            std::size_t const n_new_elements(reduceElement(
                elem, n_unique_nodes, new_nodes, new_elements, min_elem_dim));
            element_ids.insert(element_ids.end(), n_new_elements, k);
        }
        else
        {
            ERR("Something is wrong, more unique nodes than actual nodes");
        }
    }
 
    auto const& props = _mesh.getProperties();
    MeshLib::Properties const new_properties =
        copyProperties(props, node_ids, element_ids);
 
    _mesh.resetNodeIDs();
    if (!new_elements.empty())
    {
        return new MeshLib::Mesh(new_mesh_name, new_nodes, new_elements,
                                 true /* compute_element_neighbors */,
                                 new_properties);
    }
 
    BaseLib::cleanupVectorElements(new_nodes, new_elements);
    return nullptr;
}

References _mesh, BaseLib::cleanupVectorElements(), collapseNodeIndices(), constructNewNodesArray(), MeshLib::copyElement(), ERR(), MeshLib::Element::getDimension(), MeshLib::Element::getNumberOfBaseNodes(), NonCoplanar, and MeshLib::Element::validate().

Referenced by MeshToolsLib::convertSurfaceToMesh(), and main().

Member Data Documentation

◆ _mesh

MeshLib::Mesh& MeshToolsLib::MeshRevision::_mesh

private

The original mesh used for constructing the class.

Definition at line 64 of file MeshRevision.h.

Referenced by MeshRevision(), collapseNodeIndices(), constructNewNodesArray(), and simplifyMesh().

The documentation for this class was generated from the following files: