GeoLib::IO::BoostXmlGmlInterface Class Reference

Detailed Description

Definition at line 35 of file BoostXmlGmlInterface.h.

#include <BoostXmlGmlInterface.h>

Inheritance diagram for GeoLib::IO::BoostXmlGmlInterface:

Collaboration diagram for GeoLib::IO::BoostXmlGmlInterface:

Public Member Functions
	BoostXmlGmlInterface (GeoLib::GEOObjects &geo_objs)
	~BoostXmlGmlInterface () override=default
bool	readFile (const std::string &fname) override
	Reads an xml-file containing OGS geometry. More...
Public Member Functions inherited from BaseLib::IO::Writer
	Writer ()
virtual	~Writer ()=default
std::string	writeToString ()
	Writes the object to a string. More...

Protected Member Functions
bool	write () override
	Required method for writing geometry. This is not implemented here, use the Qt class for writing. More...

Private Member Functions
void	readPoints (BaseLib::ConfigTree const &pointsRoot, std::vector< GeoLib::Point * > &points, std::map< std::string, std::size_t > &pnt_names)
	Reads GeoLib::Point-objects from an xml-file. More...
void	readPolylines (BaseLib::ConfigTree const &polylinesRoot, std::vector< GeoLib::Polyline * > &polylines, std::vector< GeoLib::Point * > const &points, const std::vector< std::size_t > &pnt_id_map, std::map< std::string, std::size_t > &ply_names)
	Reads GeoLib::Polyline-objects from an xml-file. More...
void	readSurfaces (BaseLib::ConfigTree const &surfacesRoot, std::vector< GeoLib::Surface * > &surfaces, std::vector< GeoLib::Point * > const &points, const std::vector< std::size_t > &pnt_id_map, std::map< std::string, std::size_t > &sfc_names)
	Reads GeoLib::Surface-objects from an xml-file. More...
void	addSurfacesToPropertyTree (BaseLib::ConfigTree::PTree &geometry_set)
void	addPolylinesToPropertyTree (BaseLib::ConfigTree::PTree &geometry_set)

Private Attributes
std::map< std::size_t, std::size_t >	_idx_map
GeoLib::GEOObjects &	_geo_objects

Additional Inherited Members
Public Attributes inherited from BaseLib::IO::XMLInterface
std::string	export_name = {}
Protected Attributes inherited from BaseLib::IO::Writer
std::ostringstream	out
	The stream to write to. More...

Constructor & Destructor Documentation

BoostXmlGmlInterface()

GeoLib::IO::BoostXmlGmlInterface::BoostXmlGmlInterface ( GeoLib::GEOObjects &  geo_objs )

explicit

Definition at line 33 of file BoostXmlGmlInterface.cpp.

    : _geo_objects(geo_objs)
{
}

~BoostXmlGmlInterface()

GeoLib::IO::BoostXmlGmlInterface::~BoostXmlGmlInterface ( )

overridedefault

Member Function Documentation

addPolylinesToPropertyTree()

void GeoLib::IO::BoostXmlGmlInterface::addPolylinesToPropertyTree ( BaseLib::ConfigTree::PTree &  geometry_set )

private

Definition at line 387 of file BoostXmlGmlInterface.cpp.

{
    GeoLib::PolylineVec const* const vec(
        _geo_objects.getPolylineVecObj(export_name));
    if (!vec)
    {
        INFO(
            "BoostXmlGmlInterface::addPolylinesToPropertyTree(): No polylines "
            "within the geometry '{:s}'.",
            export_name);
        return;
    }
 
    std::vector<GeoLib::Polyline*> const* const polylines(vec->getVector());
    if (!polylines || polylines->empty())
    {
        INFO(
            "BoostXmlGmlInterface::addPolylinesToPropertyTree(): No polylines "
            "within the geometry '{:s}'.",
            export_name);
        return;
    }
 
    auto& polylines_tag = geometry_set.add("polylines", "");
    for (std::size_t i = 0; i < polylines->size(); ++i)
    {
        GeoLib::Polyline const* const polyline((*polylines)[i]);
        std::string ply_name;
        vec->getNameOfElement(polyline, ply_name);
        auto& polyline_tag = polylines_tag.add("polyline", "");
        polyline_tag.put("<xmlattr>.id", i);
        if (!ply_name.empty())
        {
            polyline_tag.put("<xmlattr>.name", ply_name);
        }
        for (std::size_t j = 0; j < polyline->getNumberOfPoints(); ++j)
        {
            polyline_tag.add("pnt", polyline->getPointID(j));
        }
    }
}

