GEOObjects.h

Go to the documentation of this file.

 
#pragma once
 
#include <functional>
#include <map>
#include <string>
#include <vector>
 
#include "GeoType.h"
#include "Point.h"
#include "PointVec.h"
#include "Polyline.h"
#include "PolylineVec.h"
#include "Surface.h"
#include "SurfaceVec.h"
 
namespace GeoLib
{
 
class GEOObjects final
{
public:
    struct Callbacks
    {
        virtual void addPointVec(std::string const& /*unused*/) {}
        virtual void removePointVec(std::string const& /*unused*/) {}
        virtual void addStationVec(std::string const& /*unused*/) {}
        virtual void removeStationVec(std::string const& /*unused*/) {}
        virtual void addPolylineVec(std::string const& /*unused*/) {}
        virtual void appendPolylineVec(std::string const& /*unused*/) {}
        virtual void removePolylineVec(std::string const& /*unused*/) {}
        virtual void addSurfaceVec(std::string const& /*unused*/) {}
        virtual void appendSurfaceVec(std::string const& /*unused*/) {}
        virtual void removeSurfaceVec(std::string const& /*unused*/) {}
        virtual void renameGeometry(std::string const& /*unused*/,
                                    std::string const& /*unused*/)
        {
        }
        virtual ~Callbacks() = default;
    };
 
public:
    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)
    {
        return const_cast<PointVec*>(static_cast<const GEOObjects&>(*this).
                                        getPointVecObj(name));
    }
 
    bool removePointVec(const std::string &name);
 
    void addStationVec(std::vector<Point*>&& stations, std::string& name);
 
    const std::vector<GeoLib::Point*>* getStationVec(
        const std::string& name) const;
 
    bool removeStationVec(const std::string &name)
    {
        _callbacks->removeStationVec(name);
        return removePointVec(name);
    }
 
    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)
    {
        return const_cast<PolylineVec*>(static_cast<const GEOObjects&>(*this).
                                        getPolylineVecObj(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;
 
    SurfaceVec* getSurfaceVecObj(const std::string &name)
    {
        return const_cast<SurfaceVec*>(static_cast<const GEOObjects&>(*this).
                                       getSurfaceVecObj(name));
    }
 
    bool removeSurfaceVec(const std::string &name);
    const SurfaceVec* getSurfaceVecObj(const std::string &name) const;
 
    std::vector<std::string> getGeometryNames() const;
 
    std::string getElementNameByID(const std::string& geometry_name,
                                   GeoLib::GEOTYPE type, std::size_t id) const;
 
    void getStationVectorNames(std::vector<std::string>& names) const;
 
    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;
 
    // It is required that a tuple is a unique key for a geometric object!
    // If there is another geo object with same name one of them is returned.
    // In theory different types of geometric objects can have the same name.
    // For instance it is possible that a point object and a polyline object
    // share the same name. If there exists several objects sharing the same
    // name the first object found will be returned.
    // @param geo_name name of geometry
    // @param geo_obj_name name of the geo object
    GeoLib::GeoObject const* getGeoObject(const std::string &geo_name,
                                          const std::string &geo_obj_name) const;
 
    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 { return _pnt_vecs; }
    std::vector<PolylineVec*> const& getPolylines() const { return _ply_vecs; }
    std::vector<SurfaceVec*> const& getSurfaces() const { return _sfc_vecs; }
 
    std::unique_ptr<Callbacks> _callbacks{new Callbacks};
 
    std::function<void(std::string const&)> addPolylineVecCallback =
        [](std::string const& /*unused*/) {};
 
    std::function<void(std::string const&)> appendPolylineVecCallback =
        [](std::string const& /*unused*/) {};
 
    std::function<void(std::string const&)> removePolylineVecCallback =
        [](std::string const& /*unused*/) {};
 
    std::function<void(std::string const&)> addSurfaceVecCallback =
        [](std::string const& /*unused*/) {};
 
    std::function<void(std::string const&)> appendSurfaceVecCallback =
        [](std::string const& /*unused*/) {};
 
    std::function<void(std::string const&)> removeSurfaceVecCallback =
        [](std::string const& /*unused*/) {};
 
private:
    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);
 
    std::vector<PointVec*> _pnt_vecs;
    std::vector<PolylineVec*> _ply_vecs;
    std::vector<SurfaceVec*> _sfc_vecs;
};
 
// @param geo_obj geometry manager object
// @param geo_name name of the geometry
// @param stn_name name of the new station vector
// @param only_usused_pnts if true only points not in a line or surface are
// transferred, otherwise all points
int geoPointsToStations(GEOObjects& geo_objects, std::string const& geo_name,
                        std::string& stn_name,
                        bool const only_unused_pnts = true);
}  // namespace GeoLib