MeshLib::MeshValidation Struct Reference

Detailed Description

A collection of methods for testing mesh quality and correctness.

Definition at line 30 of file MeshValidation.h.

#include <MeshValidation.h>

Public Member Functions
	MeshValidation (MeshLib::Mesh &mesh)

Static Public Member Functions
static std::vector< ElementErrorCode >	testElementGeometry (const MeshLib::Mesh &mesh, double min_volume=std::numeric_limits< double >::epsilon())
static std::array< std::string, static_cast< std::size_t >ElementErrorFlag::MaxValue)>	ElementErrorCodeOutput (const std::vector< ElementErrorCode > &error_codes)
static unsigned	detectHoles (MeshLib::Mesh const &mesh)

Constructor & Destructor Documentation

MeshValidation()

MeshLib::MeshValidation::MeshValidation ( MeshLib::Mesh &  mesh )

explicit

Constructor

Warning

This might change the mesh when removing unused mesh nodes.

Definition at line 64 of file MeshValidation.cpp.

{
    INFO("Mesh Quality Control:");
    INFO("Looking for unused nodes...");
    NodeSearch ns(mesh);
    ns.searchUnused();
    if (!ns.getSearchedNodeIDs().empty())
    {
        INFO("{:d} unused mesh nodes found.", ns.getSearchedNodeIDs().size());
    }
    MeshRevision rev(mesh);
    INFO("Found {:d} potentially collapsible nodes.",
         rev.getNumberOfCollapsableNodes());
 
    const std::vector<ElementErrorCode> codes(
        MeshLib::MeshValidation::testElementGeometry(mesh));
    std::array<std::string,
               static_cast<std::size_t>(ElementErrorFlag::MaxValue)>
        output_str(MeshLib::MeshValidation::ElementErrorCodeOutput(codes));
    for (auto& i : output_str)
    {
        INFO("{:s}", i);
    }
}

References ElementErrorCodeOutput(), MeshLib::MeshRevision::getNumberOfCollapsableNodes(), MeshLib::NodeSearch::getSearchedNodeIDs(), INFO(), MaxValue, MeshLib::NodeSearch::searchUnused(), and testElementGeometry().

Member Function Documentation

detectHoles()

unsigned MeshLib::MeshValidation::detectHoles ( MeshLib::Mesh const &  mesh )

static

Tests if holes are located within the mesh. In this context, a hole is a boundary of an element with no neighbor that cannot be reached from the actual boundary of the mesh. Examples include a missing triangle in a 2D mesh or a missing Tetrahedron in a 3D mesh. The method does not work for 1d-meshes. Note, that this method does not work when complex 3D structures are build from 2D mesh elements, e.g. using the LayeredVolume-class, where more than two 2D elements may share an edge.

Parameters

mesh	The mesh that is tested

Returns

The number of holes that have been found.

Definition at line 198 of file MeshValidation.cpp.

{
    if (mesh.getDimension() == 1)
    {
        return 0;
    }
 
    auto boundary_mesh = MeshLib::BoundaryExtraction::getBoundaryElementsAsMesh(
        mesh, "bulk_node_ids", "bulk_element_ids", "bulk_face_ids");
    std::vector<MeshLib::Element*> const& elements(
        boundary_mesh->getElements());
 
    std::vector<unsigned> sfc_idx(elements.size(),
                                  std::numeric_limits<unsigned>::max());
    unsigned current_surface_id(0);
    auto it = sfc_idx.cbegin();
 
    while (it != sfc_idx.cend())
    {
        std::size_t const idx =
            static_cast<std::size_t>(std::distance(sfc_idx.cbegin(), it));
        trackSurface(elements[idx], sfc_idx, current_surface_id++);
        it = std::find(sfc_idx.cbegin(),
                       sfc_idx.cend(),
                       std::numeric_limits<unsigned>::max());
    }
 
    // Subtract "1" from the number of surfaces found to get the number of
    // holes.
    return (--current_surface_id);
}

References MeshLib::BoundaryExtraction::getBoundaryElementsAsMesh(), MeshLib::Mesh::getDimension(), and MeshLib::trackSurface().

Referenced by MeshAnalysisDialog::on_startButton_pressed(), and MeshLib::MeshInformation::writeMeshValidationResults().

ElementErrorCodeOutput()

std::array< std::string, static_cast< std::size_t >ElementErrorFlag::MaxValue)> MeshLib::MeshValidation::ElementErrorCodeOutput ( const std::vector< ElementErrorCode > &  error_codes )

static

Detailed output which ElementID is associated with which error(s)

Returns

String containing the report

Definition at line 160 of file MeshValidation.cpp.