References _geo_objects, BaseLib::IO::XMLInterface::export_name, GeoLib::TemplateVec< T >::getNameOfElement(), GeoLib::Polyline::getNumberOfPoints(), GeoLib::Polyline::getPointID(), GeoLib::GEOObjects::getPolylineVecObj(), GeoLib::TemplateVec< T >::getVector(), and INFO().

Referenced by write().

addSurfacesToPropertyTree()

void GeoLib::IO::BoostXmlGmlInterface::addSurfacesToPropertyTree ( BaseLib::ConfigTree::PTree &  geometry_set )

private

Definition at line 341 of file BoostXmlGmlInterface.cpp.

{
    GeoLib::SurfaceVec const* const sfc_vec(
        _geo_objects.getSurfaceVecObj(export_name));
    if (!sfc_vec)
    {
        INFO(
            "BoostXmlGmlInterface::addSurfacesToPropertyTree(): No surfaces "
            "within the geometry '{:s}'.",
            export_name);
        return;
    }
 
    std::vector<GeoLib::Surface*> const* const surfaces(sfc_vec->getVector());
    if (!surfaces || surfaces->empty())
    {
        INFO(
            "BoostXmlGmlInterface::addSurfacesToPropertyTree(): No surfaces "
            "within the geometry '{:s}'.",
            export_name);
        return;
    }
 
    auto& surfaces_tag = geometry_set.add("surfaces", "");
    for (std::size_t i = 0; i < surfaces->size(); ++i)
    {
        GeoLib::Surface const* const surface((*surfaces)[i]);
        std::string sfc_name;
        sfc_vec->getNameOfElement(surface, sfc_name);
        auto& surface_tag = surfaces_tag.add("surface", "");
        surface_tag.put("<xmlattr>.id", i);
        if (!sfc_name.empty())
        {
            surface_tag.put("<xmlattr>.name", sfc_name);
        }
        for (std::size_t j = 0; j < surface->getNumberOfTriangles(); ++j)
        {
            auto& element_tag = surface_tag.add("element", "");
            element_tag.put("<xmlattr>.p1", (*(*surface)[j])[0]);
            element_tag.put("<xmlattr>.p2", (*(*surface)[j])[1]);
            element_tag.put("<xmlattr>.p3", (*(*surface)[j])[2]);
        }
    }
}

References _geo_objects, BaseLib::IO::XMLInterface::export_name, GeoLib::TemplateVec< T >::getNameOfElement(), GeoLib::Surface::getNumberOfTriangles(), GeoLib::GEOObjects::getSurfaceVecObj(), GeoLib::TemplateVec< T >::getVector(), and INFO().

Referenced by write().

readFile()

bool GeoLib::IO::BoostXmlGmlInterface::readFile ( const std::string &  fname )

overridevirtual

Reads an xml-file containing OGS geometry.

Todo:

Reading geometries is always strict.

Input File Parameter:

gml__name

Input File Parameter:

gml__points

Input File Parameter:

gml__polylines

Input File Parameter:

gml__surfaces

Implements BaseLib::IO::XMLInterface.

Definition at line 38 of file BoostXmlGmlInterface.cpp.

