Detailed Description

Container class for geometric objects.

This class contains all the methods necessary for the I/O of geometric objects. Said objects are Points, polylines, Surfaces and Stations and they are stored in vectors (arrays) which are identified by a unique name. For a hierarchical definition, surfaces are bounded by polylines and polylines are defined by points. Therefore, a vector of surfaces references a vector polylines and a vector of polylines references a vector of points, respectively. For identification purposes, all of these vectors have the same name, i.e. the polyline- vector named "aaa" references a point vector "aaa". However, this name ("aaa") is unique among all the vectors of the same class, i.e. there exists only one point- vector with this name, etc. Note: The fact that vectors are uniquely named and the same name is assigned to related objects is automatically handled by this class.

For each of these object-classes exists an "add", "remove" and "get"-method which allows for loading/unloading as well as accessing the data, respectively. E.g. for points these methods are "addPointVec(name)", "getPointVec(name)" and "removePointVec(name)". For some objects, additional methods might exist if necessary.

Definition at line 45 of file GEOObjects.h.

#include <GEOObjects.h>

Classes
struct	Callbacks

Public Member Functions
void	addPointVec (std::vector< Point * > &&points, std::string &name, PointVec::NameIdMap &&pnt_id_name_map, double const eps=std::sqrt(std::numeric_limits< double >::epsilon()))
void	addPointVec (std::vector< Point * > &&points, std::string &name, double const eps=std::sqrt(std::numeric_limits< double >::epsilon()))
const std::vector< Point * > *	getPointVec (const std::string &name) const
const PointVec *	getPointVecObj (const std::string &name) const
PointVec *	getPointVecObj (const std::string &name)
	Returns a pointer to a PointVec object for the given name.
bool	removePointVec (const std::string &name)
void	addStationVec (std::vector< Point * > &&stations, std::string &name)
	Adds a vector of stations with the given name and colour to GEOObjects.
const std::vector< GeoLib::Point * > *	getStationVec (const std::string &name) const
	Returns the station vector with the given name.
bool	removeStationVec (const std::string &name)
	Removes the station vector with the given name from GEOObjects.
void	addPolylineVec (std::vector< Polyline * > &&lines, std::string const &name, PolylineVec::NameIdMap &&ply_names)
bool	appendPolylineVec (const std::vector< Polyline * > &polylines, const std::string &name)
const std::vector< Polyline * > *	getPolylineVec (const std::string &name) const
const PolylineVec *	getPolylineVecObj (const std::string &name) const
PolylineVec *	getPolylineVecObj (const std::string &name)
	Returns a pointer to a PolylineVec object for the given name.
bool	removePolylineVec (const std::string &name)
void	addSurfaceVec (std::vector< Surface * > &&sfc, const std::string &name, SurfaceVec::NameIdMap &&sfc_names)
bool	appendSurfaceVec (const std::vector< Surface * > &surfaces, const std::string &name)
const std::vector< Surface * > *	getSurfaceVec (const std::string &name) const
	Returns the surface vector with the given name as a const.
SurfaceVec *	getSurfaceVecObj (const std::string &name)
	Returns the surface vector with the given name.
bool	removeSurfaceVec (const std::string &name)
const SurfaceVec *	getSurfaceVecObj (const std::string &name) const
std::vector< std::string >	getGeometryNames () const
	Returns the names of all geometry vectors.
std::string	getElementNameByID (const std::string &geometry_name, GeoLib::GEOTYPE type, std::size_t id) const
void	getStationVectorNames (std::vector< std::string > &names) const
	Returns the names of all station vectors.
bool	isUniquePointVecName (std::string &name) const
int	mergeGeometries (std::vector< std::string > const &geo_names, std::string &merged_geo_name)
void	renameGeometry (std::string const &old_name, std::string const &new_name)
const GeoLib::GeoObject *	getGeoObject (const std::string &geo_name, GeoLib::GEOTYPE type, const std::string &geo_obj_name) const
GeoLib::GeoObject const *	getGeoObject (const std::string &geo_name, const std::string &geo_obj_name) const
	Return named (by the tuple geo_name and geo_obj_name) geo object.
	GEOObjects ()
	~GEOObjects ()
std::size_t	exists (const std::string &geometry_name) const
bool	isPntVecUsed (const std::string &name) const
std::vector< PointVec * > const &	getPoints () const
	Read access to points w/o using a name.
std::vector< PolylineVec * > const &	getPolylines () const
	Read access to polylines w/o using a name.
std::vector< SurfaceVec * > const &	getSurfaces () const
	Read access to surfaces w/o using a name.

Public Attributes
std::unique_ptr< Callbacks >	_callbacks {new Callbacks}
std::function< void(std::string const &)>	addPolylineVecCallback
std::function< void(std::string const &)>	appendPolylineVecCallback
std::function< void(std::string const &)>	removePolylineVecCallback
std::function< void(std::string const &)>	addSurfaceVecCallback
std::function< void(std::string const &)>	appendSurfaceVecCallback
std::function< void(std::string const &)>	removeSurfaceVecCallback

Private Member Functions
void	mergePoints (std::vector< std::string > const &geo_names, std::string &merged_geo_name, std::vector< std::size_t > &pnt_offsets)
void	mergePolylines (std::vector< std::string > const &geo_names, std::string const &merged_geo_name, std::vector< std::size_t > const &pnt_offsets)
void	mergeSurfaces (std::vector< std::string > const &geo_names, std::string const &merged_geo_name, std::vector< std::size_t > const &pnt_offsets)

Private Attributes
std::vector< PointVec * >	_pnt_vecs
std::vector< PolylineVec * >	_ply_vecs
std::vector< SurfaceVec * >	_sfc_vecs

Constructor & Destructor Documentation

◆ GEOObjects()

GeoLib::GEOObjects::GEOObjects ( )

default

constructor

Referenced by getPointVecObj(), getPolylineVecObj(), and getSurfaceVecObj().

◆ ~GEOObjects()

GeoLib::GEOObjects::~GEOObjects ( )

destructor

Definition at line 30 of file GEOObjects.cpp.

