GEOModels Class Reference

Detailed Description

GEOModels connects the data management class GEOObjects and the GUI. It inherits from GeoLib::GEOObjects and additionally emits signals when data objects are modified. The GUI connects to these signals. Model instances are created for every data object.

Definition at line 36 of file GEOModels.h.

#include <GEOModels.h>

Inheritance diagram for GEOModels:

Collaboration diagram for GEOModels:

Public Slots
void	updateGeometry (const std::string &geo_name)
virtual void	removeGeometry (std::string const &geo_name, GeoLib::GEOTYPE const type)
void	addPointVec (std::string const &name)
void	removePointVec (std::string const &name)
void	addStationVec (std::string const &name)
void	removeStationVec (std::string const &name)
void	addPolylineVec (std::string const &name)
void	appendPolylineVec (std::string const &name)
void	removePolylineVec (std::string const &name)
void	addSurfaceVec (std::string const &name)
void	appendSurfaceVec (std::string const &name)
void	removeSurfaceVec (std::string const &name)
void	renameGeometry (std::string const &old_name, std::string const &new_name)
void	addNameForElement (std::string const &geometry_name, GeoLib::GEOTYPE const object_type, std::size_t const id, std::string const &new_name)
	Adds the name 'new_name' for the geo-object specified by the parameters. More...
void	addNameForObjectPoints (const std::string &geometry_name, const GeoLib::GEOTYPE object_type, const std::string &geo_object_name, const std::string &new_name)
	Adds a generic name to all points that are part of the specified geo-object. More...
void	connectPolylineSegments (const std::string &geoName, std::vector< std::size_t > const &indexlist, double const proximity, std::string const &ply_name, bool const closePly, bool const triangulatePly)

Signals
void	geoDataAdded (GeoTreeModel *, std::string, GeoLib::GEOTYPE)
void	geoDataRemoved (GeoTreeModel *, std::string, GeoLib::GEOTYPE)
void	stationVectorAdded (StationTreeModel *model, std::string name)
void	stationVectorRemoved (StationTreeModel *model, std::string name)

Public Member Functions
	GEOModels (GeoLib::GEOObjects &geo_objects, QObject *parent=nullptr)
	~GEOModels () override
GeoTreeModel *	getGeoModel ()
StationTreeModel *	getStationModel ()

Protected Attributes
GeoTreeModel *	_geoModel
StationTreeModel *	_stationModel

Private Attributes
GeoLib::GEOObjects &	_geo_objects

Constructor & Destructor Documentation

GEOModels()

GEOModels::GEOModels ( GeoLib::GEOObjects &  geo_objects, QObject *  parent = nullptr  )

explicit

Definition at line 25 of file GEOModels.cpp.

    : QObject(parent), _geo_objects(geo_objects)
{
    _geo_objects._callbacks = std::make_unique<GEOModelsCallbacks>(*this);
 
    _geoModel = new GeoTreeModel();
    _stationModel = new StationTreeModel();
}

References GeoLib::GEOObjects::_callbacks, _geo_objects, _geoModel, and _stationModel.

~GEOModels()

GEOModels::~GEOModels ( )

override

Definition at line 34 of file GEOModels.cpp.

{
    delete _stationModel;
    delete _geoModel;
}

References _geoModel, and _stationModel.

Member Function Documentation

addNameForElement

void GEOModels::addNameForElement ( std::string const &  geometry_name, GeoLib::GEOTYPE const  object_type, std::size_t const  id, std::string const &  new_name  )

slot

Adds the name 'new_name' for the geo-object specified by the parameters.

Definition at line 248 of file GEOModels.cpp.

{
    if (object_type == GeoLib::GEOTYPE::POINT)
    {
        _geo_objects.getPointVecObj(geometry_name)
            ->setNameForElement(id, new_name);
    }
    else if (object_type == GeoLib::GEOTYPE::POLYLINE)
    {
        _geo_objects.getPolylineVecObj(geometry_name)
            ->setNameForElement(id, new_name);
    }
    else if (object_type == GeoLib::GEOTYPE::SURFACE)
    {
        _geo_objects.getSurfaceVecObj(geometry_name)
            ->setNameForElement(id, new_name);
    }
    else
        ERR("GEOModels::addNameForElement() - Unknown GEOTYPE {:s}.",
            GeoLib::convertGeoTypeToString(object_type));
}

References _geo_objects, GeoLib::convertGeoTypeToString(), ERR(), GeoLib::GEOObjects::getPointVecObj(), GeoLib::GEOObjects::getPolylineVecObj(), GeoLib::GEOObjects::getSurfaceVecObj(), GeoLib::POINT, GeoLib::POLYLINE, GeoLib::TemplateVec< T >::setNameForElement(), GeoLib::PointVec::setNameForElement(), and GeoLib::SURFACE.