{
    auto doc = BaseLib::makeConfigTree(fname, true, "OpenGeoSysGLI");
 
    // ignore attributes related to XML schema
    doc->ignoreConfigAttribute("xmlns:xsi");
    doc->ignoreConfigAttribute("xsi:noNamespaceSchemaLocation");
    doc->ignoreConfigAttribute("xmlns:ogs");
 
    auto polylines = std::make_unique<std::vector<GeoLib::Polyline*>>();
    auto surfaces = std::make_unique<std::vector<GeoLib::Surface*>>();
 
    using MapNameId = std::map<std::string, std::size_t>;
    auto ply_names = std::make_unique<MapNameId>();
    auto sfc_names = std::make_unique<MapNameId>();
 
    auto geo_name = doc->getConfigParameter<std::string>("name");
    if (geo_name.empty())
    {
        OGS_FATAL("BoostXmlGmlInterface::readFile(): <name> tag is empty.");
    }
 
    for (auto st : doc->getConfigSubtreeList("points"))
    {
        auto points = std::make_unique<std::vector<GeoLib::Point*>>();
        auto pnt_names = std::make_unique<MapNameId>();
        readPoints(st, *points, *pnt_names);
        _geo_objects.addPointVec(std::move(points), geo_name,
                                 std::move(pnt_names));
    }
 
    for (auto st : doc->getConfigSubtreeList("polylines"))
    {
        readPolylines(st,
                      *polylines,
                      *_geo_objects.getPointVec(geo_name),
                      _geo_objects.getPointVecObj(geo_name)->getIDMap(),
                      *ply_names);
    }
 
    for (auto st : doc->getConfigSubtreeList("surfaces"))
    {
        readSurfaces(st,
                     *surfaces,
                     *_geo_objects.getPointVec(geo_name),
                     _geo_objects.getPointVecObj(geo_name)->getIDMap(),
                     *sfc_names);
    }
 
    if (!polylines->empty())
    {
        _geo_objects.addPolylineVec(std::move(polylines), geo_name,
                                    std::move(ply_names));
    }
 
    if (!surfaces->empty())
    {
        _geo_objects.addSurfaceVec(std::move(surfaces), geo_name,
                                   std::move(sfc_names));
    }
 
    return true;
}

References _geo_objects, GeoLib::GEOObjects::addPointVec(), GeoLib::GEOObjects::addPolylineVec(), GeoLib::GEOObjects::addSurfaceVec(), GeoLib::PointVec::getIDMap(), GeoLib::GEOObjects::getPointVec(), GeoLib::GEOObjects::getPointVecObj(), BaseLib::makeConfigTree(), OGS_FATAL, readPoints(), readPolylines(), and readSurfaces().

Referenced by main(), readGeometry(), anonymous_namespace{ProjectData.cpp}::readGeometry(), and FileIO::readGeometryFromFile().

readPoints()

void GeoLib::IO::BoostXmlGmlInterface::readPoints ( BaseLib::ConfigTree const &  pointsRoot, std::vector< GeoLib::Point * > &  points, std::map< std::string, std::size_t > &  pnt_names  )

private

Reads GeoLib::Point-objects from an xml-file.

Input File Parameter:

gml__points__point

Input File Parameter:

gml__points__point__id

Input File Parameter:

gml__points__point__x

Input File Parameter:

gml__points__point__y

Input File Parameter:

gml__points__point__z

Input File Parameter:

gml__points__point__name

Definition at line 107 of file BoostXmlGmlInterface.cpp.

{
    for (auto const pt : pointsRoot.getConfigParameterList("point"))
    {
        auto const p_id = pt.getConfigAttribute<std::size_t>("id");
        auto const p_x = pt.getConfigAttribute<double>("x");
        auto const p_y = pt.getConfigAttribute<double>("y");
        auto const p_z = pt.getConfigAttribute<double>("z");
 
        auto const p_size = points.size();
        BaseLib::insertIfKeyUniqueElseError(_idx_map, p_id, p_size,
                                            "The point id is not unique.");
        points.push_back(new GeoLib::Point(p_x, p_y, p_z, p_id));
 
        if (auto const p_name =
            pt.getConfigAttributeOptional<std::string>("name"))
        {
            if (p_name->empty())
            {
                OGS_FATAL("Empty point name found in geometry file.");
            }
 
            BaseLib::insertIfKeyUniqueElseError(
                pnt_names, *p_name, p_size, "The point name is not unique.");
        }
    }
}

References _idx_map, BaseLib::ConfigTree::getConfigParameterList(), BaseLib::insertIfKeyUniqueElseError(), and OGS_FATAL.

Referenced by readFile().

readPolylines()

void GeoLib::IO::BoostXmlGmlInterface::readPolylines ( BaseLib::ConfigTree const &  polylinesRoot, std::vector< GeoLib::Polyline * > &  polylines, std::vector< GeoLib::Point * > const &  points, const std::vector< std::size_t > &  pnt_id_map, std::map< std::string, std::size_t > &  ply_names  )

private

Reads GeoLib::Polyline-objects from an xml-file.

Input File Parameter:

gml__polylines__polyline

Input File Parameter:

