LayeredVolume Class Reference

Detailed Description

Creates a volume geometry from 2D mesh layers based on raster data.

Definition at line 32 of file LayeredVolume.h.

#include <LayeredVolume.h>

Inheritance diagram for LayeredVolume:

Collaboration diagram for LayeredVolume:

Public Member Functions
	LayeredVolume ()=default
	~LayeredVolume () override=default
bool	createRasterLayers (const MeshLib::Mesh &mesh, const std::vector< GeoLib::Raster const * > &rasters, double minimum_thickness, double noDataReplacementValue=0.0) override
std::vector< MeshLib::Node >	getAttributePoints () const
Public Member Functions inherited from LayeredMeshGenerator
virtual bool	createLayers (MeshLib::Mesh const &mesh, std::vector< GeoLib::Raster const * > const &rasters, double minimum_thickness, double noDataReplacementValue=0.0) final
std::unique_ptr< MeshLib::Mesh >	getMesh (std::string const &mesh_name) const
	Returns a mesh of the subsurface representation.

Private Member Functions
void	addLayerToMesh (const MeshLib::Mesh &dem_mesh, unsigned layer_id, GeoLib::Raster const &raster) override
	Adds another layer to the subsurface mesh.
void	addLayerBoundaries (const MeshLib::Mesh &layer, std::size_t nLayers)
void	removeCongruentElements (std::size_t nLayers, std::size_t nElementsPerLayer)
	Removes duplicate 2D elements (possible due to outcroppings)

Private Attributes
std::vector< MeshLib::Node >	_attribute_points

Additional Inherited Members
Protected Member Functions inherited from LayeredMeshGenerator
	LayeredMeshGenerator ()=default
virtual	~LayeredMeshGenerator ()=default
MeshLib::Node *	getNewLayerNode (MeshLib::Node const &dem_node, MeshLib::Node const &last_layer_node, GeoLib::Raster const &raster, std::size_t new_node_id) const
Static Protected Member Functions inherited from LayeredMeshGenerator
static double	calcEpsilon (GeoLib::Raster const &low, GeoLib::Raster const &high)
	Calculates a data-dependent epsilon value.
Protected Attributes inherited from LayeredMeshGenerator
double	_elevation_epsilon {0.0001}
double	_minimum_thickness {std::numeric_limits<float>::epsilon()}
std::vector< int >	_materials
std::vector< MeshLib::Node * >	_nodes
std::vector< MeshLib::Element * >	_elements

Constructor & Destructor Documentation

LayeredVolume()

LayeredVolume::LayeredVolume ( )

default

~LayeredVolume()

LayeredVolume::~LayeredVolume ( )

overridedefault

Member Function Documentation

addLayerBoundaries()

void LayeredVolume::addLayerBoundaries ( const MeshLib::Mesh & layer, std::size_t nLayers )

private

Creates boundary surfaces between the mapped layers to make the volumes watertight

Definition at line 133 of file LayeredVolume.cpp.

{
    const unsigned nLayerBoundaries(nLayers - 1);
    const std::size_t nNodes(layer.getNumberOfNodes());
    const std::vector<MeshLib::Element*>& layer_elements(layer.getElements());
    for (MeshLib::Element* elem : layer_elements)
    {
        const std::size_t nElemNodes(elem->getNumberOfBaseNodes());
        for (unsigned i = 0; i < nElemNodes; ++i)
        {
            if (elem->getNeighbor(i) == nullptr)
            {
                for (unsigned j = 0; j < nLayerBoundaries; ++j)
                {
                    const std::size_t offset(j * nNodes);
                    MeshLib::Node* n0 = _nodes[offset + getNodeIndex(*elem, i)];
                    MeshLib::Node* n1 =
                        _nodes[offset +
                               getNodeIndex(*elem, (i + 1) % nElemNodes)];
                    MeshLib::Node* n2 =
                        _nodes[offset + nNodes +
                               getNodeIndex(*elem, (i + 1) % nElemNodes)];
                    MeshLib::Node* n3 =
                        _nodes[offset + nNodes + getNodeIndex(*elem, i)];
 
                    auto const& v0 = n0->asEigenVector3d();
                    auto const& v1 = n1->asEigenVector3d();
                    auto const& v2 = n2->asEigenVector3d();
                    auto const& v3 = n3->asEigenVector3d();
                    double const eps = std::numeric_limits<double>::epsilon();
 
                    if ((v2 - v1).norm() > eps)
                    {
                        const std::array tri_nodes = {n0, n2, n1};
                        _elements.push_back(new MeshLib::Tri(tri_nodes));
                        _materials.push_back(nLayers + j);
                    }
                    if ((v3 - v0).norm() > eps)
                    {
                        const std::array tri_nodes = {n0, n3, n2};
                        _elements.push_back(new MeshLib::Tri(tri_nodes));
                        _materials.push_back(nLayers + j);
                    }
                }
            }
        }
    }
}