{
    // delete all SurfaceVecs, PolylineVec, and PointVecs
    BaseLib::cleanupVectorElements(_sfc_vecs, _ply_vecs, _pnt_vecs);
}

References _ply_vecs, _pnt_vecs, _sfc_vecs, and BaseLib::cleanupVectorElements().

Member Function Documentation

◆ addPointVec() [1/2]

void GeoLib::GEOObjects::addPointVec	(	std::vector< Point * > &&	points,
		std::string &	name,
		double const	eps = std::sqrt(std::numeric_limits<double>::epsilon()) )

Adds a vector of points with the given name to GEOObjects. This is an overloaded version without the need to pass a name-to-id-map.

Parameters

points	vector of pointers to points
name	the project name
eps	relative tolerance value for testing of point uniqueness

Definition at line 55 of file GEOObjects.cpp.

{
    addPointVec(std::move(points), name, {}, eps);
}

References addPointVec().

◆ addPointVec() [2/2]

void GeoLib::GEOObjects::addPointVec	(	std::vector< Point * > &&	points,
		std::string &	name,
		PointVec::NameIdMap &&	pnt_id_name_map,
		double const	eps = std::sqrt(std::numeric_limits<double>::epsilon()) )

Adds a vector of points with the given name to GEOObjects.

Parameters

points	vector of pointers to points
name	the project name
pnt_id_name_map	names corresponding to the points
eps	relative tolerance value for testing of point uniqueness

Definition at line 36 of file GEOObjects.cpp.

{
    isUniquePointVecName(name);
    if (points.empty())
    {
        DBUG(
            "GEOObjects::addPointVec(): Failed to create PointVec, because "
            "there aren't any points in the given vector.");
        return;
    }
    _pnt_vecs.push_back(new PointVec(name, std::move(points),
                                     std::move(pnt_id_name_map),
                                     PointVec::PointType::POINT, eps));
    _callbacks->addPointVec(name);
}

References _callbacks, _pnt_vecs, DBUG(), isUniquePointVecName(), and GeoLib::PointVec::POINT.

Referenced by FileIO::PetrelInterface::PetrelInterface(), addPointVec(), convertMeshNodesToGeometry(), anonymous_namespace{convertMeshToGeo.cpp}::convertMeshNodesToGeoPoints(), convertPoints(), FileIO::SwmmInterface::convertSwmmInputToGeometry(), createGeometries(), GeoLib::Grid< POINT >::createGridGeometry(), FileIO::createSurface(), generatePolylineGeometry(), generateQuadGeometry(), generateSinglePointGeometry(), FileIO::GMSH::GMSHAdaptiveMeshDensity::getQuadTreeGeometry(), main(), mergeGeometries(), mergePoints(), FileIO::FEFLOWGeoInterface::readFEFLOWFile(), FileIO::Legacy::readGLIFileV4(), and FileIO::TetGenInterface::readTetGenGeometry().

◆ addPolylineVec()

void GeoLib::GEOObjects::addPolylineVec	(	std::vector< Polyline * > &&	lines,
		std::string const &	name,
		PolylineVec::NameIdMap &&	ply_names )

Adds a vector of polylines with the given name to GEOObjects.

Parameters

lines	The lines vector.
name	The geometry to which the given Polyline objects should be added.
ply_names	map of names and ids that are corresponding to the polylines

Definition at line 141 of file GEOObjects.cpp.

{
    auto lines_end = std::remove_if(
        lines.begin(), lines.end(),
        [](auto const* polyline) { return polyline->getNumberOfPoints() < 2; });
    lines.erase(lines_end, lines.end());
 
    if (lines.empty())
    {
        return;
    }
 
    _ply_vecs.push_back(
        new PolylineVec(name, std::move(lines), std::move(ply_names)));
    _callbacks->addPolylineVec(name);
}

References _callbacks, and _ply_vecs.

Referenced by FileIO::SwmmInterface::convertSwmmInputToGeometry(), createGeometries(), GeoLib::Grid< POINT >::createGridGeometry(), FileIO::createSurface(), generatePolylineGeometry(), generateQuadGeometry(), FileIO::GMSH::GMSHAdaptiveMeshDensity::getQuadTreeGeometry(), mergeGeometries(), mergePolylines(), FileIO::FEFLOWGeoInterface::readFEFLOWFile(), and FileIO::Legacy::readGLIFileV4().

◆ addStationVec()

void GeoLib::GEOObjects::addStationVec	(	std::vector< Point * > &&	stations,
		std::string &	name )

Adds a vector of stations with the given name and colour to GEOObjects.

Definition at line 112 of file GEOObjects.cpp.

{
    isUniquePointVecName(name);
    _pnt_vecs.push_back(new PointVec(name, std::move(stations),
                                     PointVec::NameIdMap{},
                                     PointVec::PointType::STATION));
    _callbacks->addStationVec(name);
}

References _callbacks, _pnt_vecs, isUniquePointVecName(), and GeoLib::PointVec::STATION.

Referenced by convertPoints(), and GeoLib::geoPointsToStations().

◆ addSurfaceVec()

void GeoLib::GEOObjects::addSurfaceVec	(	std::vector< Surface * > &&	sfc,
		const std::string &	name,
		SurfaceVec::NameIdMap &&	sfc_names )

Adds a vector of surfaces with the given name to GEOObjects.

Definition at line 229 of file GEOObjects.cpp.

{
    _sfc_vecs.push_back(
        new SurfaceVec(name, std::move(sfc), std::move(sfc_names)));
    _callbacks->addSurfaceVec(name);
}

References _callbacks, and _sfc_vecs.

Referenced by appendSurfaceVec(), mergeSurfaces(), FileIO::Legacy::readGLIFileV4(), and FileIO::TetGenInterface::readTetGenGeometry().

◆ appendPolylineVec()

bool GeoLib::GEOObjects::appendPolylineVec	(	const std::vector< Polyline * > &	polylines,
		const std::string &	name )

copies the pointers to the polylines in the vector to the PolylineVec with provided name. the pointers are managed by the GEOObjects, i.e. GEOObjects will delete the Polylines at the end of its scope

Parameters