gml__polylines__polyline__id

Input File Parameter:

gml__polylines__polyline__name

Input File Parameter:

gml__polylines__polyline__pnt

Definition at line 144 of file BoostXmlGmlInterface.cpp.

{
    for (auto const pl : polylinesRoot.getConfigSubtreeList("polyline"))
    {
        auto const id = pl.getConfigAttribute<std::size_t>("id");
        // The id is not used but must be present in the GML file.
        // That's why pl.ignore...() cannot be used.
        (void)id;
 
        polylines.push_back(new GeoLib::Polyline(points));
 
        if (auto const p_name =
            pl.getConfigAttributeOptional<std::string>("name"))
        {
            if (p_name->empty())
            {
                OGS_FATAL("Empty polyline name found in geometry file.");
            }
 
            BaseLib::insertIfKeyUniqueElseError(
                ply_names, *p_name, polylines.size() - 1,
                "The polyline name is not unique.");
 
            auto accessOrError = [this, &p_name](auto pt_idx)
            {
                auto search = _idx_map.find(pt_idx);
                if (search == _idx_map.end())
                {
                    OGS_FATAL(
                        "Polyline `{:s}' contains the point id `{:d}', but the "
                        "id is not in the point list.",
                        p_name->c_str(), pt_idx);
                }
                return search->second;
            };
 
            for (auto const pt : pl.getConfigParameterList<std::size_t>("pnt"))
            {
                polylines.back()->addPoint(pnt_id_map[accessOrError(pt)]);
            }
        }
        else
        {
            // polyline has no name, ignore it.
            pl.ignoreConfigParameterAll("pnt");
            WARN(
                "Polyline name is required! Polylines without a name are "
                "ignored.");
        }
    }
}

References _idx_map, BaseLib::ConfigTree::getConfigSubtreeList(), BaseLib::insertIfKeyUniqueElseError(), OGS_FATAL, and WARN().

Referenced by readFile().

readSurfaces()

void GeoLib::IO::BoostXmlGmlInterface::readSurfaces ( BaseLib::ConfigTree const &  surfacesRoot, std::vector< GeoLib::Surface * > &  surfaces, std::vector< GeoLib::Point * > const &  points, const std::vector< std::size_t > &  pnt_id_map, std::map< std::string, std::size_t > &  sfc_names  )

private

Reads GeoLib::Surface-objects from an xml-file.

Input File Parameter:

gml__surfaces__surface

Input File Parameter:

gml__surfaces__surface__id

Input File Parameter:

gml__surfaces__surface__name

Input File Parameter:

gml__surfaces__surface__element

Input File Parameter:

gml__surfaces__surface__element__p1

Input File Parameter:

gml__surfaces__surface__element__p2

Input File Parameter:

gml__surfaces__surface__element__p3

Definition at line 205 of file BoostXmlGmlInterface.cpp.

{
    for (auto const& sfc : surfacesRoot.getConfigSubtreeList("surface"))
    {
        auto const id = sfc.getConfigAttribute<std::size_t>("id");
        // The id is not used but must be present in the GML file.
        // That's why sfc.ignore...() cannot be used.
        (void)id;
        surfaces.push_back(new GeoLib::Surface(points));
 
        if (auto const s_name =
            sfc.getConfigAttributeOptional<std::string>("name"))
        {
            if (s_name->empty())
            {
                OGS_FATAL("Empty surface name found in geometry file.");
            }
 
            BaseLib::insertIfKeyUniqueElseError(
                sfc_names, *s_name, surfaces.size() - 1,
                "The surface name is not unique.");
 
            for (auto const& element : sfc.getConfigParameterList("element"))
            {
                auto const p1_attr =
                    element.getConfigAttribute<std::size_t>("p1");
                auto const p2_attr =
                    element.getConfigAttribute<std::size_t>("p2");
                auto const p3_attr =
                    element.getConfigAttribute<std::size_t>("p3");
 
                auto accessOrError = [this, &s_name](std::size_t pt_idx)
                {
                    auto search = _idx_map.find(pt_idx);
                    if (search == _idx_map.end())
                    {
                        OGS_FATAL(
                            "The element list of the surface `{:s}' contains "
                            "the invalid point id `{:d}'.",
                            s_name->c_str(), pt_idx);
                    }
                    return search->second;
                };
 
                auto const p1 = pnt_id_map[accessOrError(p1_attr)];
                auto const p2 = pnt_id_map[accessOrError(p2_attr)];
                auto const p3 = pnt_id_map[accessOrError(p3_attr)];
                surfaces.back()->addTriangle(p1, p2, p3);
            }
        }
        else
        {
            // surface has no name, ignore it.
            sfc.ignoreConfigParameterAll("element");
        }
    }
}

