GeoLib::IO::XmlGmlInterface Class Reference

Detailed Description

Reads and writes GeoObjects to and from XML files.

Definition at line 32 of file XmlGmlInterface.h.

#include <XmlGmlInterface.h>

Inheritance diagram for GeoLib::IO::XmlGmlInterface:

Collaboration diagram for GeoLib::IO::XmlGmlInterface:

Public Member Functions
	XmlGmlInterface (GeoLib::GEOObjects &geo_objs)
int	readFile (const QString &fileName) override
	Reads an xml-file containing geometric object definitions into the GEOObjects used in the constructor.
bool	readFile (std::string const &fname) override
Public Member Functions inherited from BaseLib::IO::Writer
	Writer ()
virtual	~Writer ()=default
std::string	writeToString ()
	Writes the object to a string.
Public Member Functions inherited from BaseLib::IO::XMLQtInterface
	XMLQtInterface (QString schemaFile="")
virtual	~XMLQtInterface ()=default

Protected Member Functions
bool	write () override
	Writes the object to the internal stream. This method must be implemented by a subclass. The implementation should return true on success, else false.
Protected Member Functions inherited from BaseLib::IO::XMLQtInterface
bool	checkHash () const
QByteArray const &	getContent () const

Private Member Functions
void	readPoints (const QDomNode &pointsRoot, std::vector< GeoLib::Point * > &points, std::map< std::string, std::size_t > *pnt_names)
	Reads GeoLib::Point-objects from an xml-file.
void	readPolylines (const QDomNode &polylinesRoot, std::vector< GeoLib::Polyline * > &polylines, std::vector< GeoLib::Point * > const &points, const std::vector< std::size_t > &pnt_id_map, GeoLib::PolylineVec::NameIdMap &ply_names)
	Reads GeoLib::Polyline-objects from an xml-file.
void	readSurfaces (const QDomNode &surfacesRoot, std::vector< GeoLib::Surface * > &surfaces, std::vector< GeoLib::Point * > const &points, const std::vector< std::size_t > &pnt_id_map, GeoLib::SurfaceVec::NameIdMap &sfc_names)
	Reads GeoLib::Surface-objects from an xml-file.

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

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.

Constructor & Destructor Documentation

XmlGmlInterface()

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

explicit

Definition at line 29 of file XmlGmlInterface.cpp.

    : XMLQtInterface("OpenGeoSysGLI.xsd"), _geo_objs(geo_objs)
{
}

Member Function Documentation

readFile() [1/2]

int GeoLib::IO::XmlGmlInterface::readFile ( const QString & fileName )

overridevirtual

Reads an xml-file containing geometric object definitions into the GEOObjects used in the constructor.

Reimplemented from BaseLib::IO::XMLQtInterface.

Definition at line 34 of file XmlGmlInterface.cpp.

{
    if (XMLQtInterface::readFile(fileName) == 0)
    {
        return 0;
    }
 
    QDomDocument doc("OGS-GLI-DOM");
    doc.setContent(getContent());
    QDomElement docElement = doc.documentElement();  // OpenGeoSysGLI
    if (docElement.nodeName().compare("OpenGeoSysGLI"))
    {
        ERR("XmlGmlInterface::readFile() - Unexpected XML root.");
        return 0;
    }
 
    std::string gliName("[NN]");
 
    std::vector<GeoLib::Point*> points;
    std::vector<GeoLib::Polyline*> polylines;
    std::vector<GeoLib::Surface*> surfaces;
 
    GeoLib::PointVec::NameIdMap pnt_names;
    GeoLib::PolylineVec::NameIdMap ply_names;
    GeoLib::SurfaceVec::NameIdMap sfc_names;
 
    QDomNodeList geoTypes = docElement.childNodes();
    for (int i = 0; i < geoTypes.count(); i++)
    {
        const QDomNode type_node(geoTypes.at(i));
        const QString nodeName = type_node.nodeName();
        if (nodeName.compare("name") == 0)
        {
            if (type_node.toElement().text().isEmpty())
            {
                ERR("XmlGmlInterface::readFile(): <name>-tag is empty.");
                BaseLib::cleanupVectorElements(surfaces, polylines, points);
                return 0;
            }
 
            gliName = type_node.toElement().text().toStdString();
        }
        else if (nodeName.compare("points") == 0)
        {
            readPoints(type_node, points, &pnt_names);
            _geo_objs.addPointVec(std::move(points), gliName,
                                  std::move(pnt_names));
        }
        else if (nodeName.compare("polylines") == 0)
        {
            try
            {
                readPolylines(
                    type_node, polylines, *_geo_objs.getPointVec(gliName),
                    _geo_objs.getPointVecObj(gliName)->getIDMap(), ply_names);
            }
            catch (std::runtime_error const&)
            {
                // further reading is aborted and it is necessary to clean up
                _geo_objs.removePointVec(gliName);
                throw;
            }
        }
        else if (nodeName.compare("surfaces") == 0)
        {
            try
            {
                readSurfaces(
                    type_node, surfaces, *_geo_objs.getPointVec(gliName),
                    _geo_objs.getPointVecObj(gliName)->getIDMap(), sfc_names);
            }
            catch (std::runtime_error const&)
            {
                // further reading is aborted and it is necessary to clean up
                _geo_objs.removePointVec(gliName);
                _geo_objs.removePolylineVec(gliName);
                throw;
            }
        }
    }
 
    if (!polylines.empty())
    {
        _geo_objs.addPolylineVec(std::move(polylines), gliName,
                                 std::move(ply_names));
    }
 
    if (!surfaces.empty())
    {
        _geo_objs.addSurfaceVec(std::move(surfaces), gliName,
                                std::move(sfc_names));
    }
    return 1;
}