polylines	the vector with polylines
name	the name of the internal PolylineVec

Returns: true if the polylines are appended, false if the PolylineVec with the corresponding name does not exist

Definition at line 160 of file GEOObjects.cpp.

{
    // find an already existing PolylineVec object the given polylines will be
    // appended to
    auto polyline_vec_it = findVectorByName(_ply_vecs, name);
    if (polyline_vec_it == _ply_vecs.end())
    {
        return false;
    }
    for (auto* polyline : polylines)
    {
        (*polyline_vec_it)->push_back(polyline);
    }
    _callbacks->appendPolylineVec(name);
    return true;
}

References _callbacks, _ply_vecs, and GeoLib::findVectorByName().

◆ appendSurfaceVec()

bool GeoLib::GEOObjects::appendSurfaceVec	(	const std::vector< Surface * > &	surfaces,
		const std::string &	name )

Copies the surfaces in the vector to the SurfaceVec with the given name.

Parameters

surfaces	the vector with surfaces
name	the name of the internal PolylineVec

Returns: true if the surfaces are appended, false if the SurfaceVec with the corresponding name does not exist and the surfaces are added.

Definition at line 238 of file GEOObjects.cpp.

{
    auto surface_vec_to_append_it = findVectorByName(_sfc_vecs, name);
    if (surface_vec_to_append_it != _sfc_vecs.end())
    {
        for (auto& surface : surfaces)
        {
            (*surface_vec_to_append_it)->push_back(surface);
        }
        _callbacks->appendSurfaceVec(name);
        return true;
    }
 
    // the copy is needed because addSurfaceVec is passing it to SurfaceVec
    // ctor, which needs write access to the surface vector.
    std::vector<GeoLib::Surface*> sfc(begin(surfaces), end(surfaces));
    addSurfaceVec(std::move(sfc), name, SurfaceVec::NameIdMap{});
    return false;
}

References _callbacks, _sfc_vecs, addSurfaceVec(), and GeoLib::findVectorByName().

◆ exists()

std::size_t GeoLib::GEOObjects::exists ( const std::string & geometry_name ) const

Returns std::numeric_limits<std::size_t>::max() if no geometry of the given name exists or the index of the geometry in _pnt_vecs otherwise

Definition at line 733 of file GEOObjects.cpp.

{
    if (auto const it = findVectorByName(_pnt_vecs, geometry_name);
        it != _pnt_vecs.end())
    {
        return std::distance(_pnt_vecs.begin(), it);
    }
 
    // HACK for enabling conversion of files without loading the associated
    // geometry
    if (_pnt_vecs.size() > 0 &&
        _pnt_vecs[0]->getName() == "conversionTestRun#1")
    {
        return 1;
    }
 
    return std::numeric_limits<std::size_t>::max();
}

References _pnt_vecs, and GeoLib::findVectorByName().

Referenced by getPointVec(), and getPointVecObj().

◆ getElementNameByID()

std::string GeoLib::GEOObjects::getElementNameByID	(	const std::string &	geometry_name,
		GeoLib::GEOTYPE	type,
		std::size_t	id ) const

Definition at line 344 of file GEOObjects.cpp.

{
    std::string name;
    switch (type)
    {
        case GeoLib::GEOTYPE::POINT:
            this->getPointVecObj(geometry_name)->getNameOfElementByID(id, name);
            break;
        case GeoLib::GEOTYPE::POLYLINE:
            this->getPolylineVecObj(geometry_name)
                ->getNameOfElementByID(id, name);
            break;
        case GeoLib::GEOTYPE::SURFACE:
            this->getSurfaceVecObj(geometry_name)
                ->getNameOfElementByID(id, name);
    }
    return name;
}

References GeoLib::TemplateVec< T >::getNameOfElementByID(), getPointVecObj(), getPolylineVecObj(), getSurfaceVecObj(), GeoLib::POINT, GeoLib::POLYLINE, and GeoLib::SURFACE.

◆ getGeometryNames()

std::vector< std::string > GeoLib::GEOObjects::getGeometryNames ( ) const

Returns the names of all geometry vectors.

Definition at line 331 of file GEOObjects.cpp.

{
    std::vector<std::string> names;
    for (auto const* point : _pnt_vecs)
    {
        if (point->getType() == PointVec::PointType::POINT)
        {
            names.push_back(point->getName());
        }
    }
    return names;
}

References _pnt_vecs, and GeoLib::PointVec::POINT.

Referenced by GMSHPrefsDialog::GMSHPrefsDialog(), OGSFileConverter::convertGML2GLI(), FileIO::createSurface(), isUniquePointVecName(), main(), FileIO::readGeometryFromFile(), FileIO::XmlPrjInterface::write(), and FileIO::Legacy::writeAllDataToGLIFileV4().

◆ getGeoObject() [1/2]

GeoLib::GeoObject const * GeoLib::GEOObjects::getGeoObject	(	const std::string &	geo_name,
		const std::string &	geo_obj_name ) const

Return named (by the tuple geo_name and geo_obj_name) geo object.

Definition at line 705 of file GEOObjects.cpp.

{
    GeoLib::GeoObject const* geo_obj(
        getGeoObject(geo_name, GeoLib::GEOTYPE::POINT, geo_obj_name));
 
    if (!geo_obj)
    {
        geo_obj =
            getGeoObject(geo_name, GeoLib::GEOTYPE::POLYLINE, geo_obj_name);
    }
 
    if (!geo_obj)
    {
        geo_obj =
            getGeoObject(geo_name, GeoLib::GEOTYPE::SURFACE, geo_obj_name);
    }
 
    if (!geo_obj)
    {
        DBUG(
            "GEOObjects::getGeoObject(): Could not find '{:s}' in geometry "
            "{:s}.",
            geo_obj_name, geo_name);
    }
    return geo_obj;
}

References DBUG(), getGeoObject(), GeoLib::POINT, GeoLib::POLYLINE, and GeoLib::SURFACE.

◆ getGeoObject() [2/2]

const GeoLib::GeoObject * GeoLib::GEOObjects::getGeoObject	(	const std::string &	geo_name,
		GeoLib::GEOTYPE	type,
		const std::string &	geo_obj_name ) const