addNameForObjectPoints

void GEOModels::addNameForObjectPoints ( const std::string &  geometry_name, const GeoLib::GEOTYPE  object_type, const std::string &  geo_object_name, const std::string &  new_name  )

slot

Adds a generic name to all points that are part of the specified geo-object.

Definition at line 273 of file GEOModels.cpp.

{
    const GeoLib::GeoObject* obj =
        _geo_objects.getGeoObject(geometry_name, object_type, geo_object_name);
    GeoLib::PointVec* pnt_vec = _geo_objects.getPointVecObj(geometry_name);
    if (object_type == GeoLib::GEOTYPE::POLYLINE)
    {
        const auto* ply = dynamic_cast<const GeoLib::Polyline*>(obj);
        std::size_t nPoints = ply->getNumberOfPoints();
        for (std::size_t i = 0; i < nPoints; i++)
        {
            pnt_vec->setNameForElement(
                ply->getPointID(i),
                new_name + "_Point" + std::to_string(ply->getPointID(i)));
        }
    }
    else if (object_type == GeoLib::GEOTYPE::SURFACE)
    {
        const auto* sfc = dynamic_cast<const GeoLib::Surface*>(obj);
        std::size_t nTriangles = sfc->getNumberOfTriangles();
        for (std::size_t i = 0; i < nTriangles; i++)
        {
            const GeoLib::Triangle* tri = (*sfc)[i];
            pnt_vec->setNameForElement(
                (*tri)[0], new_name + "_Point" + std::to_string((*tri)[0]));
            pnt_vec->setNameForElement(
                (*tri)[1], new_name + "_Point" + std::to_string((*tri)[1]));
            pnt_vec->setNameForElement(
                (*tri)[2], new_name + "_Point" + std::to_string((*tri)[2]));
        }
    }
    else
        ERR("GEOModels::addNameForObjectPoints() - Unknown GEOTYPE {:s}.",
            GeoLib::convertGeoTypeToString(object_type));
}

References _geo_objects, GeoLib::convertGeoTypeToString(), ERR(), GeoLib::GEOObjects::getGeoObject(), GeoLib::Polyline::getNumberOfPoints(), GeoLib::Surface::getNumberOfTriangles(), GeoLib::GEOObjects::getPointVecObj(), GeoLib::POLYLINE, GeoLib::PointVec::setNameForElement(), and GeoLib::SURFACE.

addPointVec

void GEOModels::addPointVec ( std::string const &  name )

slot

Definition at line 103 of file GEOModels.cpp.

{
    _geoModel->addPointList(QString::fromStdString(name),
                            *_geo_objects.getPointVecObj(name));
    emit geoDataAdded(_geoModel, name, GeoLib::GEOTYPE::POINT);
}

References _geo_objects, _geoModel, GeoTreeModel::addPointList(), geoDataAdded(), GeoLib::GEOObjects::getPointVecObj(), MaterialPropertyLib::name, and GeoLib::POINT.

Referenced by GEOModelsCallbacks::addPointVec().

addPolylineVec

void GEOModels::addPolylineVec ( std::string const &  name )

slot

Definition at line 131 of file GEOModels.cpp.

{
    _geoModel->addPolylineList(QString::fromStdString(name),
                               *_geo_objects.getPolylineVecObj(name));
    emit geoDataAdded(_geoModel, name, GeoLib::GEOTYPE::POLYLINE);
}

References _geo_objects, _geoModel, GeoTreeModel::addPolylineList(), geoDataAdded(), GeoLib::GEOObjects::getPolylineVecObj(), MaterialPropertyLib::name, and GeoLib::POLYLINE.

Referenced by GEOModelsCallbacks::addPolylineVec().

addStationVec

void GEOModels::addStationVec ( std::string const &  name )

slot

Definition at line 118 of file GEOModels.cpp.

{
    _stationModel->addStationList(QString::fromStdString(name),
                                  _geo_objects.getStationVec(name));
    emit stationVectorAdded(_stationModel, name);
}

References _geo_objects, _stationModel, StationTreeModel::addStationList(), GeoLib::GEOObjects::getStationVec(), MaterialPropertyLib::name, and stationVectorAdded().

Referenced by GEOModelsCallbacks::addStationVec().

addSurfaceVec

void GEOModels::addSurfaceVec ( std::string const &  name )

slot

Definition at line 150 of file GEOModels.cpp.