References _geo_objs, GeoLib::GEOObjects::addPointVec(), GeoLib::GEOObjects::addPolylineVec(), GeoLib::GEOObjects::addSurfaceVec(), BaseLib::cleanupVectorElements(), ERR(), BaseLib::IO::XMLQtInterface::getContent(), GeoLib::PointVec::getIDMap(), GeoLib::GEOObjects::getPointVec(), GeoLib::GEOObjects::getPointVecObj(), readPoints(), readPolylines(), readSurfaces(), GeoLib::GEOObjects::removePointVec(), and GeoLib::GEOObjects::removePolylineVec().

Referenced by consolidateGeometry(), OGSFileConverter::convertGML2GLI(), MainWindow::loadFile(), FileIO::XmlPrjInterface::readFile(), and readFile().

readFile() [2/2]

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

inlineoverridevirtual

Implements BaseLib::IO::XMLInterface.

Definition at line 41 of file XmlGmlInterface.h.

    {
        return readFile(QString(fname.c_str())) != 0;
    }

References readFile().

readPoints()

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

private

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

Definition at line 129 of file XmlGmlInterface.cpp.

{
    char* pEnd;
    QDomElement point = pointsRoot.firstChildElement();
    while (!point.isNull())
    {
        _idx_map.insert(std::pair<std::size_t, std::size_t>(
            strtol((point.attribute("id")).toStdString().c_str(), &pEnd, 10),
            points.size()));
        GeoLib::Point* p = new GeoLib::Point(point.attribute("x").toDouble(),
                                             point.attribute("y").toDouble(),
                                             point.attribute("z").toDouble(),
                                             point.attribute("id").toInt());
        if (point.hasAttribute("name"))
        {
            pnt_names->insert(std::pair<std::string, std::size_t>(
                point.attribute("name").toStdString(), points.size()));
        }
 
        points.push_back(p);
        point = point.nextSiblingElement();
    }
}

References _idx_map.

Referenced by readFile().

readPolylines()

void GeoLib::IO::XmlGmlInterface::readPolylines ( const QDomNode & polylinesRoot, std::vector< GeoLib::Polyline * > & polylines, std::vector< GeoLib::Point * > const & points, const std::vector< std::size_t > & pnt_id_map, GeoLib::PolylineVec::NameIdMap & ply_names )

private

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

Definition at line 155 of file XmlGmlInterface.cpp.

{
    QDomElement polyline = polylinesRoot.firstChildElement();
    while (!polyline.isNull())
    {
        std::size_t const idx = polylines.size();
        polylines.push_back(new GeoLib::Polyline(points));
 
        if (polyline.hasAttribute("name"))
        {
            std::string const ply_name(
                polyline.attribute("name").toStdString());
            std::map<std::string, std::size_t>::const_iterator it(
                ply_names.find(ply_name));
            if (it == ply_names.end())
            {
                ply_names.insert(
                    std::pair<std::string, std::size_t>(ply_name, idx));
            }
            else
            {
                WARN(
                    "Polyline '{:s}' exists already. Polyline {:d} will be "
                    "inserted without a name.",
                    ply_name, idx);
            }
        }
 
        QDomElement point = polyline.firstChildElement();
        auto accessOrError = [this, &polyline](auto pt_idx)
        {
            auto search = _idx_map.find(pt_idx);
            if (search == _idx_map.end())
            {
                std::string polyline_name;
                if (polyline.hasAttribute("name"))
                {
                    polyline_name = polyline.attribute("name").toStdString();
                }
                OGS_FATAL(
                    "Polyline `{:s}' contains the point id `{:d}' which is not "
                    "in the point list.",
                    polyline_name, pt_idx);
            }
            return search->second;
        };
 
        while (!point.isNull())
        {
            polylines[idx]->addPoint(
                pnt_id_map[accessOrError(point.text().toInt())]);
            point = point.nextSiblingElement();
        }
 
        polyline = polyline.nextSiblingElement();
    }
}

