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 25 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)
std::vector< std::string >	getGeometryNames () const
const std::vector< GeoLib::Point * > *	getPointVec (const std::string &name) const
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.
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.
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 14 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 _geo_objects, _geoModel, and _stationModel.

~GEOModels()

GEOModels::~GEOModels ( )

override

Definition at line 23 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 247 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::POINT, GeoLib::POLYLINE, 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 272 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::Polyline::getNumberOfPoints(), GeoLib::Surface::getNumberOfTriangles(), GeoLib::POLYLINE, GeoLib::PointVec::setNameForElement(), and GeoLib::SURFACE.

addPointVec

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

slot

Definition at line 102 of file GEOModels.cpp.

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

References _geo_objects, _geoModel, geoDataAdded(), and GeoLib::POINT.

addPolylineVec

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

slot

Definition at line 130 of file GEOModels.cpp.

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

References _geo_objects, _geoModel, geoDataAdded(), and GeoLib::POLYLINE.

addStationVec

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

slot

Definition at line 117 of file GEOModels.cpp.

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

References _geo_objects, _stationModel, and stationVectorAdded().

addSurfaceVec

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

slot

Definition at line 149 of file GEOModels.cpp.

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

References _geo_objects, _geoModel, geoDataAdded(), and GeoLib::SURFACE.

appendPolylineVec

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

slot

Definition at line 137 of file GEOModels.cpp.

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

References _geo_objects, and _geoModel.

appendSurfaceVec

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

slot

Definition at line 156 of file GEOModels.cpp.

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

References _geo_objects, and _geoModel.

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 174 of file GEOModels.cpp.

{
    GeoLib::PolylineVec* plyVec = _geo_objects.getPolylineVecObj(geoName);
 
    if (plyVec)
    {
        auto 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, OGSError::box(), GeoLib::Polyline::closePolyline(), GeoLib::Polyline::constructPolylineFromSegments(), FileIO::createSurfaceWithEarClipping(), 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().

getGeometryNames

std::vector< std::string > GEOModels::getGeometryNames ( ) const

slot

Definition at line 92 of file GEOModels.cpp.

{
    return _geo_objects.getGeometryNames();
}

References _geo_objects.

getGeoModel()

GeoTreeModel * GEOModels::getGeoModel ( )

inline

Definition at line 34 of file GEOModels.h.

{ return _geoModel; }

References _geoModel.

getPointVec

const std::vector< GeoLib::Point * > * GEOModels::getPointVec ( const std::string & name ) const

slot

Definition at line 96 of file GEOModels.cpp.

{
    return _geo_objects.getPointVec(name);
}

References _geo_objects.

getStationModel()

StationTreeModel * GEOModels::getStationModel ( )

inline

Definition at line 35 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 75 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, and GeoLib::SURFACE.

removePointVec

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

slot

Definition at line 109 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(), and GeoLib::POINT.

removePolylineVec

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

slot

Definition at line 143 of file GEOModels.cpp.

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

References _geoModel, geoDataRemoved(), and GeoLib::POLYLINE.

removeStationVec

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

slot

Definition at line 124 of file GEOModels.cpp.

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

References _stationModel, and stationVectorRemoved().

removeSurfaceVec

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

slot

Definition at line 161 of file GEOModels.cpp.

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

References _geoModel, geoDataRemoved(), and GeoLib::SURFACE.

renameGeometry

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

slot

Definition at line 167 of file GEOModels.cpp.

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

References _geoModel, and updateGeometry().

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 29 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, ERR(), geoDataAdded(), geoDataRemoved(), GeoLib::POINT, GeoLib::POLYLINE, stationVectorAdded(), stationVectorRemoved(), and GeoLib::SURFACE.

Referenced by renameGeometry().

Member Data Documentation

_geo_objects

GeoLib::GEOObjects& GEOModels::_geo_objects

private

Definition at line 99 of file GEOModels.h.

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

_geoModel

GeoTreeModel* GEOModels::_geoModel

protected

Definition at line 95 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 96 of file GEOModels.h.

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

---

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

• GEOModels.h
• GEOModels.cpp