Returns the geo object for a geometric item of the given name and type for the associated geometry.

Definition at line 648 of file GEOObjects.cpp.

{
    GeoLib::GeoObject* geo_obj(nullptr);
    switch (type)
    {
        case GeoLib::GEOTYPE::POINT:
        {
            GeoLib::PointVec const* pnt_vec(getPointVecObj(geo_name));
            if (pnt_vec)
            {
                geo_obj = const_cast<GeoLib::GeoObject*>(
                    dynamic_cast<GeoLib::GeoObject const*>(
                        pnt_vec->getElementByName(geo_obj_name)));
            }
            break;
        }
        case GeoLib::GEOTYPE::POLYLINE:
        {
            GeoLib::PolylineVec const* ply_vec(getPolylineVecObj(geo_name));
            if (ply_vec)
            {
                geo_obj = const_cast<GeoLib::GeoObject*>(
                    dynamic_cast<GeoLib::GeoObject const*>(
                        ply_vec->getElementByName(geo_obj_name)));
            }
            break;
        }
        case GeoLib::GEOTYPE::SURFACE:
        {
            GeoLib::SurfaceVec const* sfc_vec(getSurfaceVecObj(geo_name));
            if (sfc_vec)
            {
                geo_obj = const_cast<GeoLib::GeoObject*>(
                    dynamic_cast<GeoLib::GeoObject const*>(
                        sfc_vec->getElementByName(geo_obj_name)));
            }
            break;
        }
        default:
            ERR("GEOObjects::getGeoObject(): geometric type not handled.");
            return nullptr;
    };
 
    if (!geo_obj)
    {
        DBUG(
            "GEOObjects::getGeoObject(): Could not find {:s} '{:s}' in "
            "geometry.",
            GeoLib::convertGeoTypeToString(type),
            geo_obj_name);
    }
    return geo_obj;
}

References GeoLib::convertGeoTypeToString(), DBUG(), ERR(), GeoLib::TemplateVec< T >::getElementByName(), getPointVecObj(), getPolylineVecObj(), getSurfaceVecObj(), GeoLib::POINT, GeoLib::POLYLINE, and GeoLib::SURFACE.

Referenced by getGeoObject().

◆ getPoints()

std::vector< PointVec * > const & GeoLib::GEOObjects::getPoints ( ) const

inline

Read access to points w/o using a name.

Definition at line 286 of file GEOObjects.h.

286{ return _pnt_vecs; }

References _pnt_vecs.

Referenced by MeshGeoToolsLib::constructAdditionalMeshesFromGeoObjects(), and anonymous_namespace{ProjectData.cpp}::readMeshes().

◆ getPointVec()

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

Returns the point vector with the given name.

Definition at line 61 of file GEOObjects.cpp.

{
    std::size_t const idx = this->exists(name);
    if (idx != std::numeric_limits<std::size_t>::max())
    {
        return &_pnt_vecs[idx]->getVector();
    }
 
    DBUG("GEOObjects::getPointVec() - No entry found with name '{:s}'.", name);
    return nullptr;
}

References _pnt_vecs, DBUG(), and exists().

Referenced by MeshToolsLib::convertMeshToGeo(), createGeometries(), GeoLib::Grid< POINT >::createGridGeometry(), FileIO::createSurface(), main(), mergeGeometries(), FileIO::TetGenInterface::readTetGenGeometry(), and FileIO::TetGenInterface::writeTetGenSmesh().

◆ getPointVecObj() [1/2]

PointVec * GeoLib::GEOObjects::getPointVecObj ( const std::string & name )

inline

Returns a pointer to a PointVec object for the given name.

Definition at line 104 of file GEOObjects.h.

    {
        return const_cast<PointVec*>(
            static_cast<const GEOObjects&>(*this).getPointVecObj(name));
    }

References GEOObjects().

◆ getPointVecObj() [2/2]

const PointVec * GeoLib::GEOObjects::getPointVecObj ( const std::string & name ) const

search and returns the PointVec object with the given name.

Parameters

name	the name of the PointVec object

Returns: the PointVec object stored in GEOObjects

Definition at line 74 of file GEOObjects.cpp.

{
    std::size_t const idx = this->exists(name);
    if (idx != std::numeric_limits<std::size_t>::max())
    {
        return _pnt_vecs[idx];
    }
 
    DBUG("GEOObjects::getPointVecObj() - No entry found with name '{:s}'.",
         name);
    return nullptr;
}

References _pnt_vecs, DBUG(), and exists().

Referenced by MeshToolsLib::convertMeshToGeo(), FileIO::SwmmInterface::convertSwmmInputToGeometry(), generatePolylineGeometry(), generateQuadGeometry(), GeoLib::geoPointsToStations(), getElementNameByID(), getGeoObject(), FileIO::GMSH::GMSHAdaptiveMeshDensity::getQuadTreeGeometry(), main(), mergePoints(), mergePolylines(), mergeSurfaces(), FileIO::Legacy::readGLIFileV4(), FileIO::TetGenInterface::readTetGenGeometry(), FileIO::Legacy::writeAllDataToGLIFileV4(), writeBCsAndGeometry(), and FileIO::Legacy::writeGLIFileV4().

◆ getPolylines()

std::vector< PolylineVec * > const & GeoLib::GEOObjects::getPolylines ( ) const

inline

Read access to polylines w/o using a name.

Definition at line 288 of file GEOObjects.h.

288{ return _ply_vecs; }

References _ply_vecs.

Referenced by MeshGeoToolsLib::constructAdditionalMeshesFromGeoObjects(), and anonymous_namespace{ProjectData.cpp}::readMeshes().

◆ getPolylineVec()

const std::vector< Polyline * > * GeoLib::GEOObjects::getPolylineVec ( const std::string & name ) const

Returns the polyline vector with the given name.

Definition at line 178 of file GEOObjects.cpp.