References _idx_map, BaseLib::ConfigTree::getConfigSubtreeList(), BaseLib::insertIfKeyUniqueElseError(), and OGS_FATAL.

Referenced by readFile().

write()

bool GeoLib::IO::BoostXmlGmlInterface::write ( )

overrideprotectedvirtual

Required method for writing geometry. This is not implemented here, use the Qt class for writing.

Implements BaseLib::IO::Writer.

Definition at line 275 of file BoostXmlGmlInterface.cpp.

{
    if (export_name.empty())
    {
        ERR("BoostXmlGmlInterface::write(): No geometry specified.");
        return false;
    }
 
    GeoLib::PointVec const* const pnt_vec(
        _geo_objects.getPointVecObj(export_name));
    if (!pnt_vec)
    {
        ERR("BoostXmlGmlInterface::write(): No PointVec within the geometry "
            "'{:s}'.",
            export_name);
        return false;
    }
 
    std::vector<GeoLib::Point*> const* const pnts(pnt_vec->getVector());
    if (!pnts)
    {
        ERR("BoostXmlGmlInterface::write(): No vector of points within the "
            "geometry '{:s}'.",
            export_name);
        return false;
    }
    if (pnts->empty())
    {
        ERR("BoostXmlGmlInterface::write(): No points within the geometry "
            "'{:s}'.",
            export_name);
        return false;
    }
 
    // create a property tree for writing it to file
    boost::property_tree::ptree pt;
 
    // put header in property tree
    pt.put("<xmlattr>.xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
    pt.put("<xmlattr>.xmlns:ogs", "https://www.opengeosys.org");
    auto& geometry_set = pt.add("OpenGeoSysGLI", "");
 
    geometry_set.add("name", export_name);
    auto& pnts_tag = geometry_set.add("points", "");
    for (std::size_t k(0); k < pnts->size(); k++)
    {
        auto& pnt_tag = pnts_tag.add("point", "");
        pnt_tag.put("<xmlattr>.id", k);
        pnt_tag.put("<xmlattr>.x", (*((*pnts)[k]))[0]);
        pnt_tag.put("<xmlattr>.y", (*((*pnts)[k]))[1]);
        pnt_tag.put("<xmlattr>.z", (*((*pnts)[k]))[2]);
        std::string const& point_name(pnt_vec->getItemNameByID(k));
        if (!point_name.empty())
        {
            pnt_tag.put("<xmlattr>.name", point_name);
        }
    }
 
    addPolylinesToPropertyTree(geometry_set);
    addSurfacesToPropertyTree(geometry_set);
 
    boost::property_tree::xml_writer_settings<std::string> settings('\t', 1);
    write_xml(out, pt, settings);
    return true;
}

References _geo_objects, addPolylinesToPropertyTree(), addSurfacesToPropertyTree(), ERR(), BaseLib::IO::XMLInterface::export_name, GeoLib::PointVec::getItemNameByID(), GeoLib::GEOObjects::getPointVecObj(), GeoLib::TemplateVec< T >::getVector(), and BaseLib::IO::Writer::out.

Member Data Documentation

_geo_objects

GeoLib::GEOObjects& GeoLib::IO::BoostXmlGmlInterface::_geo_objects

private

Definition at line 72 of file BoostXmlGmlInterface.h.

Referenced by addPolylinesToPropertyTree(), addSurfacesToPropertyTree(), readFile(), and write().

_idx_map

std::map<std::size_t, std::size_t> GeoLib::IO::BoostXmlGmlInterface::_idx_map

private

Definition at line 71 of file BoostXmlGmlInterface.h.

Referenced by readPoints(), readPolylines(), and readSurfaces().

---

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

• GeoLib/IO/XmlIO/Boost/BoostXmlGmlInterface.h
• GeoLib/IO/XmlIO/Boost/BoostXmlGmlInterface.cpp