References LayeredMeshGenerator::_elements, LayeredMeshGenerator::_materials, LayeredMeshGenerator::_nodes, MathLib::Point3d::asEigenVector3d(), MeshLib::Mesh::getElements(), and MeshLib::Mesh::getNumberOfNodes().

Referenced by createRasterLayers().

addLayerToMesh()

void LayeredVolume::addLayerToMesh ( const MeshLib::Mesh & dem_mesh, unsigned layer_id, GeoLib::Raster const & raster )

overrideprivatevirtual

Adds another layer to the subsurface mesh.

Implements LayeredMeshGenerator.

Definition at line 90 of file LayeredVolume.cpp.

{
    const std::size_t nNodes(dem_mesh.getNumberOfNodes());
    const std::vector<MeshLib::Node*>& nodes(dem_mesh.getNodes());
    const std::size_t node_id_offset(_nodes.size());
    const std::size_t last_layer_node_offset(node_id_offset - nNodes);
 
    for (std::size_t i = 0; i < nNodes; ++i)
    {
        _nodes.push_back(getNewLayerNode(*nodes[i],
                                         *_nodes[last_layer_node_offset + i],
                                         raster,
                                         _nodes.size()));
    }
 
    const std::vector<MeshLib::Element*>& layer_elements(
        dem_mesh.getElements());
    for (MeshLib::Element* elem : layer_elements)
    {
        if (elem->getGeomType() == MeshLib::MeshElemType::TRIANGLE)
        {
            std::array<MeshLib::Node*, 3> tri_nodes = {
                {_nodes[node_id_offset + getNodeIndex(*elem, 0)],
                 _nodes[node_id_offset + getNodeIndex(*elem, 1)],
                 _nodes[node_id_offset + getNodeIndex(*elem, 2)]}};
            _elements.push_back(new MeshLib::Tri(tri_nodes));
            _materials.push_back(layer_id);
        }
        else if (elem->getGeomType() == MeshLib::MeshElemType::QUAD)
        {
            std::array<MeshLib::Node*, 4> quad_nodes = {
                {_nodes[node_id_offset + getNodeIndex(*elem, 0)],
                 _nodes[node_id_offset + getNodeIndex(*elem, 1)],
                 _nodes[node_id_offset + getNodeIndex(*elem, 2)],
                 _nodes[node_id_offset + getNodeIndex(*elem, 3)]}};
            _elements.push_back(new MeshLib::Quad(quad_nodes));
            _materials.push_back(layer_id);
        }
    }
}

References LayeredMeshGenerator::_elements, LayeredMeshGenerator::_materials, LayeredMeshGenerator::_nodes, MeshLib::Mesh::getElements(), LayeredMeshGenerator::getNewLayerNode(), MeshLib::Mesh::getNodes(), MeshLib::Mesh::getNumberOfNodes(), MeshLib::QUAD, and MeshLib::TRIANGLE.

Referenced by createRasterLayers().

createRasterLayers()

bool LayeredVolume::createRasterLayers ( const MeshLib::Mesh & mesh, const std::vector< GeoLib::Raster const * > & rasters, double minimum_thickness, double noDataReplacementValue = 0.0 )

overridevirtual

Constructs a subsurface representation of a mesh using only 2D elements (i.e. layer boundaries are represented by surfaces)

Parameters

mesh	The 2D surface mesh that is used as a basis for the subsurface mesh
rasters	Containing all the raster-data for the subsurface layers from bottom to top (starting with the bottom of the oldest layer and ending with the DEM)
minimum_thickness	Minimum thickness of each of the newly created layers (i.e. nodes with a vertical distance smaller than this will be collapsed)
noDataReplacementValue	Default z-coordinate if there are mesh nodes not located on the DEM raster (i.e. raster_paths[0])

Returns

true if the subsurface representation has been created, false if there was an error

Implements LayeredMeshGenerator.

Definition at line 27 of file LayeredVolume.cpp.