{
    std::size_t size(_ply_vecs.size());
    for (std::size_t i = 0; i < size; i++)
    {
        if (_ply_vecs[i]->getName() == name)
        {
            return &_ply_vecs[i]->getVector();
        }
    }
 
    DBUG("GEOObjects::getPolylineVec() - No entry found with name '{:s}'.",
         name);
    return nullptr;
}

References _ply_vecs, DBUG(), and getName().

Referenced by main(), mergePolylines(), and FileIO::Legacy::readGLIFileV4().

◆ getPolylineVecObj() [1/2]

PolylineVec * GeoLib::GEOObjects::getPolylineVecObj ( const std::string & name )

inline

Returns a pointer to a PolylineVec object for the given name.

Definition at line 165 of file GEOObjects.h.

    {
        return const_cast<PolylineVec*>(
            static_cast<const GEOObjects&>(*this).getPolylineVecObj(name));
    }

References GEOObjects().

◆ getPolylineVecObj() [2/2]

const PolylineVec * GeoLib::GEOObjects::getPolylineVecObj ( const std::string & name ) const

Returns a pointer to a PolylineVec object for the given name as a const.

Parameters

name	the name of the vector of polylines

Returns: PolylineVec object

Definition at line 195 of file GEOObjects.cpp.

{
    std::size_t size(_ply_vecs.size());
    for (std::size_t i = 0; i < size; i++)
    {
        if (_ply_vecs[i]->getName() == name)
        {
            return _ply_vecs[i];
        }
    }
 
    DBUG("GEOObjects::getPolylineVecObj() - No entry found with name '{:s}'.",
         name);
    return nullptr;
}

References _ply_vecs, DBUG(), and getName().

Referenced by getElementNameByID(), getGeoObject(), main(), GeoLib::markUnusedPoints(), mergePolylines(), FileIO::Legacy::readGLIFileV4(), FileIO::Legacy::writeAllDataToGLIFileV4(), and FileIO::Legacy::writeGLIFileV4().

◆ getStationVec()

const std::vector< GeoLib::Point * > * GeoLib::GEOObjects::getStationVec ( const std::string & name ) const

Returns the station vector with the given name.

Definition at line 122 of file GEOObjects.cpp.

{
    auto const it =
        std::find_if(begin(_pnt_vecs), end(_pnt_vecs),
                     [&name](PointVec const* const p)
                     {
                         return p->getName() == name &&
                                p->getType() == PointVec::PointType::STATION;
                     });
    if (it != end(_pnt_vecs))
    {
        return &(*it)->getVector();
    }
    DBUG("GEOObjects::getStationVec() - No entry found with name '{:s}'.",
         name);
    return nullptr;
}

References _pnt_vecs, DBUG(), GeoLib::TemplateVec< T >::getName(), GeoLib::PointVec::getType(), and GeoLib::PointVec::STATION.

Referenced by FileIO::Legacy::writeAllDataToGLIFileV4().

◆ getStationVectorNames()

void GeoLib::GEOObjects::getStationVectorNames ( std::vector< std::string > & names ) const

Returns the names of all station vectors.

Definition at line 320 of file GEOObjects.cpp.

{
    for (auto const* point : _pnt_vecs)
    {
        if (point->getType() == PointVec::PointType::STATION)
        {
            names.push_back(point->getName());
        }
    }
}

References _pnt_vecs, and GeoLib::PointVec::STATION.

Referenced by GMSHPrefsDialog::GMSHPrefsDialog(), FileIO::XmlPrjInterface::write(), and FileIO::Legacy::writeAllDataToGLIFileV4().

◆ getSurfaces()

std::vector< SurfaceVec * > const & GeoLib::GEOObjects::getSurfaces ( ) const

inline

Read access to surfaces w/o using a name.

Definition at line 290 of file GEOObjects.h.

290{ return _sfc_vecs; }

References _sfc_vecs.

Referenced by MeshGeoToolsLib::constructAdditionalMeshesFromGeoObjects(), and anonymous_namespace{ProjectData.cpp}::readMeshes().

◆ getSurfaceVec()

const std::vector< Surface * > * GeoLib::GEOObjects::getSurfaceVec ( const std::string & name ) const

Returns the surface vector with the given name as a const.

Definition at line 259 of file GEOObjects.cpp.

{
    auto surface_vec_it = findVectorByName(_sfc_vecs, name);
    if (surface_vec_it != _sfc_vecs.end())
    {
        return &(*surface_vec_it)->getVector();
    }
    DBUG("GEOObjects::getSurfaceVec() - No entry found with name '{:s}'.",
         name);
    return nullptr;
}

References _sfc_vecs, DBUG(), and GeoLib::findVectorByName().

Referenced by main(), mergeSurfaces(), and FileIO::TetGenInterface::writeTetGenSmesh().

◆ getSurfaceVecObj() [1/2]

SurfaceVec * GeoLib::GEOObjects::getSurfaceVecObj ( const std::string & name )

inline

Returns the surface vector with the given name.

Definition at line 197 of file GEOObjects.h.

    {
        return const_cast<SurfaceVec*>(
            static_cast<const GEOObjects&>(*this).getSurfaceVecObj(name));
    }

References GEOObjects().

Referenced by getElementNameByID(), getGeoObject(), GeoLib::markUnusedPoints(), mergeSurfaces(), FileIO::Legacy::writeAllDataToGLIFileV4(), and FileIO::Legacy::writeGLIFileV4().

◆ getSurfaceVecObj() [2/2]

const SurfaceVec * GeoLib::GEOObjects::getSurfaceVecObj ( const std::string & name ) const

Returns a pointer to a SurfaceVec object for the given name. The class SurfaceVec stores the relation between surfaces and the names of the surfaces.

Parameters

name	the name of the vector of surfaces (the project name)

Returns: SurfaceVec object

Definition at line 288 of file GEOObjects.cpp.

{
    auto surface_vec_it = findVectorByName(_sfc_vecs, name);
    if (surface_vec_it != _sfc_vecs.end())
    {
        return *surface_vec_it;
    }
    DBUG("GEOObjects::getSurfaceVecObj() - No entry found with name '{:s}'.",
         name);
    return nullptr;
}

References _sfc_vecs, DBUG(), and GeoLib::findVectorByName().