{
    _geoModel->addSurfaceList(QString::fromStdString(name),
                              *_geo_objects.getSurfaceVecObj(name));
    emit geoDataAdded(_geoModel, name, GeoLib::GEOTYPE::SURFACE);
}

References _geo_objects, _geoModel, GeoTreeModel::addSurfaceList(), geoDataAdded(), GeoLib::GEOObjects::getSurfaceVecObj(), MaterialPropertyLib::name, and GeoLib::SURFACE.

Referenced by GEOModelsCallbacks::addSurfaceVec().

appendPolylineVec

void GEOModels::appendPolylineVec ( std::string const &  name )

slot

Definition at line 138 of file GEOModels.cpp.

{
    this->_geoModel->appendPolylines(name,
                                     *_geo_objects.getPolylineVecObj(name));
}

References _geo_objects, _geoModel, GeoTreeModel::appendPolylines(), GeoLib::GEOObjects::getPolylineVecObj(), and MaterialPropertyLib::name.

Referenced by GEOModelsCallbacks::appendPolylineVec().

appendSurfaceVec

void GEOModels::appendSurfaceVec ( std::string const &  name )

slot

Definition at line 157 of file GEOModels.cpp.

{
    _geoModel->appendSurfaces(name, *_geo_objects.getSurfaceVecObj(name));
}

References _geo_objects, _geoModel, GeoTreeModel::appendSurfaces(), GeoLib::GEOObjects::getSurfaceVecObj(), and MaterialPropertyLib::name.

Referenced by GEOModelsCallbacks::appendSurfaceVec().

connectPolylineSegments

void GEOModels::connectPolylineSegments ( const std::string &  geoName, std::vector< std::size_t > const &  indexlist, double const  proximity, std::string const &  ply_name, bool const  closePly, bool const  triangulatePly  )

slot

Calls all necessary functions to connect polyline-segments and update all views and windows.

Definition at line 175 of file GEOModels.cpp.

{
    GeoLib::PolylineVec* plyVec = _geo_objects.getPolylineVecObj(geoName);
 
    if (plyVec)
    {
        std::vector<GeoLib::Polyline*> const& polylines = *plyVec->getVector();
        std::vector<GeoLib::Polyline*> ply_list;
        std::transform(indexlist.begin(), indexlist.end(),
                       std::back_inserter(ply_list),
                       [polylines](auto const& ply_index)
                       { return polylines[ply_index]; });
 
        // connect polylines
        GeoLib::Polyline* new_line =
            GeoLib::Polyline::constructPolylineFromSegments(ply_list,
                                                            proximity);
 
        if (new_line)
        {
            // insert result in a new vector of polylines (because the
            // GEOObjects::appendPolylines()-method requires a vector)
            std::vector<GeoLib::Polyline*> connected_ply;
 
            connected_ply.push_back(new_line);
            _geo_objects.appendPolylineVec(connected_ply, geoName);
 
            if (closePly)
            {
                new_line->closePolyline();
 
                if (triangulatePly)
                {
                    INFO(
                        "Creating a surface by triangulation of the polyline "
                        "...");
                    if (auto sfc =
                            FileIO::createSurfaceWithEarClipping(*new_line))
                    {
                        std::vector<GeoLib::Surface*> new_sfc;
                        new_sfc.push_back(sfc.release());
                        _geo_objects.appendSurfaceVec(new_sfc, geoName);
                        INFO("\t done");
                    }
                    else
                    {
                        WARN(
                            "\t Creating a surface by triangulation of the "
                            "polyline failed.");
                    }
                    plyVec = _geo_objects.getPolylineVecObj(geoName);
                }
            }
 
            if (!ply_name.empty())
            {
                plyVec->setNameOfElementByID(polylines.size(), ply_name);
            }
        }
        else
        {
            OGSError::box("Error connecting polyines.");
        }
    }
    else
    {
        OGSError::box("Corresponding geometry not found.");
    }
}

References _geo_objects, GeoLib::GEOObjects::appendPolylineVec(), GeoLib::GEOObjects::appendSurfaceVec(), OGSError::box(), GeoLib::Polyline::closePolyline(), GeoLib::Polyline::constructPolylineFromSegments(), FileIO::createSurfaceWithEarClipping(), GeoLib::GEOObjects::getPolylineVecObj(), GeoLib::TemplateVec< T >::getVector(), INFO(), GeoLib::TemplateVec< T >::setNameOfElementByID(), and WARN().

geoDataAdded

void GEOModels::geoDataAdded ( GeoTreeModel *  , std::string  , GeoLib::GEOTYPE    )

signal