References _idx_map, OGS_FATAL, and WARN().

Referenced by readFile().

readSurfaces()

void GeoLib::IO::XmlGmlInterface::readSurfaces ( const QDomNode & surfacesRoot, std::vector< GeoLib::Surface * > & surfaces, std::vector< GeoLib::Point * > const & points, const std::vector< std::size_t > & pnt_id_map, GeoLib::SurfaceVec::NameIdMap & sfc_names )

private

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

Definition at line 217 of file XmlGmlInterface.cpp.

{
    QDomElement surface = surfacesRoot.firstChildElement();
    while (!surface.isNull())
    {
        surfaces.push_back(new GeoLib::Surface(points));
 
        if (surface.hasAttribute("name"))
        {
            sfc_names.insert(std::pair<std::string, std::size_t>(
                surface.attribute("name").toStdString(), surfaces.size() - 1));
        }
 
        auto accessOrError = [this, &surface](auto pt_idx)
        {
            auto search = _idx_map.find(pt_idx);
            if (search == _idx_map.end())
            {
                std::string surface_name;
                if (surface.hasAttribute("name"))
                {
                    surface_name = surface.attribute("name").toStdString();
                }
                OGS_FATAL(
                    "Surface `{:s}' contains the point id `{:d}', which is not "
                    "in the point list.",
                    surface_name, pt_idx);
            }
            return search->second;
        };
 
        QDomElement element = surface.firstChildElement();
        while (!element.isNull())
        {
            std::size_t p1 =
                pnt_id_map[accessOrError(element.attribute("p1").toInt())];
            std::size_t p2 =
                pnt_id_map[accessOrError(element.attribute("p2").toInt())];
            std::size_t p3 =
                pnt_id_map[accessOrError(element.attribute("p3").toInt())];
            surfaces.back()->addTriangle(p1, p2, p3);
            element = element.nextSiblingElement();
        }
 
        surface = surface.nextSiblingElement();
    }
}

References _idx_map, and OGS_FATAL.

Referenced by readFile().

write()

bool GeoLib::IO::XmlGmlInterface::write ( )

overrideprotectedvirtual

Writes the object to the internal stream. This method must be implemented by a subclass. The implementation should return true on success, else false.

Implements BaseLib::IO::Writer.

Definition at line 268 of file XmlGmlInterface.cpp.