◆ isPntVecUsed()

bool GeoLib::GEOObjects::isPntVecUsed ( const std::string & name ) const

Checks if the point vector with the given name is referenced in a polyline- or surface vector.

Definition at line 313 of file GEOObjects.cpp.

{
    // search for dependent PolylineVecs or SurfaceVecs
    return findVectorByName(_ply_vecs, name) != _ply_vecs.end() ||
           findVectorByName(_sfc_vecs, name) != _sfc_vecs.end();
}

References _ply_vecs, _sfc_vecs, and GeoLib::findVectorByName().

Referenced by removePointVec().

◆ isUniquePointVecName()

bool GeoLib::GEOObjects::isUniquePointVecName ( std::string & name ) const

Determines if the given name is unique among all the names in point vectors and creates a new name if this is not the case. The new name is then simply "name + x", where x>1 is the smallest number that creates a unique name (i.e. "name-2", "name-3", etc.)

Parameters

name	Original name of the list, this name might be changed within this method if necessary.

Returns: true if the name was unique, false if a new name has been generated

Definition at line 300 of file GEOObjects.cpp.

{
    std::vector<std::string> const existing_names = getGeometryNames();
    auto const& unique_name = BaseLib::getUniqueName(existing_names, name);
 
    if (unique_name != name)
    {
        name = unique_name;
        return false;
    }
    return true;
}

References getGeometryNames(), and BaseLib::getUniqueName().

Referenced by addPointVec(), and addStationVec().

◆ mergeGeometries()

int GeoLib::GEOObjects::mergeGeometries	(	std::vector< std::string > const &	geo_names,
		std::string &	merged_geo_name )

Method mergeGeometries merges the geometries that are given by the names in the vector. Stations points are not included in the resulting merged geometry.

Parameters

geo_names	the names of the geometries that are to be merged
merged_geo_name	the name of the resulting geometry

Returns: 0 if success, 1 if no point-list is found for at least one of the geometries and 2 if the mergelist only contains less than two geometry

Definition at line 365 of file GEOObjects.cpp.

{
    const std::size_t n_geo_names(geo_names.size());
 
    if (n_geo_names < 2)
    {
        return 2;
    }
 
    std::vector<std::size_t> pnt_offsets(n_geo_names, 0);
 
    mergePoints(geo_names, merged_geo_name, pnt_offsets);
 
    mergePolylines(geo_names, merged_geo_name, pnt_offsets);
 
    mergeSurfaces(geo_names, merged_geo_name, pnt_offsets);
 
    return 0;
}

References mergePoints(), mergePolylines(), and mergeSurfaces().

Referenced by GeoLib::Grid< POINT >::createGridGeometry(), FileIO::createSurface(), and main().

◆ mergePoints()

void GeoLib::GEOObjects::mergePoints	(	std::vector< std::string > const &	geo_names,
		std::string &	merged_geo_name,
		std::vector< std::size_t > &	pnt_offsets )

private

Method merges points from different geometries into one geometry. This is a helper method for GEOObjects::mergeGeometries().

Parameters

geo_names	The vector of names of the geometries to merge.
merged_geo_name	The (new) name of the geometry resulting from merging.
pnt_offsets	offsets in the merged vector storing the points

Definition at line 386 of file GEOObjects.cpp.

{
    const std::size_t n_geo_names(geo_names.size());
 
    std::vector<GeoLib::Point*> merged_points;
    PointVec::NameIdMap merged_pnt_names;
 
    for (std::size_t j(0); j < n_geo_names; ++j)
    {
        GeoLib::PointVec const* const pnt_vec(
            this->getPointVecObj(geo_names[j]));
        if (pnt_vec == nullptr)
        {
            continue;
        }
        auto const& pnts(pnt_vec->getVector());
 
        // do not consider stations
        if (dynamic_cast<GeoLib::Station*>(pnts[0]))
        {
            continue;
        }
 
        std::size_t const n_pnts(pnts.size());
        for (std::size_t k(0); k < n_pnts; ++k)
        {
            merged_points.push_back(
                new GeoLib::Point(*pnts[k], pnt_offsets[j] + k));
            std::string const& item_name(pnt_vec->getItemNameByID(k));
            if (!item_name.empty())
            {
                merged_pnt_names.insert(
                    std::make_pair(item_name, pnt_offsets[j] + k));
            }
        }
        if (n_geo_names - 1 > j)
        {
            pnt_offsets[j + 1] = n_pnts + pnt_offsets[j];
        }
    }
 
    addPointVec(std::move(merged_points), merged_geo_name,
                std::move(merged_pnt_names), 1e-6);
}

References addPointVec(), GeoLib::PointVec::getItemNameByID(), getPointVecObj(), and GeoLib::TemplateVec< T >::getVector().

Referenced by mergeGeometries().

◆ mergePolylines()

void GeoLib::GEOObjects::mergePolylines	(	std::vector< std::string > const &	geo_names,
		std::string const &	merged_geo_name,
		std::vector< std::size_t > const &	pnt_offsets )

private

Method merges GeoLib::Polylines from different geometries into one geometry. There isn't a check if the polyline is unique within the given data sets. If there are two polylines with the same name, the second occurrence will lost their name. This is a helper for GEOObjects::mergeGeometries() and should be used only after GEOObjects::mergePoints() is executed.

Parameters

geo_names	The vector of names of the geometries to merge.
merged_geo_name	The (new) name of the geometry resulting from merging.
pnt_offsets	offsets in the merged vector storing the points.

Definition at line 433 of file GEOObjects.cpp.