Referenced by addPointVec(), addPolylineVec(), addSurfaceVec(), and updateGeometry().

geoDataRemoved

void GEOModels::geoDataRemoved ( GeoTreeModel *  , std::string  , GeoLib::GEOTYPE    )

signal

Referenced by removePointVec(), removePolylineVec(), removeSurfaceVec(), and updateGeometry().

getGeoModel()

GeoTreeModel* GEOModels::getGeoModel ( )

inline

Definition at line 45 of file GEOModels.h.

{ return _geoModel; }

References _geoModel.

getStationModel()

StationTreeModel* GEOModels::getStationModel ( )

inline

Definition at line 46 of file GEOModels.h.

{ return _stationModel; }

References _stationModel.

removeGeometry

void GEOModels::removeGeometry ( std::string const &  geo_name, GeoLib::GEOTYPE const  type  )

virtualslot

Removes all parts (points, lines, surfaces) of the geometry with the given name.

Definition at line 86 of file GEOModels.cpp.

{
    if (type == GeoLib::GEOTYPE::SURFACE)
    {
        _geo_objects.removeSurfaceVec(geo_name);
    }
    if (type == GeoLib::GEOTYPE::POLYLINE)
    {
        _geo_objects.removePolylineVec(geo_name);
    }
    if (type == GeoLib::GEOTYPE::POINT)
    {
        _geo_objects.removePointVec(geo_name);
    }
}

References _geo_objects, GeoLib::POINT, GeoLib::POLYLINE, GeoLib::GEOObjects::removePointVec(), GeoLib::GEOObjects::removePolylineVec(), GeoLib::GEOObjects::removeSurfaceVec(), and GeoLib::SURFACE.

removePointVec

void GEOModels::removePointVec ( std::string const &  name )

slot

Definition at line 110 of file GEOModels.cpp.

{
    assert(!_geo_objects.isPntVecUsed(name));
 
    emit geoDataRemoved(_geoModel, name, GeoLib::GEOTYPE::POINT);
    this->_geoModel->removeGeoList(name, GeoLib::GEOTYPE::POINT);
}

References _geo_objects, _geoModel, geoDataRemoved(), GeoLib::GEOObjects::isPntVecUsed(), MaterialPropertyLib::name, GeoLib::POINT, and GeoTreeModel::removeGeoList().

Referenced by GEOModelsCallbacks::removePointVec().

removePolylineVec

void GEOModels::removePolylineVec ( std::string const &  name )

slot

Definition at line 144 of file GEOModels.cpp.

{
    emit geoDataRemoved(_geoModel, name, GeoLib::GEOTYPE::POLYLINE);
    this->_geoModel->removeGeoList(name, GeoLib::GEOTYPE::POLYLINE);
}

References _geoModel, geoDataRemoved(), MaterialPropertyLib::name, GeoLib::POLYLINE, and GeoTreeModel::removeGeoList().

Referenced by GEOModelsCallbacks::removePolylineVec().

removeStationVec

void GEOModels::removeStationVec ( std::string const &  name )

slot

Definition at line 125 of file GEOModels.cpp.

{
    emit stationVectorRemoved(_stationModel, name);
    _stationModel->removeStationList(name);
}

References _stationModel, MaterialPropertyLib::name, StationTreeModel::removeStationList(), and stationVectorRemoved().

Referenced by GEOModelsCallbacks::removeStationVec().

removeSurfaceVec

void GEOModels::removeSurfaceVec ( std::string const &  name )

slot

Definition at line 162 of file GEOModels.cpp.

{
    emit geoDataRemoved(_geoModel, name, GeoLib::GEOTYPE::SURFACE);
    _geoModel->removeGeoList(name, GeoLib::GEOTYPE::SURFACE);
}

References _geoModel, geoDataRemoved(), MaterialPropertyLib::name, GeoTreeModel::removeGeoList(), and GeoLib::SURFACE.

Referenced by GEOModelsCallbacks::removeSurfaceVec().

renameGeometry

void GEOModels::renameGeometry ( std::string const &  old_name, std::string const &  new_name  )

slot

Definition at line 168 of file GEOModels.cpp.

{
    _geoModel->renameGeometry(old_name, new_name);
    updateGeometry(new_name);
}

References _geoModel, GeoTreeModel::renameGeometry(), and updateGeometry().

Referenced by GEOModelsCallbacks::renameGeometry().

stationVectorAdded

void GEOModels::stationVectorAdded ( StationTreeModel *  model, std::string  name  )

signal

Referenced by addStationVec(), and updateGeometry().

stationVectorRemoved

