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 60 of file GEOObjects.h.

#include <GEOObjects.h>

Classes
struct	Callbacks

Public Member Functions
void	addPointVec (std::unique_ptr< std::vector< Point * >> points, std::string &name, std::unique_ptr< std::map< std::string, std::size_t >> pnt_id_name_map=nullptr, double 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. More...

bool	removePointVec (const std::string &name)

void	addStationVec (std::unique_ptr< std::vector< Point * >> stations, std::string &name)
	Adds a vector of stations with the given name and colour to GEOObjects. More...

const std::vector< GeoLib::Point * > *	getStationVec (const std::string &name) const
	Returns the station vector with the given name. More...

bool	removeStationVec (const std::string &name)
	Removes the station vector with the given name from GEOObjects. More...

void	addPolylineVec (std::unique_ptr< std::vector< Polyline * >> lines, const std::string &name, std::unique_ptr< std::map< std::string, std::size_t >> ply_names=nullptr)

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. More...

bool	removePolylineVec (const std::string &name)

void	addSurfaceVec (std::unique_ptr< std::vector< Surface * >> sfc, const std::string &name, std::unique_ptr< std::map< std::string, std::size_t >> sfc_names=nullptr)

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. More...

SurfaceVec *	getSurfaceVecObj (const std::string &name)
	Returns the surface vector with the given name. More...

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. More...

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. More...

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
	Returns the geo object for a geometric item of the given name and type for the associated geometry. More...

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. More...

	GEOObjects ()

	~GEOObjects ()

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

bool	isPntVecUsed (const std::string &name) const
	Checks if the point vector with the given name is referenced in a polyline- or surface vector. More...

std::vector< PointVec * > const &	getPoints () const
	Read access to points w/o using a name. More...

std::vector< PolylineVec * > const &	getPolylines () const
	Read access to polylines w/o using a name. More...

std::vector< SurfaceVec * > const &	getSurfaces () const
	Read access to surfaces w/o using a name. More...

Public Attributes
std::vector< PointVec * >	_pnt_vecs

std::vector< PolylineVec * >	_ply_vecs

std::vector< SurfaceVec * >	_sfc_vecs

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
bool	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)

Constructor & Destructor Documentation

◆ GEOObjects()

GeoLib::GEOObjects::GEOObjects ( )

default

constructor

◆ ~GEOObjects()

GeoLib::GEOObjects::~GEOObjects ( )

destructor

Definition at line 32 of file GEOObjects.cpp.

 {
     // delete surfaces
     for (auto& surface : _sfc_vecs)
     {
         delete surface;
     }
     // delete polylines
     for (auto& polyline : _ply_vecs)
     {
         delete polyline;
     }
     // delete points
     for (auto& point : _pnt_vecs)
     {
         delete point;
     }
 }

References _ply_vecs, _pnt_vecs, and _sfc_vecs.

Member Function Documentation

◆ addPointVec()

