MeshGeoToolsLib::GeoMapper Class Reference

Detailed Description

A set of tools for mapping the elevation of geometric objects.

Definition at line 39 of file GeoMapper.h.

#include <GeoMapper.h>

Collaboration diagram for MeshGeoToolsLib::GeoMapper:

Public Member Functions
	GeoMapper (GeoLib::GEOObjects &geo_objects, const std::string &geo_name)
	~GeoMapper ()
void	mapOnDEM (std::unique_ptr< GeoLib::Raster const > raster)
	Maps geometry based on a raster file.
void	mapOnMesh (MeshLib::Mesh const *const mesh)
void	mapToConstantValue (double value)
	Maps geometry to a constant elevation value.
void	advancedMapOnMesh (MeshLib::Mesh const &mesh)

Private Member Functions
void	mapStationData (std::vector< GeoLib::Point * > const &points)
	Mapping stations, boreholes on a raster or mesh.
void	mapPointDataToDEM (std::vector< GeoLib::Point * > const &points) const
	Mapping points on a raster.
void	mapPointDataToMeshSurface (std::vector< GeoLib::Point * > const &pnts)
	Mapping points on mesh.
double	getMeshElevation (double x, double y, double min_val, double max_val) const
float	getDemElevation (GeoLib::Point const &pnt) const
	Returns the elevation at Point (x,y) based on a raster.

Private Attributes
GeoLib::GEOObjects &	_geo_objects
std::string &	_geo_name
MeshLib::Mesh *	_surface_mesh
	only necessary for mapping on mesh
GeoLib::Grid< MeshLib::Node > *	_grid
std::unique_ptr< GeoLib::Raster const >	_raster
	only necessary for mapping on DEM

Constructor & Destructor Documentation

GeoMapper()

MeshGeoToolsLib::GeoMapper::GeoMapper	(	GeoLib::GEOObjects &	geo_objects,
		const std::string &	geo_name )

Definition at line 37 of file GeoMapper.cpp.

    : _geo_objects(geo_objects),
      _geo_name(const_cast<std::string&>(geo_name)),
      _surface_mesh(nullptr),
      _grid(nullptr),
      _raster(nullptr)
{
}

~GeoMapper()

MeshGeoToolsLib::GeoMapper::~GeoMapper

(

)

Definition at line 47 of file GeoMapper.cpp.

{
    delete _surface_mesh;
}

References _surface_mesh.

Member Function Documentation

advancedMapOnMesh()

void MeshGeoToolsLib::GeoMapper::advancedMapOnMesh

(

MeshLib::Mesh const &

mesh

)

Maps the geometry based on the given mesh file. I.e., all geometric points are assigned an elevation value on the mesh surface. Additional points are inserted whenever a polyline from the original geometry intersects a mesh node or the edge of a mesh element. A new geometry with the given name is inserted into _geo_objects.

Parameters

mesh	Mesh the geometry is mapped on

Definition at line 615 of file GeoMapper.cpp.

{
    // 1. extract surface
    delete _surface_mesh;
 
    if (mesh.getDimension() < 3)
    {
        _surface_mesh = new MeshLib::Mesh(mesh);
    }
    else
    {
        Eigen::Vector3d const dir({0, 0, -1});
        _surface_mesh = MeshToolsLib::MeshSurfaceExtraction::getMeshSurface(
            mesh, dir, 90 + 1e-6);
    }
 
    // 2. compute mesh grid for surface
    MeshLib::MeshElementGrid const mesh_element_grid(*_surface_mesh);
 
    // 3. map each polyline
    auto org_lines(_geo_objects.getPolylineVec(_geo_name));
    auto org_points(_geo_objects.getPointVecObj(_geo_name));
    for (auto org_line : *org_lines)
    {
        mapPolylineOnSurfaceMesh(*org_line, *org_points, mesh_element_grid);
    }
}

References MeshLib::Mesh::getDimension(), MeshToolsLib::MeshSurfaceExtraction::getMeshSurface(), and MeshGeoToolsLib::mapPolylineOnSurfaceMesh().

Referenced by main(), and MainWindow::mapGeometry().

getDemElevation()

float MeshGeoToolsLib::GeoMapper::getDemElevation ( GeoLib::Point const & pnt ) const

private

Returns the elevation at Point (x,y) based on a raster.

Definition at line 206 of file GeoMapper.cpp.

{
    double const elevation(_raster->getValueAtPoint(pnt));
    if (std::abs(elevation - _raster->getHeader().no_data) <
        std::numeric_limits<double>::epsilon())
    {
        return 0.0;
    }
    return static_cast<float>(elevation);
}

References _raster.

Referenced by mapPointDataToDEM(), and mapStationData().

getMeshElevation()

double MeshGeoToolsLib::GeoMapper::getMeshElevation ( double x, double y, double min_val, double max_val ) const

private

Returns the elevation at Point (x,y) based on a mesh. This uses collision detection for triangles and nearest neighbor for quads. NOTE: This method only returns correct values if the node numbering of the elements is correct!

Definition at line 217 of file GeoMapper.cpp.