void GEOModels::stationVectorRemoved ( StationTreeModel *  model, std::string  name  )

signal

Referenced by removeStationVec(), and updateGeometry().

updateGeometry

void GEOModels::updateGeometry ( const std::string &  geo_name )

slot

Updates the tree model if the underlying data in GEOObjects has changed. Technically it removes the geometry from the tree model (but not from GeoObjects) and re-adds the (modified) geometry.

Definition at line 40 of file GEOModels.cpp.

{
    if (auto const stations = _geo_objects.getStationVec(geo_name);
        stations != nullptr)
    {
        emit stationVectorRemoved(_stationModel, geo_name);
        _stationModel->removeStationList(geo_name);
        _stationModel->addStationList(QString::fromStdString(geo_name),
                                      stations);
        emit stationVectorAdded(_stationModel, geo_name);
        return;
    }
 
    if (auto const points = _geo_objects.getPointVecObj(geo_name);
        points != nullptr)
    {
        emit geoDataRemoved(_geoModel, geo_name, GeoLib::GEOTYPE::POINT);
        this->_geoModel->removeGeoList(geo_name, GeoLib::GEOTYPE::POINT);
        _geoModel->addPointList(QString::fromStdString(geo_name), *points);
        emit geoDataAdded(_geoModel, geo_name, GeoLib::GEOTYPE::POINT);
 
        if (auto const lines = _geo_objects.getPolylineVecObj(geo_name);
            lines != nullptr)
        {
            emit geoDataRemoved(_geoModel, geo_name, GeoLib::GEOTYPE::POLYLINE);
            this->_geoModel->removeGeoList(geo_name, GeoLib::GEOTYPE::POLYLINE);
            _geoModel->addPolylineList(QString::fromStdString(geo_name),
                                       *lines);
            emit geoDataAdded(_geoModel, geo_name, GeoLib::GEOTYPE::POLYLINE);
        }
 
        if (auto const surfaces = _geo_objects.getSurfaceVecObj(geo_name);
            surfaces != nullptr)
        {
            emit geoDataRemoved(_geoModel, geo_name, GeoLib::GEOTYPE::SURFACE);
            this->_geoModel->removeGeoList(geo_name, GeoLib::GEOTYPE::SURFACE);
            _geoModel->addSurfaceList(QString::fromStdString(geo_name),
                                      *surfaces);
            emit geoDataAdded(_geoModel, geo_name, GeoLib::GEOTYPE::SURFACE);
        }
    }
    else
        ERR("GEOModels::updateGeometry() - Geometry '{:s}' not found.",
            geo_name);
}

References _geo_objects, _geoModel, _stationModel, GeoTreeModel::addPointList(), GeoTreeModel::addPolylineList(), StationTreeModel::addStationList(), GeoTreeModel::addSurfaceList(), ERR(), geoDataAdded(), geoDataRemoved(), GeoLib::GEOObjects::getPointVecObj(), GeoLib::GEOObjects::getPolylineVecObj(), GeoLib::GEOObjects::getStationVec(), GeoLib::GEOObjects::getSurfaceVecObj(), GeoLib::POINT, GeoLib::POLYLINE, GeoTreeModel::removeGeoList(), StationTreeModel::removeStationList(), stationVectorAdded(), stationVectorRemoved(), and GeoLib::SURFACE.

Referenced by renameGeometry().

Member Data Documentation

_geo_objects

GeoLib::GEOObjects& GEOModels::_geo_objects

private

Definition at line 106 of file GEOModels.h.

Referenced by GEOModels(), addNameForElement(), addNameForObjectPoints(), addPointVec(), addPolylineVec(), addStationVec(), addSurfaceVec(), appendPolylineVec(), appendSurfaceVec(), connectPolylineSegments(), removeGeometry(), removePointVec(), and updateGeometry().

_geoModel

GeoTreeModel* GEOModels::_geoModel

protected

Definition at line 102 of file GEOModels.h.

Referenced by GEOModels(), ~GEOModels(), addPointVec(), addPolylineVec(), addSurfaceVec(), appendPolylineVec(), appendSurfaceVec(), getGeoModel(), removePointVec(), removePolylineVec(), removeSurfaceVec(), renameGeometry(), and updateGeometry().

_stationModel

StationTreeModel* GEOModels::_stationModel

protected

Definition at line 103 of file GEOModels.h.

Referenced by GEOModels(), ~GEOModels(), addStationVec(), getStationModel(), removeStationVec(), and updateGeometry().

---

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

• Applications/DataExplorer/DataView/GEOModels.h
• Applications/DataExplorer/DataView/GEOModels.cpp