{
    if (mesh.getDimension() != 2)
    {
        return false;
    }
 
    _elevation_epsilon = calcEpsilon(*rasters[0], *rasters.back());
    if (_elevation_epsilon <= 0)
    {
        return false;
    }
 
    // remove line elements, only tri + quad remain
    MeshLib::ElementSearch ex(mesh);
    ex.searchByElementType(MeshLib::MeshElemType::LINE);
    std::unique_ptr<MeshLib::Mesh> top(MeshToolsLib::removeElements(
        mesh, ex.getSearchedElementIDs(), "MeshLayer"));
    if (top == nullptr)
    {
        top = std::make_unique<MeshLib::Mesh>(mesh);
    }
 
    if (!MeshToolsLib::MeshLayerMapper::layerMapping(
            *top, *rasters.back(), noDataReplacementValue))
    {
        return false;
    }
 
    std::unique_ptr<MeshLib::Mesh> bottom(new MeshLib::Mesh(*top));
    if (!MeshToolsLib::MeshLayerMapper::layerMapping(*bottom, *rasters[0], 0))
    {
        return false;
    }
 
    this->_minimum_thickness = minimum_thickness;
    _nodes = MeshLib::copyNodeVector(bottom->getNodes());
    _elements = MeshLib::copyElementVector(bottom->getElements(), _nodes);
    if (!_materials.empty())
    {
        ERR("The materials vector is not empty.");
        return false;
    }
    _materials.resize(_elements.size(), 0);
 
    // map each layer and attach to subsurface mesh
    const std::size_t nRasters(rasters.size());
    for (std::size_t i = 1; i < nRasters; ++i)
    {
        this->addLayerToMesh(*top, i, *rasters[i]);
    }
 
    // close boundaries between layers
    this->addLayerBoundaries(*top, nRasters);
    this->removeCongruentElements(nRasters, top->getNumberOfElements());
 
    return true;
}

References LayeredMeshGenerator::_elements, LayeredMeshGenerator::_elevation_epsilon, LayeredMeshGenerator::_materials, LayeredMeshGenerator::_minimum_thickness, LayeredMeshGenerator::_nodes, addLayerBoundaries(), addLayerToMesh(), LayeredMeshGenerator::calcEpsilon(), MeshLib::copyElementVector(), MeshLib::copyNodeVector(), ERR(), MeshLib::Mesh::getDimension(), MeshLib::ElementSearch::getSearchedElementIDs(), MeshToolsLib::MeshLayerMapper::layerMapping(), MeshLib::LINE, removeCongruentElements(), MeshToolsLib::removeElements(), and MeshLib::ElementSearch::searchByElementType().

getAttributePoints()

std::vector< MeshLib::Node > LayeredVolume::getAttributePoints ( ) const

inline

Returns the region attribute vector necessary for assigning region attributes via TetGen

Definition at line 64 of file LayeredVolume.h.

    {
        return _attribute_points;
    }

References _attribute_points.

Referenced by MeshLayerEditDialog::createTetMesh(), and main().

removeCongruentElements()

void LayeredVolume::removeCongruentElements ( std::size_t nLayers, std::size_t nElementsPerLayer )

private

Removes duplicate 2D elements (possible due to outcroppings)

Definition at line 183 of file LayeredVolume.cpp.

{
    for (std::size_t i = nLayers - 1; i > 0; --i)
    {
        const std::size_t lower_offset((i - 1) * nElementsPerLayer);
        const std::size_t upper_offset(i * nElementsPerLayer);
        for (std::size_t j = 0; j < nElementsPerLayer; ++j)
        {
            MeshLib::Element const* const high(_elements[upper_offset + j]);
            MeshLib::Element* const low(_elements[lower_offset + j]);
 
            unsigned count(0);
            const std::size_t nElemNodes(low->getNumberOfBaseNodes());
            for (std::size_t k = 0; k < nElemNodes; ++k)
            {
                if (getNodeIndex(*high, k) == getNodeIndex(*low, k))
                {
                    low->setNode(k, _nodes[getNodeIndex(*high, k)]);
                    count++;
                }
            }
 
            if (count == nElemNodes)
            {
                delete _elements[upper_offset + j];
                // mark element and material entries for deletion
                _elements[upper_offset + j] = nullptr;
                _materials[upper_offset + j] = -1;
            }
            else
            {
                auto const& attr = MeshLib::getCenterOfGravity(*high);
                _attribute_points.emplace_back(
                    attr[0],
                    attr[1],
                    (attr[2] + MeshLib::getCenterOfGravity(*low)[2]) / 2.0,
                    _materials[lower_offset + j]);
            }
        }
    }
    // delete marked entries
    auto elem_vec_end =
        std::remove(_elements.begin(), _elements.end(), nullptr);
    _elements.erase(elem_vec_end, _elements.end());
    auto mat_vec_end = std::remove(_materials.begin(), _materials.end(), -1);
    _materials.erase(mat_vec_end, _materials.end());
}

References _attribute_points, LayeredMeshGenerator::_elements, LayeredMeshGenerator::_materials, LayeredMeshGenerator::_nodes, MeshLib::getCenterOfGravity(), MeshLib::Element::getNumberOfBaseNodes(), and MeshLib::Element::setNode().

Referenced by createRasterLayers().

Member Data Documentation

_attribute_points

std::vector<MeshLib::Node> LayeredVolume::_attribute_points

private

Definition at line 83 of file LayeredVolume.h.

Referenced by getAttributePoints(), and removeCongruentElements().

---

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

• MeshToolsLib/MeshGenerators/LayeredVolume.h
• MeshToolsLib/MeshGenerators/LayeredVolume.cpp