{
    const auto nErrorFlags(
        static_cast<std::size_t>(ElementErrorFlag::MaxValue));
    ElementErrorFlag flags[nErrorFlags] = {
        ElementErrorFlag::ZeroVolume, ElementErrorFlag::NonCoplanar,
        ElementErrorFlag::NonConvex, ElementErrorFlag::NodeOrder};
    const std::size_t nElements(error_codes.size());
    std::array<std::string,
               static_cast<std::size_t>(ElementErrorFlag::MaxValue)>
        output;
 
    for (std::size_t i = 0; i < nErrorFlags; ++i)
    {
        unsigned count(0);
        std::string elementIdStr;
 
        for (std::size_t j = 0; j < nElements; ++j)
        {
            if (error_codes[j][flags[i]])
            {
                elementIdStr += (std::to_string(j) + ", ");
                count++;
            }
        }
        const std::string nErrorsStr = (count) ? std::to_string(count) : "No";
        output[i] = (nErrorsStr + " elements found with " +
                     ElementErrorCode::toString(flags[i]) + ".\n");
 
        if (count)
        {
            output[i] += ("ElementIDs: " + elementIdStr + "\n");
        }
    }
    return output;
}

References MaxValue, NodeOrder, NonConvex, NonCoplanar, ElementErrorCode::toString(), and ZeroVolume.

Referenced by MeshValidation(), and MeshAnalysisDialog::elementsMsgOutput().

testElementGeometry()

std::vector< ElementErrorCode > MeshLib::MeshValidation::testElementGeometry ( const MeshLib::Mesh &  mesh, double  min_volume = std::numeric_limits<double>::epsilon()  )

static

Tests if elements are geometrically correct.

Parameters

mesh	The mesh that is tested
min_volume	The minimum required volume for a mesh element, so it is NOT considered faulty

Returns

Vector of error codes for each mesh element

Definition at line 89 of file MeshValidation.cpp.

{
    INFO("Testing mesh element geometry:");
    const auto nErrorCodes(
        static_cast<std::size_t>(ElementErrorFlag::MaxValue));
    unsigned error_count[nErrorCodes];
    std::fill_n(error_count, 4, 0);
    const std::size_t nElements(mesh.getNumberOfElements());
    const std::vector<MeshLib::Element*>& elements(mesh.getElements());
    std::vector<ElementErrorCode> error_code_vector;
    error_code_vector.reserve(nElements);
 
    for (std::size_t i = 0; i < nElements; ++i)
    {
        const ElementErrorCode e = elements[i]->validate();
        error_code_vector.push_back(e);
        if (e.none())
        {
            continue;
        }
 
        // increment error statistics
        const std::bitset<static_cast<std::size_t>(ElementErrorFlag::MaxValue)>
            flags(static_cast<std::bitset<static_cast<std::size_t>(
                      ElementErrorFlag::MaxValue)>>(e));
        for (unsigned j = 0; j < nErrorCodes; ++j)
        {
            error_count[j] += flags[j];
        }
    }
 
    // if a larger volume threshold is given, evaluate elements again to add
    // them even if they are formally okay
    if (min_volume > std::numeric_limits<double>::epsilon())
    {
        for (std::size_t i = 0; i < nElements; ++i)
        {
            if (elements[i]->getContent() < min_volume)
            {
                error_code_vector[i].set(ElementErrorFlag::ZeroVolume);
            }
        }
    }
 
    // output
    const auto error_sum(static_cast<unsigned>(
        std::accumulate(error_count, error_count + nErrorCodes, 0.0)));
    if (error_sum != 0)
    {
        ElementErrorFlag flags[nErrorCodes] = {
            ElementErrorFlag::ZeroVolume, ElementErrorFlag::NonCoplanar,
            ElementErrorFlag::NonConvex, ElementErrorFlag::NodeOrder};
        for (std::size_t i = 0; i < nErrorCodes; ++i)
        {
            if (error_count[i])
            {
                INFO("{:d} elements found with {:s}.",
                     error_count[i],
                     ElementErrorCode::toString(flags[i]));
            }
        }
    }
    else
    {
        INFO("No errors found.");
    }
    return error_code_vector;
}

References MeshLib::Mesh::getElements(), MeshLib::Mesh::getNumberOfElements(), INFO(), MaxValue, NodeOrder, NonConvex, NonCoplanar, ElementErrorCode::toString(), and ZeroVolume.

Referenced by MeshValidation(), and MeshAnalysisDialog::on_startButton_pressed().

---

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

• MeshLib/MeshQuality/MeshValidation.h
• MeshLib/MeshQuality/MeshValidation.cpp