{
    const MeshLib::Node* pnt =
        _grid->getNearestPoint(MathLib::Point3d{{{x, y, 0}}});
    auto const elements(
        _surface_mesh->getElementsConnectedToNode(pnt->getID()));
    std::unique_ptr<GeoLib::Point> intersection;
 
    for (auto const& element : elements)
    {
        if (intersection == nullptr &&
            element->getGeomType() != MeshLib::MeshElemType::LINE)
        {
            intersection = GeoLib::triangleLineIntersection(
                *element->getNode(0), *element->getNode(1),
                *element->getNode(2), GeoLib::Point(x, y, max_val),
                GeoLib::Point(x, y, min_val));
        }
 
        if (intersection == nullptr &&
            element->getGeomType() == MeshLib::MeshElemType::QUAD)
        {
            intersection = GeoLib::triangleLineIntersection(
                *element->getNode(0), *element->getNode(2),
                *element->getNode(3), GeoLib::Point(x, y, max_val),
                GeoLib::Point(x, y, min_val));
        }
    }
    if (intersection)
    {
        return (*intersection)[2];
    }
    // if something goes wrong, simply take the elevation of the nearest mesh
    // node
    return (*(_surface_mesh->getNode(pnt->getID())))[2];
}

References _grid, _surface_mesh, MeshLib::Mesh::getElementsConnectedToNode(), MathLib::Point3dWithID::getID(), GeoLib::Grid< POINT >::getNearestPoint(), MeshLib::Mesh::getNode(), MeshLib::LINE, MeshLib::QUAD, and GeoLib::triangleLineIntersection().

Referenced by mapPointDataToMeshSurface(), and mapStationData().

mapOnDEM()

void MeshGeoToolsLib::GeoMapper::mapOnDEM

(

std::unique_ptr< GeoLib::Raster const >

raster

)

Maps geometry based on a raster file.

Definition at line 52 of file GeoMapper.cpp.

{
    std::vector<GeoLib::Point*> const* pnts(
        _geo_objects.getPointVec(_geo_name));
    if (!pnts)
    {
        ERR("Geometry '{:s}' does not exist.", _geo_name);
        return;
    }
    _raster = std::move(raster);
 
    if (GeoLib::isStation((*pnts)[0]))
    {
        mapStationData(*pnts);
    }
    else
    {
        mapPointDataToDEM(*pnts);
    }
}

References _geo_name, _geo_objects, _raster, ERR(), GeoLib::GEOObjects::getPointVec(), GeoLib::isStation(), mapPointDataToDEM(), and mapStationData().

Referenced by MainWindow::mapGeometry().

mapOnMesh()

void MeshGeoToolsLib::GeoMapper::mapOnMesh

(

MeshLib::Mesh const *const

mesh

)

Maps the geometry based on the given mesh file. The elevation value of all geometric points are modified such that they are located on the mesh surface.

Definition at line 73 of file GeoMapper.cpp.

{
    std::vector<GeoLib::Point*> const* pnts(
        _geo_objects.getPointVec(_geo_name));
    if (!pnts)
    {
        ERR("Geometry '{:s}' does not exist.", _geo_name);
        return;
    }
 
    // the variable _surface_mesh is reused below, so first the existing
    // _surface_mesh has to be cleaned up
    delete _surface_mesh;
 
    if (mesh->getDimension() < 3)
    {
        _surface_mesh = new MeshLib::Mesh(*mesh);
    }
    else
    {
        Eigen::Vector3d const dir(0, 0, -1);
        _surface_mesh =
            MeshToolsLib::MeshSurfaceExtraction::getMeshSurface(*mesh, dir, 90);
    }
 
    // init grid
    MathLib::Point3d origin(std::array<double, 3>{{0, 0, 0}});
    std::vector<MeshLib::Node> flat_nodes;
    flat_nodes.reserve(_surface_mesh->getNumberOfNodes());
    // copy nodes and project the copied nodes to the x-y-plane, i.e. set
    // z-coordinate to zero
    for (auto n_ptr : _surface_mesh->getNodes())
    {
        flat_nodes.emplace_back(*n_ptr);
        flat_nodes.back()[2] = 0.0;
    }
    _grid =
        new GeoLib::Grid<MeshLib::Node>(flat_nodes.cbegin(), flat_nodes.cend());
 
    if (GeoLib::isStation((*pnts)[0]))
    {
        mapStationData(*pnts);
    }
    else
    {
        mapPointDataToMeshSurface(*pnts);
    }
 
    delete _grid;
}

References _geo_name, _geo_objects, _grid, _surface_mesh, ERR(), MeshLib::Mesh::getDimension(), MeshToolsLib::MeshSurfaceExtraction::getMeshSurface(), MeshLib::Mesh::getNodes(), MeshLib::Mesh::getNumberOfNodes(), GeoLib::GEOObjects::getPointVec(), GeoLib::isStation(), mapPointDataToMeshSurface(), and mapStationData().

Referenced by createGeometries(), main(), and MainWindow::mapGeometry().

mapPointDataToDEM()

void MeshGeoToolsLib::GeoMapper::mapPointDataToDEM ( std::vector< GeoLib::Point * > const & points ) const