{
    const std::size_t n_geo_names(geo_names.size());
    std::vector<std::size_t> ply_offsets(n_geo_names, 0);
 
    std::vector<GeoLib::Polyline*> merged_polylines;
    PolylineVec::NameIdMap merged_ply_names;
 
    auto const& merged_points(getPointVecObj(merged_geo_name)->getVector());
    std::vector<std::size_t> const& id_map(
        this->getPointVecObj(merged_geo_name)->getIDMap());
 
    for (std::size_t j(0); j < n_geo_names; j++)
    {
        const std::vector<GeoLib::Polyline*>* plys(
            this->getPolylineVec(geo_names[j]));
        if (plys)
        {
            std::string tmp_name;
            for (std::size_t k(0); k < plys->size(); k++)
            {
                auto* kth_ply_new(new GeoLib::Polyline(merged_points));
                GeoLib::Polyline const* const kth_ply_old((*plys)[k]);
                const std::size_t size_of_kth_ply(
                    kth_ply_old->getNumberOfPoints());
                // copy point ids from old ply to new ply (considering the
                // offset)
                for (std::size_t i(0); i < size_of_kth_ply; i++)
                {
                    kth_ply_new->addPoint(
                        id_map[pnt_offsets[j] + kth_ply_old->getPointID(i)]);
                }
                merged_polylines.push_back(kth_ply_new);
                if (this->getPolylineVecObj(geo_names[j])
                        ->getNameOfElementByID(k, tmp_name))
                {
                    merged_ply_names.emplace(tmp_name, ply_offsets[j] + k);
                }
            }
            if (n_geo_names - 1 > j)
            {
                ply_offsets[j + 1] = plys->size() + ply_offsets[j];
            }
        }
    }
 
    if (!merged_polylines.empty())
    {
        this->addPolylineVec(std::move(merged_polylines), merged_geo_name,
                             std::move(merged_ply_names));
    }
}

References addPolylineVec(), GeoLib::Polyline::getNumberOfPoints(), GeoLib::Polyline::getPointID(), getPointVecObj(), getPolylineVec(), and getPolylineVecObj().

Referenced by mergeGeometries().

◆ mergeSurfaces()

void GeoLib::GEOObjects::mergeSurfaces	(	std::vector< std::string > const &	geo_names,
		std::string const &	merged_geo_name,
		std::vector< std::size_t > const &	pnt_offsets )

private

Method merges GeoLib::Surfaces from different geometries into one geometry. There isn't a check if the GeoLib::Surface is unique within the given data sets. This is a helper for GEOObjects::mergeGeometries() and should be used only after GEOObjects::mergePoints() is executed.

Parameters

geo_names	The vector of names of the geometries to merge.
merged_geo_name	The (new) name of the geometry resulting from merging.
pnt_offsets	offsets in the merged vector storing the points.

Definition at line 488 of file GEOObjects.cpp.

{
    auto const& merged_points(getPointVecObj(merged_geo_name)->getVector());
    std::vector<std::size_t> const& id_map(
        this->getPointVecObj(merged_geo_name)->getIDMap());
 
    const std::size_t n_geo_names(geo_names.size());
    std::vector<std::size_t> sfc_offsets(n_geo_names, 0);
    std::vector<GeoLib::Surface*> merged_sfcs;
    SurfaceVec::NameIdMap merged_sfc_names;
    for (std::size_t j(0); j < n_geo_names; j++)
    {
        const std::vector<GeoLib::Surface*>* sfcs(
            this->getSurfaceVec(geo_names[j]));
        if (sfcs)
        {
            std::string tmp_name;
            for (std::size_t k(0); k < sfcs->size(); k++)
            {
                auto* kth_sfc_new(new GeoLib::Surface(merged_points));
                GeoLib::Surface const* const kth_sfc_old((*sfcs)[k]);
                const std::size_t size_of_kth_sfc(
                    kth_sfc_old->getNumberOfTriangles());
                // clone surface elements using new ids
                for (std::size_t i(0); i < size_of_kth_sfc; i++)
                {
                    const GeoLib::Triangle* tri((*kth_sfc_old)[i]);
                    const std::size_t id0(id_map[pnt_offsets[j] + (*tri)[0]]);
                    const std::size_t id1(id_map[pnt_offsets[j] + (*tri)[1]]);
                    const std::size_t id2(id_map[pnt_offsets[j] + (*tri)[2]]);
                    kth_sfc_new->addTriangle(id0, id1, id2);
                }
                merged_sfcs.push_back(kth_sfc_new);
 
                if (this->getSurfaceVecObj(geo_names[j])
                        ->getNameOfElementByID(k, tmp_name))
                {
                    merged_sfc_names.emplace(tmp_name, sfc_offsets[j] + k);
                }
            }
            if (n_geo_names - 1 > j)
            {
                sfc_offsets[j + 1] = sfcs->size() + sfc_offsets[j];
            }
        }
    }
    if (!merged_sfcs.empty())
    {
        this->addSurfaceVec(std::move(merged_sfcs), merged_geo_name,
                            std::move(merged_sfc_names));
    }
}

References addSurfaceVec(), GeoLib::Surface::getNumberOfTriangles(), getPointVecObj(), getSurfaceVec(), and getSurfaceVecObj().

Referenced by mergeGeometries().

◆ removePointVec()

bool GeoLib::GEOObjects::removePointVec ( const std::string & name )

If there exists no dependencies the point vector with the given name from GEOObjects will be removed and the method returns true, else the return value is false.

Definition at line 87 of file GEOObjects.cpp.

{
    if (isPntVecUsed(name))
    {
        DBUG(
            "GEOObjects::removePointVec() - There are still Polylines or "
            "Surfaces depending on these points.");
        return false;
    }
 
    for (auto it(_pnt_vecs.begin()); it != _pnt_vecs.end(); ++it)
    {
        if ((*it)->getName() == name)
        {
            _callbacks->removePointVec(name);
            delete *it;
            _pnt_vecs.erase(it);
            return true;
        }
    }
    DBUG("GEOObjects::removePointVec() - No entry found with name '{:s}'.",
         name);
    return false;
}

References _callbacks, _pnt_vecs, DBUG(), and isPntVecUsed().

Referenced by consolidateGeometry(), OGSFileConverter::convertGLI2GML(), OGSFileConverter::convertGML2GLI(), FileIO::SwmmInterface::convertSwmmInputToGeometry(), FileIO::createSurface(), and removeStationVec().

◆ removePolylineVec()

bool GeoLib::GEOObjects::removePolylineVec ( const std::string & name )

If no Surfaces depends on the vector of Polylines with the given name it will be removed and the method returns true, else the return value is false.