{
    if (export_name.empty())
    {
        ERR("XmlGmlInterface::write(): No geometry specified.");
        return false;
    }
 
    out << "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n";  // xml
                                                                 // definition
 
    QDomDocument doc("OGS-GML-DOM");
    QDomElement root = doc.createElement("OpenGeoSysGLI");
    root.setAttribute("xmlns:ogs", "http://www.opengeosys.org");
    root.setAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
 
    doc.appendChild(root);
 
    QDomElement geoNameTag = doc.createElement("name");
    root.appendChild(geoNameTag);
    QDomText geoNameText =
        doc.createTextNode(QString::fromStdString(export_name));
    geoNameTag.appendChild(geoNameText);
 
    // POINTS
    QDomElement pointsListTag = doc.createElement("points");
    root.appendChild(pointsListTag);
 
    const GeoLib::PointVec* pnt_vec(_geo_objs.getPointVecObj(export_name));
    if (pnt_vec)
    {
        auto const& points(pnt_vec->getVector());
 
        if (!points.empty())
        {
            auto const nPoints = points.size();
            for (std::size_t i = 0; i < nPoints; i++)
            {
                QDomElement pointTag = doc.createElement("point");
                pointTag.setAttribute("id", QString::number(i));
                pointTag.setAttribute(
                    "x",
                    QString::number((*points[i])[0], 'f',
                                    std::numeric_limits<double>::max_digits10));
                pointTag.setAttribute(
                    "y",
                    QString::number((*points[i])[1], 'f',
                                    std::numeric_limits<double>::max_digits10));
                pointTag.setAttribute(
                    "z",
                    QString::number((*points[i])[2], 'f',
                                    std::numeric_limits<double>::max_digits10));
 
                std::string const& point_name(pnt_vec->getItemNameByID(i));
                if (!point_name.empty())
                {
                    pointTag.setAttribute("name",
                                          QString::fromStdString(point_name));
                }
 
                pointsListTag.appendChild(pointTag);
            }
        }
        else
        {
            ERR("XmlGmlInterface::write(): Point vector is empty, abort "
                "writing geometry.");
            return false;
        }
    }
    else
    {
        ERR("XmlGmlInterface::write(): No point vector found, abort writing "
            "geometry.");
        return false;
    }
 
    // POLYLINES
    const GeoLib::PolylineVec* ply_vec(
        _geo_objs.getPolylineVecObj(export_name));
    if (ply_vec)
    {
        auto const& polylines(ply_vec->getVector());
 
        if (!polylines.empty())
        {
            QDomElement plyListTag = doc.createElement("polylines");
            root.appendChild(plyListTag);
            auto const nPolylines = polylines.size();
            for (std::size_t i = 0; i < nPolylines; i++)
            {
                QDomElement polylineTag = doc.createElement("polyline");
                polylineTag.setAttribute("id", QString::number(i));
 
                std::string ply_name;
                if (ply_vec->getNameOfElementByID(i, ply_name))
                {
                    polylineTag.setAttribute("name",
                                             QString::fromStdString(ply_name));
                }
                else
                {
                    ply_name = std::to_string(i);
                    polylineTag.setAttribute("name",
                                             QString::fromStdString(ply_name));
                }
 
                plyListTag.appendChild(polylineTag);
 
                auto const nPoints = polylines[i]->getNumberOfPoints();
                for (std::size_t j = 0; j < nPoints; j++)
                {
                    QDomElement plyPointTag = doc.createElement("pnt");
                    polylineTag.appendChild(plyPointTag);
                    QDomText plyPointText = doc.createTextNode(
                        QString::number((polylines[i])->getPointID(j)));
                    plyPointTag.appendChild(plyPointText);
                }
            }
        }
    }
    else
    {
        INFO(
            "XmlGmlInterface::write(): Polyline vector is empty, no polylines "
            "written to file.");
    }
 
    // SURFACES
    const GeoLib::SurfaceVec* sfc_vec(_geo_objs.getSurfaceVecObj(export_name));
    if (sfc_vec)
    {
        auto const& surfaces(sfc_vec->getVector());
 
        if (!surfaces.empty())
        {
            QDomElement sfcListTag = doc.createElement("surfaces");
            root.appendChild(sfcListTag);
            auto const nSurfaces = surfaces.size();
            for (std::size_t i = 0; i < nSurfaces; i++)
            {
                QDomElement surfaceTag = doc.createElement("surface");
                surfaceTag.setAttribute("id", QString::number(i));
 
                std::string sfc_name;
                if (sfc_vec->getNameOfElementByID(i, sfc_name))
                {
                    surfaceTag.setAttribute("name",
                                            QString::fromStdString(sfc_name));
                }
 
                sfcListTag.appendChild(surfaceTag);
 
                // writing the elements compromising the surface
                std::size_t nElements = (surfaces[i])->getNumberOfTriangles();
                for (std::size_t j = 0; j < nElements; j++)
                {
                    QDomElement elementTag = doc.createElement("element");
                    elementTag.setAttribute(
                        "p1", QString::number((*(*surfaces[i])[j])[0]));
                    elementTag.setAttribute(
                        "p2", QString::number((*(*surfaces[i])[j])[1]));
                    elementTag.setAttribute(
                        "p3", QString::number((*(*surfaces[i])[j])[2]));
                    surfaceTag.appendChild(elementTag);
                }
            }
        }
        else
        {
            INFO(
                "XmlGmlInterface::write(): Surface vector is empty, no "
                "surfaces written to file.");
        }
    }
    else
    {
        INFO(
            "XmlGmlInterface::write(): Surface vector is empty, no surfaces "
            "written to file.");
    }
 
    std::string xml = doc.toString().toStdString();
    out << xml;
 
    return true;
}

References _geo_objs, ERR(), BaseLib::IO::XMLInterface::export_name, GeoLib::PointVec::getItemNameByID(), GeoLib::TemplateVec< T >::getNameOfElementByID(), GeoLib::GEOObjects::getPointVecObj(), GeoLib::GEOObjects::getPolylineVecObj(), GeoLib::GEOObjects::getSurfaceVecObj(), GeoLib::TemplateVec< T >::getVector(), INFO(), and BaseLib::IO::Writer::out.

Member Data Documentation

_geo_objs

GeoLib::GEOObjects& GeoLib::IO::XmlGmlInterface::_geo_objs

private

Definition at line 69 of file XmlGmlInterface.h.

Referenced by readFile(), and write().

_idx_map

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

private

Definition at line 70 of file XmlGmlInterface.h.

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

---

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

• GeoLib/IO/XmlIO/Qt/XmlGmlInterface.h
• GeoLib/IO/XmlIO/Qt/XmlGmlInterface.cpp