private

Mapping points on a raster.

Definition at line 171 of file GeoMapper.cpp.

{
    for (auto* pnt : points)
    {
        GeoLib::Point& p(*pnt);
        p[2] = getDemElevation(p);
    }
}

References getDemElevation().

Referenced by mapOnDEM().

mapPointDataToMeshSurface()

void MeshGeoToolsLib::GeoMapper::mapPointDataToMeshSurface ( std::vector< GeoLib::Point * > const & pnts )

private

Mapping points on mesh.

Definition at line 181 of file GeoMapper.cpp.

{
    GeoLib::AABB const aabb(_surface_mesh->getNodes().cbegin(),
                            _surface_mesh->getNodes().cend());
    auto const [min, max] = aabb.getMinMaxPoints();
 
    for (auto* pnt : pnts)
    {
        // check if pnt is inside of the bounding box of the _surface_mesh
        // projected onto the y-x plane
        GeoLib::Point& p(*pnt);
        if (p[0] < min[0] || max[0] < p[0])
        {
            continue;
        }
        if (p[1] < min[1] || max[1] < p[1])
        {
            continue;
        }
 
        p[2] = getMeshElevation(p[0], p[1], min[2], max[2]);
    }
}

References _surface_mesh, getMeshElevation(), GeoLib::AABB::getMinMaxPoints(), and MeshLib::Mesh::getNodes().

Referenced by mapOnMesh().

mapStationData()

void MeshGeoToolsLib::GeoMapper::mapStationData ( std::vector< GeoLib::Point * > const & points )

private

Mapping stations, boreholes on a raster or mesh.

Definition at line 137 of file GeoMapper.cpp.

{
    double min_val(0);
    double max_val(0);
    if (_surface_mesh)
    {
        GeoLib::AABB bounding_box(_surface_mesh->getNodes().begin(),
                                  _surface_mesh->getNodes().end());
        min_val = bounding_box.getMinPoint()[2];
        max_val = bounding_box.getMaxPoint()[2];
    }
 
    for (auto* pnt : points)
    {
        double offset =
            (_grid)
                ? (getMeshElevation((*pnt)[0], (*pnt)[1], min_val, max_val) -
                   (*pnt)[2])
                : getDemElevation(*pnt);
 
        if (!GeoLib::isBorehole(pnt))
        {
            (*pnt)[2] = offset;
            continue;
        }
        auto const& layers =
            static_cast<GeoLib::StationBorehole*>(pnt)->getProfile();
        for (auto* layer_pnt : layers)
        {
            (*layer_pnt)[2] = (*layer_pnt)[2] + offset;
        }
    }
}

References _grid, _surface_mesh, getDemElevation(), GeoLib::AABB::getMaxPoint(), getMeshElevation(), GeoLib::AABB::getMinPoint(), MeshLib::Mesh::getNodes(), and GeoLib::isBorehole().

Referenced by mapOnDEM(), and mapOnMesh().

mapToConstantValue()

void MeshGeoToolsLib::GeoMapper::mapToConstantValue

(

double

value

)

Maps geometry to a constant elevation value.

Definition at line 124 of file GeoMapper.cpp.

{
    std::vector<GeoLib::Point*> const* points(
        this->_geo_objects.getPointVec(this->_geo_name));
    if (points == nullptr)
    {
        ERR("Geometry '{:s}' not found.", this->_geo_name);
        return;
    }
    std::for_each(points->begin(), points->end(),
                  [value](GeoLib::Point* pnt) { (*pnt)[2] = value; });
}

References _geo_name, _geo_objects, ERR(), and GeoLib::GEOObjects::getPointVec().

Member Data Documentation

_geo_name

std::string& MeshGeoToolsLib::GeoMapper::_geo_name

private

Definition at line 85 of file GeoMapper.h.

Referenced by mapOnDEM(), mapOnMesh(), and mapToConstantValue().

_geo_objects

GeoLib::GEOObjects& MeshGeoToolsLib::GeoMapper::_geo_objects

private

Definition at line 84 of file GeoMapper.h.

Referenced by mapOnDEM(), mapOnMesh(), and mapToConstantValue().

_grid

GeoLib::Grid<MeshLib::Node>* MeshGeoToolsLib::GeoMapper::_grid

private

Definition at line 89 of file GeoMapper.h.

Referenced by getMeshElevation(), mapOnMesh(), and mapStationData().

_raster

std::unique_ptr<GeoLib::Raster const> MeshGeoToolsLib::GeoMapper::_raster

private

only necessary for mapping on DEM

Definition at line 92 of file GeoMapper.h.

Referenced by getDemElevation(), and mapOnDEM().

_surface_mesh

MeshLib::Mesh* MeshGeoToolsLib::GeoMapper::_surface_mesh

private

only necessary for mapping on mesh

Definition at line 88 of file GeoMapper.h.

Referenced by ~GeoMapper(), getMeshElevation(), mapOnMesh(), mapPointDataToMeshSurface(), and mapStationData().

---

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

• MeshGeoToolsLib/GeoMapper.h
• MeshGeoToolsLib/GeoMapper.cpp