Definition at line 211 of file GEOObjects.cpp.

{
    _callbacks->removePolylineVec(name);
    auto it = std::find_if(_ply_vecs.begin(), _ply_vecs.end(),
                           [&name](PolylineVec const* const v)
                           { return v->getName() == name; });
    if (it != _ply_vecs.end())
    {
        delete *it;
        _ply_vecs.erase(it);
        return true;
    }
 
    DBUG("GEOObjects::removePolylineVec() - No entry found with name '{:s}'.",
         name);
    return false;
}

References _callbacks, _ply_vecs, and DBUG().

Referenced by consolidateGeometry(), OGSFileConverter::convertGLI2GML(), OGSFileConverter::convertGML2GLI(), and FileIO::createSurface().

◆ removeStationVec()

bool GeoLib::GEOObjects::removeStationVec ( const std::string & name )

inline

Removes the station vector with the given name from GEOObjects.

Definition at line 124 of file GEOObjects.h.

    {
        _callbacks->removeStationVec(name);
        return removePointVec(name);
    }

References _callbacks, and removePointVec().

◆ removeSurfaceVec()

bool GeoLib::GEOObjects::removeSurfaceVec ( const std::string & name )

removes the vector of Surfaces with the given name

Definition at line 272 of file GEOObjects.cpp.

{
    _callbacks->removeSurfaceVec(name);
    auto const it = findVectorByName(_sfc_vecs, name);
    if (it != _sfc_vecs.end())
    {
        delete *it;
        _sfc_vecs.erase(it);
        return true;
    }
 
    DBUG("GEOObjects::removeSurfaceVec() - No entry found with name '{:s}'.",
         name);
    return false;
}

References _callbacks, _sfc_vecs, DBUG(), and GeoLib::findVectorByName().

Referenced by OGSFileConverter::convertGLI2GML(), OGSFileConverter::convertGML2GLI(), and FileIO::createSurface().

◆ renameGeometry()

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

Renames an existing geometry, i.e. renames the internal PointVec, PolylineVec and the SurfaceVec objects from old_name to new_name. If no such PointVec, PolylineVec and SurfaceVec objects exist nothing will happen.

Definition at line 543 of file GEOObjects.cpp.

{
    _callbacks->renameGeometry(old_name, new_name);
 
    auto rename = [&old_name, &new_name](auto const& container)
    {
        auto it = findVectorByName(container, old_name);
        if (it != container.end())
        {
            (*it)->setName(new_name);
        }
    };
 
    rename(_pnt_vecs);
    rename(_ply_vecs);
    rename(_sfc_vecs);
}

References _callbacks, _ply_vecs, _pnt_vecs, _sfc_vecs, and GeoLib::findVectorByName().

Referenced by FileIO::createSurface().

Member Data Documentation

◆ _callbacks

std::unique_ptr<Callbacks> GeoLib::GEOObjects::_callbacks {new Callbacks}

Definition at line 292 of file GEOObjects.h.

292{new Callbacks};

GeoLib::GEOObjects::Callbacks

Definition GEOObjects.h:49

Referenced by addPointVec(), addPolylineVec(), addStationVec(), addSurfaceVec(), appendPolylineVec(), appendSurfaceVec(), removePointVec(), removePolylineVec(), removeStationVec(), removeSurfaceVec(), and renameGeometry().

◆ _ply_vecs

std::vector<PolylineVec*> GeoLib::GEOObjects::_ply_vecs

private

vector manages pointers to PolylineVec objects

Definition at line 358 of file GEOObjects.h.

Referenced by ~GEOObjects(), addPolylineVec(), appendPolylineVec(), getPolylines(), getPolylineVec(), getPolylineVecObj(), isPntVecUsed(), removePolylineVec(), and renameGeometry().

◆ _pnt_vecs

std::vector<PointVec*> GeoLib::GEOObjects::_pnt_vecs

private

vector manages pointers to PointVec objects

Definition at line 356 of file GEOObjects.h.

Referenced by ~GEOObjects(), addPointVec(), addStationVec(), exists(), getGeometryNames(), getPoints(), getPointVec(), getPointVecObj(), getStationVec(), getStationVectorNames(), removePointVec(), and renameGeometry().

std::function<void(std::string const&)> GeoLib::GEOObjects::removeSurfaceVecCallback

Initial value:

=

[](std::string const& ) {}

Definition at line 309 of file GEOObjects.h.

310 {};

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

Detailed Description

Classes

Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Constructor & Destructor Documentation

◆ GEOObjects()

◆ ~GEOObjects()

Member Function Documentation

◆ addPointVec() [1/2]

◆ addPointVec() [2/2]

◆ addPolylineVec()

◆ addStationVec()

◆ addSurfaceVec()

◆ appendPolylineVec()

◆ appendSurfaceVec()

◆ exists()

◆ getElementNameByID()

◆ getGeometryNames()

◆ getGeoObject() [1/2]

◆ getGeoObject() [2/2]

◆ getPoints()

◆ getPointVec()

◆ getPointVecObj() [1/2]

◆ getPointVecObj() [2/2]

◆ getPolylines()

◆ getPolylineVec()

◆ getPolylineVecObj() [1/2]

◆ getPolylineVecObj() [2/2]

◆ getStationVec()

◆ getStationVectorNames()

◆ getSurfaces()

◆ getSurfaceVec()

◆ getSurfaceVecObj() [1/2]

◆ getSurfaceVecObj() [2/2]

◆ isPntVecUsed()

◆ isUniquePointVecName()

◆ mergeGeometries()

◆ mergePoints()

◆ mergePolylines()

◆ mergeSurfaces()

◆ removePointVec()

◆ removePolylineVec()

◆ removeStationVec()

◆ removeSurfaceVec()

◆ renameGeometry()

Member Data Documentation

◆ _callbacks

◆ _ply_vecs

◆ _pnt_vecs

◆ _sfc_vecs

◆ addPolylineVecCallback

◆ addSurfaceVecCallback

◆ appendPolylineVecCallback

◆ appendSurfaceVecCallback

◆ removePolylineVecCallback

◆ removeSurfaceVecCallback