void GeoLib::GEOObjects::addPointVec	(	std::unique_ptr< std::vector< Point * >>	points,
		std::string &	name,
		std::unique_ptr< std::map< std::string, std::size_t >>	pnt_id_name_map = `nullptr`,
		double	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 51 of file GEOObjects.cpp.

 {
     isUniquePointVecName(name);
     if (!points || 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(), MaterialPropertyLib::name, and GeoLib::PointVec::POINT.

Referenced by FileIO::PetrelInterface::PetrelInterface(), convertMeshNodesToGeometry(), anonymous_namespace{convertMeshToGeo.cpp}::convertMeshNodesToGeoPoints(), convertPoints(), FileIO::SwmmInterface::convertSwmmInputToGeometry(), createGeometries(), GeoLib::Grid< POINT >::createGridGeometry(), GeoLib::DuplicateGeometry::duplicate(), main(), mergeGeometries(), mergePoints(), FileIO::FEFLOWGeoInterface::readFEFLOWFile(), GeoLib::IO::XmlGmlInterface::readFile(), GeoLib::IO::BoostXmlGmlInterface::readFile(), FileIO::Legacy::readGLIFileV4(), FileIO::SHPInterface::readPoints(), FileIO::SHPInterface::readPolylines(), FileIO::TetGenInterface::readTetGenGeometry(), and FileIO::GMSH::GMSHPolygonTree::writeAdditionalPointData().

◆ addPolylineVec()

void GeoLib::GEOObjects::addPolylineVec	(	std::unique_ptr< std::vector< Polyline * >>	lines,
		const std::string &	name,
		std::unique_ptr< std::map< std::string, std::size_t >>	ply_names = `nullptr`
	)

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 150 of file GEOObjects.cpp.

 {
     assert(lines);
     for (auto it(lines->begin()); it != lines->end();)
     {
         if ((*it)->getNumberOfPoints() < 2)
         {
             auto it_erase(it);
             it = lines->erase(it_erase);
         }
         else
         {
             ++it;
         }
     }
  
     if (lines->empty())
     {
         return;
     }
  
     _ply_vecs.push_back(
         new PolylineVec(name, std::move(lines), std::move(ply_names)));
     _callbacks->addPolylineVec(name);
 }

References _callbacks, _ply_vecs, and MaterialPropertyLib::name.

Referenced by FileIO::PetrelInterface::PetrelInterface(), FileIO::SwmmInterface::convertSwmmInputToGeometry(), createGeometries(), GeoLib::Grid< POINT >::createGridGeometry(), GeoLib::DuplicateGeometry::duplicate(), mergeGeometries(), mergePolylines(), FileIO::FEFLOWGeoInterface::readFEFLOWFile(), GeoLib::IO::XmlGmlInterface::readFile(), GeoLib::IO::BoostXmlGmlInterface::readFile(), FileIO::Legacy::readGLIFileV4(), FileIO::SHPInterface::readPolylines(), and FileIO::GMSH::GMSHPolygonTree::writeAdditionalPointData().

◆ addStationVec()

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

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

Definition at line 122 of file GEOObjects.cpp.

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

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

Referenced by FileIO::PetrelInterface::PetrelInterface(), convertPoints(), GeoLib::geoPointsToStations(), MainWindow::loadFile(), GeoLib::IO::XmlStnInterface::readFile(), FileIO::SHPInterface::readStations(), and FileIO::GMSH::GMSHInterface::writeGMSHInputFile().

◆ addSurfaceVec()

void GeoLib::GEOObjects::addSurfaceVec	(	std::unique_ptr< std::vector< Surface * >>	sfc,
		const std::string &	name,
		std::unique_ptr< std::map< std::string, std::size_t >>	sfc_names = `nullptr`
	)

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

Definition at line 261 of file GEOObjects.cpp.

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

References _callbacks, _sfc_vecs, and MaterialPropertyLib::name.

Referenced by appendSurfaceVec(), GeoLib::DuplicateGeometry::duplicate(), mergeSurfaces(), GeoLib::IO::XmlGmlInterface::readFile(), GeoLib::IO::BoostXmlGmlInterface::readFile(), 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 180 of file GEOObjects.cpp.

 {
     // search vector
     std::size_t idx(0);
     bool nfound(true);
     for (idx = 0; idx < _ply_vecs.size() && nfound; idx++)
     {
         if (_ply_vecs[idx]->getName() == name)
         {
             nfound = false;
         }
     }
  
     if (!nfound)
     {
         idx--;
         std::size_t n_plys(polylines.size());
         // append lines
         for (std::size_t k(0); k < n_plys; k++)
         {
             _ply_vecs[idx]->push_back(polylines[k]);
         }
         _callbacks->appendPolylineVec(name);
         return true;
     }
  
     return false;
 }

References _callbacks, _ply_vecs, getName(), and MaterialPropertyLib::name.

Referenced by GEOModels::connectPolylineSegments(), and FileIO::GMSH::GMSHInterface::writeGMSHInputFile().

◆ 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 272 of file GEOObjects.cpp.

 {
     // search vector
     std::size_t idx(0);
     bool nfound(true);
     for (idx = 0; idx < _sfc_vecs.size() && nfound; idx++)
     {
         if (_sfc_vecs[idx]->getName() == name)
         {
             nfound = false;
         }
     }
  
     if (!nfound)
     {
         idx--;
         std::size_t n_sfcs(surfaces.size());
         // append surfaces
         for (std::size_t k(0); k < n_sfcs; k++)
         {
             _sfc_vecs[idx]->push_back(surfaces[k]);
         }
         _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.
     auto sfc = std::make_unique<std::vector<GeoLib::Surface*>>(begin(surfaces),
                                                                end(surfaces));
     addSurfaceVec(std::move(sfc), name);
     return false;
 }

References _callbacks, _sfc_vecs, addSurfaceVec(), getName(), and MaterialPropertyLib::name.

Referenced by GEOModels::connectPolylineSegments().

◆ 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 831 of file GEOObjects.cpp.

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

References _pnt_vecs, and getName().

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 414 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(), MaterialPropertyLib::name, GeoLib::POINT, GeoLib::POLYLINE, and GeoLib::SURFACE.

Referenced by MainWindow::showGeoNameDialog().

◆ getGeometryNames()

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

Returns the names of all geometry vectors.

Definition at line 401 of file GEOObjects.cpp.

 {
     std::vector<std::string> names;
     for (auto 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(), MergeGeometriesDialog::MergeGeometriesDialog(), OGSFileConverter::convertGML2GLI(), isUniquePointVecName(), main(), FileIO::readGeometryFromFile(), MainWindow::save(), 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 803 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 746 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 GEOModels::addNameForObjectPoints(), and 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().

◆ getPointVec()

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

Returns the point vector with the given name.

Definition at line 71 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(), exists(), and MaterialPropertyLib::name.

Referenced by MeshLib::convertMeshToGeo(), GeoLib::DuplicateGeometry::copyPolylinesVector(), GeoLib::DuplicateGeometry::copySurfacesVector(), createGeometries(), GeoLib::Grid< POINT >::createGridGeometry(), GeoLib::DuplicateGeometry::duplicate(), GeoLib::DuplicateGeometry::getPointVectorCopy(), main(), MeshGeoToolsLib::GeoMapper::mapOnDEM(), MeshGeoToolsLib::GeoMapper::mapOnMesh(), MeshGeoToolsLib::GeoMapper::mapToConstantValue(), mergeGeometries(), GeoLib::IO::XmlGmlInterface::readFile(), GeoLib::IO::BoostXmlGmlInterface::readFile(), FileIO::TetGenInterface::readTetGenGeometry(), FileIO::GMSH::GMSHInterface::writeGMSHInputFile(), 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 110 of file GEOObjects.h.

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

References getPointVecObj(), and MaterialPropertyLib::name.

◆ 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 84 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(), exists(), and MaterialPropertyLib::name.

Referenced by GEOModels::addNameForElement(), GEOModels::addNameForObjectPoints(), GEOModels::addPointVec(), FileIO::GMSH::GMSHPolygonTree::checkIntersectionsSegmentExistingPolylines(), MeshLib::convertMeshToGeo(), FileIO::SwmmInterface::convertSwmmInputToGeometry(), GeoLib::DuplicateGeometry::duplicate(), GeoLib::geoPointsToStations(), getElementNameByID(), getGeoObject(), getPointVecObj(), FileIO::GMSH::GMSHPolygonTree::insertPolyline(), main(), mergePoints(), mergePolylines(), mergeSurfaces(), GeoLib::IO::XmlGmlInterface::readFile(), GeoLib::IO::BoostXmlGmlInterface::readFile(), FileIO::Legacy::readGLIFileV4(), FileIO::SHPInterface::readPolylines(), FileIO::TetGenInterface::readTetGenGeometry(), GEOModels::updateGeometry(), GeoLib::IO::BoostXmlGmlInterface::write(), GeoLib::IO::XmlGmlInterface::write(), FileIO::GMSH::GMSHPolygonTree::writeAdditionalPointData(), FileIO::Legacy::writeAllDataToGLIFileV4(), writeBCsAndGeometry(), FileIO::Legacy::writeGLIFileV4(), and FileIO::GMSH::GMSHInterface::writeGMSHInputFile().

◆ 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().

◆ getPolylineVec()

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

Returns the polyline vector with the given name.

Definition at line 210 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(), getName(), and MaterialPropertyLib::name.

Referenced by GeoLib::DuplicateGeometry::duplicate(), GeoLib::DuplicateGeometry::getPolylineVectorCopy(), main(), mergePolylines(), FileIO::Legacy::readGLIFileV4(), FileIO::SHPInterface::readPolygons(), and FileIO::GMSH::GMSHInterface::writeGMSHInputFile().

◆ 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 172 of file GEOObjects.h.

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

References getPolylineVecObj(), and MaterialPropertyLib::name.

◆ 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 227 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(), getName(), and MaterialPropertyLib::name.

Referenced by GEOModels::addNameForElement(), GeoLib::IO::BoostXmlGmlInterface::addPolylinesToPropertyTree(), GEOModels::addPolylineVec(), GEOModels::appendPolylineVec(), GEOModels::connectPolylineSegments(), GeoLib::DuplicateGeometry::duplicate(), getElementNameByID(), getGeoObject(), getPolylineVecObj(), main(), GeoLib::markUnusedPoints(), mergePolylines(), FileIO::Legacy::readGLIFileV4(), MainWindow::showLineEditDialog(), GEOModels::updateGeometry(), GeoLib::IO::XmlGmlInterface::write(), 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 131 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(), MaterialPropertyLib::name, and GeoLib::PointVec::STATION.

Referenced by GEOModels::addStationVec(), MainWindow::exportBoreholesToGMS(), MainWindow::showStationNameDialog(), GEOModels::updateGeometry(), GeoLib::IO::XmlStnInterface::write(), FileIO::Legacy::writeAllDataToGLIFileV4(), and FileIO::GMSH::GMSHInterface::writeGMSHInputFile().

◆ getStationVectorNames()

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

Returns the names of all station vectors.

Definition at line 390 of file GEOObjects.cpp.

 {
     for (auto 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(), MergeGeometriesDialog::MergeGeometriesDialog(), 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().

◆ 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 307 of file GEOObjects.cpp.

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

References _sfc_vecs, DBUG(), getName(), and MaterialPropertyLib::name.

Referenced by GeoLib::DuplicateGeometry::duplicate(), GeoLib::DuplicateGeometry::getSurfaceVectorCopy(), 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 205 of file GEOObjects.h.

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

References MaterialPropertyLib::name.

Referenced by GEOModels::addNameForElement(), GeoLib::IO::BoostXmlGmlInterface::addSurfacesToPropertyTree(), GEOModels::addSurfaceVec(), GEOModels::appendSurfaceVec(), GeoLib::DuplicateGeometry::duplicate(), getElementNameByID(), getGeoObject(), main(), GeoLib::markUnusedPoints(), mergeSurfaces(), GEOModels::updateGeometry(), GeoLib::IO::XmlGmlInterface::write(), 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 341 of file GEOObjects.cpp.

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

References _sfc_vecs, DBUG(), getName(), and MaterialPropertyLib::name.

◆ 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 369 of file GEOObjects.cpp.

 {
     // search dependent data structures (Polyline)
     for (auto polyline : _ply_vecs)
     {
         if (polyline->getName() == name)
         {
             return true;
         }
     }
     for (auto surface : _sfc_vecs)
     {
         if (surface->getName() == name)
         {
             return true;
         }
     }
  
     return false;
 }

References _ply_vecs, _sfc_vecs, and MaterialPropertyLib::name.

Referenced by removePointVec(), and GEOModels::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 356 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(), BaseLib::getUniqueName(), and MaterialPropertyLib::name.

Referenced by MergeGeometriesDialog::MergeGeometriesDialog(), 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 435 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);
  
     if (!mergePoints(geo_names, merged_geo_name, pnt_offsets))
     {
         return 1;
     }
  
     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(), main(), MainWindow::showMergeGeometriesDialog(), and FileIO::GMSH::GMSHInterface::writeGMSHInputFile().

◆ mergePoints()

bool 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

Returns: true, if merging the points succeeded, else false

Definition at line 459 of file GEOObjects.cpp.

 {
     const std::size_t n_geo_names(geo_names.size());
  
     auto merged_points = std::make_unique<std::vector<GeoLib::Point*>>();
     auto merged_pnt_names =
         std::make_unique<std::map<std::string, std::size_t>>();
  
     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;
         }
         const std::vector<GeoLib::Point*>* pnts(pnt_vec->getVector());
         if (pnts == nullptr)
         {
             return false;
         }
  
         // 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);
     return true;
 }

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 512 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);
  
     auto merged_polylines = std::make_unique<std::vector<GeoLib::Polyline*>>();
     auto merged_ply_names =
         std::make_unique<std::map<std::string, std::size_t>>();
  
     std::vector<GeoLib::Point*> const* merged_points(
         this->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->insert(
                         std::pair<std::string, std::size_t>(
                             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 571 of file GEOObjects.cpp.

 {
     std::vector<GeoLib::Point*> const* merged_points(
         this->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);
     auto merged_sfcs = std::make_unique<std::vector<GeoLib::Surface*>>();
     auto merged_sfc_names =
         std::make_unique<std::map<std::string, std::size_t>>();
     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->insert(
                         std::pair<std::string, std::size_t>(
                             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 97 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(), isPntVecUsed(), and MaterialPropertyLib::name.

Referenced by consolidateGeometry(), OGSFileConverter::convertGLI2GML(), OGSFileConverter::convertGML2GLI(), FileIO::SwmmInterface::convertSwmmInputToGeometry(), FileIO::createSurface(), GeoLib::IO::XmlGmlInterface::readFile(), GEOModels::removeGeometry(), removeStationVec(), and FileIO::GMSH::GMSHInterface::writeGMSHInputFile().

◆ 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 243 of file GEOObjects.cpp.

 {
     _callbacks->removePolylineVec(name);
     for (auto it = _ply_vecs.begin(); it != _ply_vecs.end(); ++it)
     {
         if ((*it)->getName() == name)
         {
             delete *it;
             _ply_vecs.erase(it);
             return true;
         }
     }
  
     DBUG("GEOObjects::removePolylineVec() - No entry found with name '{:s}'.",
          name);
     return false;
 }

References _callbacks, _ply_vecs, DBUG(), and MaterialPropertyLib::name.

Referenced by consolidateGeometry(), OGSFileConverter::convertGLI2GML(), OGSFileConverter::convertGML2GLI(), FileIO::createSurface(), GeoLib::IO::XmlGmlInterface::readFile(), GEOModels::removeGeometry(), and FileIO::GMSH::GMSHInterface::writeGMSHInputFile().

◆ removeStationVec()

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

inline

Removes the station vector with the given name from GEOObjects.

Definition at line 131 of file GEOObjects.h.

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

References _callbacks, MaterialPropertyLib::name, and removePointVec().

Referenced by FileIO::GMSH::GMSHInterface::writeGMSHInputFile().

◆ removeSurfaceVec()

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

removes the vector of Surfaces with the given name

Definition at line 323 of file GEOObjects.cpp.

 {
     _callbacks->removeSurfaceVec(name);
     for (auto it(_sfc_vecs.begin()); it != _sfc_vecs.end(); ++it)
     {
         if ((*it)->getName() == name)
         {
             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 MaterialPropertyLib::name.

Referenced by OGSFileConverter::convertGLI2GML(), OGSFileConverter::convertGML2GLI(), FileIO::createSurface(), GEOModels::removeGeometry(), and FileIO::GMSH::GMSHInterface::writeGMSHInputFile().

◆ 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 630 of file GEOObjects.cpp.

 {
     _callbacks->renameGeometry(old_name, new_name);
     for (auto* pnt_vec : _pnt_vecs)
     {
         if (pnt_vec->getName() == old_name)
         {
             pnt_vec->setName(new_name);
             break;
         }
     }
     for (auto* ply_vec : _ply_vecs)
     {
         if (ply_vec->getName() == old_name)
         {
             ply_vec->setName(new_name);
             break;
         }
     }
     for (auto* sfc_vec : _sfc_vecs)
     {
         if (sfc_vec->getName() == old_name)
         {
             sfc_vec->setName(new_name);
             break;
         }
     }
 }

References _callbacks, _ply_vecs, _pnt_vecs, and _sfc_vecs.

Referenced by FileIO::createSurface().

Member Data Documentation

◆ _callbacks

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

Definition at line 302 of file GEOObjects.h.

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

◆ _ply_vecs

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

vector manages pointers to PolylineVec objects

Definition at line 298 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

vector manages pointers to PointVec objects

Definition at line 295 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 319 of file GEOObjects.h.

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

GeoLib/GEOObjects.h
GeoLib/GEOObjects.cpp

Detailed Description

Classes

Public Member Functions

Public Attributes

Private Member Functions

Constructor & Destructor Documentation

◆ GEOObjects()

◆ ~GEOObjects()

Member Function Documentation

◆ addPointVec()

◆ 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