GeoLib::IO::XmlStnInterface Class Reference

Detailed Description

Reads and writes Observation Sites to and from XML files.

Definition at line 33 of file XmlStnInterface.h.

#include <XmlStnInterface.h>

Inheritance diagram for GeoLib::IO::XmlStnInterface:

Collaboration diagram for GeoLib::IO::XmlStnInterface:

Public Member Functions
	XmlStnInterface (GeoLib::GEOObjects &geo_objs)
int	readFile (const QString &fileName) override
	Reads an xml-file containing station object definitions into the GEOObjects used in the constructor (requires Qt)
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	readStations (const QDomNode &stationsRoot, std::vector< GeoLib::Point * > &stations, const std::string &station_file_name)
	Reads GeoLib::Station- or StationBorehole-objects from an xml-file.
void	writeBoreholeData (QDomDocument &doc, QDomElement &boreholeTag, GeoLib::StationBorehole *borehole) const
	Writes borehole-specific data to a station-xml-file.
void	readStratigraphy (const QDomNode &stratRoot, GeoLib::StationBorehole *borehole)
	Reads the stratigraphy of a borehole from an xml-file.

Private Attributes
GeoLib::GEOObjects &	_geo_objs

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

XmlStnInterface()

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

explicit

Definition at line 32 of file XmlStnInterface.cpp.

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

Member Function Documentation

readFile() [1/2]

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

overridevirtual

Reads an xml-file containing station object definitions into the GEOObjects used in the constructor (requires Qt)

Reimplemented from BaseLib::IO::XMLQtInterface.

Definition at line 37 of file XmlStnInterface.cpp.

{
    if (XMLQtInterface::readFile(fileName) == 0)
    {
        return 0;
    }
 
    QDomDocument doc("OGS-STN-DOM");
    doc.setContent(getContent());
    QDomElement docElement =
        doc.documentElement();  // root element, used for identifying file-type
    if (docElement.nodeName().compare("OpenGeoSysSTN"))
    {
        ERR("XmlStnInterface::readFile(): Unexpected XML root.");
        return 0;
    }
 
    QDomNodeList lists = docElement.childNodes();
    for (int i = 0; i < lists.count(); i++)
    {
        // read all the station lists
        QDomNodeList stationList = lists.at(i).childNodes();
        std::vector<GeoLib::Point*> stations;
        std::string stnName("[NN]");
 
        for (int j = 0; j < stationList.count(); j++)
        {
            const QDomNode station_node(stationList.at(j));
            const QString station_type(station_node.nodeName());
            if (station_type.compare("name") == 0)
            {
                stnName = station_node.toElement().text().toStdString();
            }
            else if (station_type.compare("stations") == 0)
            {
                readStations(station_node, stations, fileName.toStdString());
            }
            else if (station_type.compare("boreholes") == 0)
            {
                readStations(station_node, stations, fileName.toStdString());
            }
        }
 
        if (!stations.empty())
        {
            _geo_objs.addStationVec(std::move(stations), stnName);
        }
    }
 
    return 1;
}

References _geo_objs, GeoLib::GEOObjects::addStationVec(), ERR(), BaseLib::IO::XMLQtInterface::getContent(), and readStations().

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

readFile() [2/2]

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

inlineoverridevirtual

Implements BaseLib::IO::XMLInterface.

Definition at line 42 of file XmlStnInterface.h.

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

References readFile().

readStations()

void GeoLib::IO::XmlStnInterface::readStations ( const QDomNode & stationsRoot, std::vector< GeoLib::Point * > & stations, const std::string & station_file_name )

private

Reads GeoLib::Station- or StationBorehole-objects from an xml-file.

Definition at line 89 of file XmlStnInterface.cpp.

{
    QDomElement station = stationsRoot.firstChildElement();
    while (!station.isNull())
    {
        if (station.hasAttribute("id") && station.hasAttribute("x") &&
            station.hasAttribute("y"))
        {
            std::string stationName("[NN]");
            std::string sensor_data_file_name;
            std::string boreholeDate("0000-00-00");
            double boreholeDepth(0.0);
            double stationValue(0.0);
 
            QDomNodeList stationFeatures = station.childNodes();
            for (int i = 0; i < stationFeatures.count(); i++)
            {
                // check for general station features
                const QDomNode feature_node(stationFeatures.at(i));
                const QString feature_name(feature_node.nodeName());
                const QString element_text(feature_node.toElement().text());
                if (feature_name.compare("name") == 0)
                {
                    stationName = element_text.toStdString();
                }
                if (feature_name.compare("sensordata") == 0)
                {
                    sensor_data_file_name = element_text.toStdString();
                    /* add other station features here */
 
                    // check for general borehole features
                }
                else if (feature_name.compare("value") == 0)
                {
                    stationValue = element_text.toDouble();
                }
                else if (feature_name.compare("bdepth") == 0)
                {
                    boreholeDepth = element_text.toDouble();
                }
                else if (feature_name.compare("bdate") == 0)
                {
                    boreholeDate = element_text.toStdString();
                }
                /* add other borehole features here */
            }
 
            double zVal = (station.hasAttribute("z"))
                              ? station.attribute("z").toDouble()
                              : 0.0;
 
            if (station.nodeName().compare("station") == 0)
            {
                GeoLib::Station* s =
                    new GeoLib::Station(station.attribute("x").toDouble(),
                                        station.attribute("y").toDouble(),
                                        zVal,
                                        stationName);
                s->setStationValue(stationValue);
                if (!sensor_data_file_name.empty())
                {
                    s->addSensorDataFromCSV(BaseLib::copyPathToFileName(
                        sensor_data_file_name, station_file_name));
                }
                stations.push_back(s);
            }
            else if (station.nodeName().compare("borehole") == 0)
            {
                GeoLib::StationBorehole* s =
                    GeoLib::StationBorehole::createStation(
                        stationName,
                        station.attribute("x").toDouble(),
                        station.attribute("y").toDouble(),
                        zVal,
                        boreholeDepth,
                        boreholeDate);
                s->setStationValue(stationValue);
                /* add stratigraphy to the borehole */
                for (int j = 0; j < stationFeatures.count(); j++)
                {
                    if (stationFeatures.at(j).nodeName().compare("strat") == 0)
                    {
                        this->readStratigraphy(stationFeatures.at(j), s);
                    }
                }
 
                stations.push_back(s);
            }
        }
        else
        {
            WARN(
                "XmlStnInterface::readStations(): Attribute missing in "
                "<station> tag.");
        }
        station = station.nextSiblingElement();
    }
}

References GeoLib::Station::addSensorDataFromCSV(), BaseLib::copyPathToFileName(), GeoLib::StationBorehole::createStation(), readStratigraphy(), GeoLib::Station::setStationValue(), and WARN().

Referenced by readFile().

readStratigraphy()

void GeoLib::IO::XmlStnInterface::readStratigraphy ( const QDomNode & stratRoot, GeoLib::StationBorehole * borehole )

private

Reads the stratigraphy of a borehole from an xml-file.

Definition at line 190 of file XmlStnInterface.cpp.

{
    // borehole->addSoilLayer((*borehole)[0], (*borehole)[1], (*borehole)[2],
    // "");
    double depth_check((*borehole)[2]);
    QDomElement horizon = stratRoot.firstChildElement();
    while (!horizon.isNull())
    {
        if (horizon.hasAttribute("id") && horizon.hasAttribute("x") &&
            horizon.hasAttribute("y") && horizon.hasAttribute("z"))
        {
            std::string horizonName("[NN]");
 
            QDomNodeList horizonFeatures = horizon.childNodes();
            for (int i = 0; i < horizonFeatures.count(); i++)
            {
                if (horizonFeatures.at(i).nodeName().compare("name") == 0)
                {
                    horizonName =
                        horizonFeatures.at(i).toElement().text().toStdString();
                }
            }
            /* add other horizon features here */
 
            double depth(horizon.attribute("z").toDouble());
            if (std::abs(depth - depth_check) >
                std::numeric_limits<double>::
                    epsilon())  // skip soil-layer if its thickness is zero
            {
                borehole->addSoilLayer(horizon.attribute("x").toDouble(),
                                       horizon.attribute("y").toDouble(),
                                       depth,
                                       horizonName);
                depth_check = depth;
            }
            else
            {
                WARN(
                    "XmlStnInterface::readStratigraphy(): Skipped layer '{:s}' "
                    "in borehole '{:s}' because of thickness 0.0.",
                    horizonName, borehole->getName());
            }
        }
        else
        {
            WARN(
                "XmlStnInterface::readStratigraphy(): Attribute missing in "
                "<horizon> tag.");
        }
        horizon = horizon.nextSiblingElement();
    }
}

References GeoLib::StationBorehole::addSoilLayer(), GeoLib::Station::getName(), and WARN().

Referenced by readStations().

write()

bool GeoLib::IO::XmlStnInterface::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 244 of file XmlStnInterface.cpp.

{
    if (export_name.empty())
    {
        ERR("XmlStnInterface::write(): No station list specified.");
        return false;
    }
 
    out << "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n";  // xml
                                                                 // definition
    out << "<?xml-stylesheet type=\"text/xsl\" "
           "href=\"OpenGeoSysSTN.xsl\"?>\n\n";  // stylefile definition
 
    QDomDocument doc("OGS-STN-DOM");
    QDomElement root = doc.createElement("OpenGeoSysSTN");
    root.setAttribute("xmlns:ogs", "http://www.opengeosys.org");
    root.setAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
 
    const std::vector<GeoLib::Point*>* stations(
        _geo_objs.getStationVec(export_name));
    bool const is_borehole =
        dynamic_cast<GeoLib::StationBorehole*>((*stations)[0]);
 
    doc.appendChild(root);
    QDomElement stationListTag = doc.createElement("stationlist");
    root.appendChild(stationListTag);
 
    QDomElement listNameTag = doc.createElement("name");
    stationListTag.appendChild(listNameTag);
    QDomText stationListNameText =
        doc.createTextNode(QString::fromStdString(export_name));
    listNameTag.appendChild(stationListNameText);
    QString listType = is_borehole ? "boreholes" : "stations";
    QDomElement stationsTag = doc.createElement(listType);
    stationListTag.appendChild(stationsTag);
 
    bool useStationValue(false);
    double sValue =
        static_cast<GeoLib::Station*>((*stations)[0])->getStationValue();
    std::size_t nStations(stations->size());
    for (std::size_t i = 1; i < nStations; i++)
    {
        if ((static_cast<GeoLib::Station*>((*stations)[i])->getStationValue() -
             sValue) < std::numeric_limits<double>::epsilon())
        {
            useStationValue = true;
            break;
        }
    }
 
    for (std::size_t i = 0; i < nStations; i++)
    {
        QString stationType = is_borehole ? "borehole" : "station";
        QDomElement stationTag = doc.createElement(stationType);
        stationTag.setAttribute("id", QString::number(i));
        stationTag.setAttribute(
            "x", QString::number((*(*stations)[i])[0], 'f',
                                 std::numeric_limits<double>::digits10));
        stationTag.setAttribute(
            "y", QString::number((*(*stations)[i])[1], 'f',
                                 std::numeric_limits<double>::digits10));
        stationTag.setAttribute(
            "z", QString::number((*(*stations)[i])[2], 'f',
                                 std::numeric_limits<double>::digits10));
        stationsTag.appendChild(stationTag);
 
        QDomElement stationNameTag = doc.createElement("name");
        stationTag.appendChild(stationNameTag);
        QDomText stationNameText = doc.createTextNode(QString::fromStdString(
            static_cast<GeoLib::Station*>((*stations)[i])->getName()));
        stationNameTag.appendChild(stationNameText);
 
        if (useStationValue)
        {
            QDomElement stationValueTag = doc.createElement("value");
            stationTag.appendChild(stationValueTag);
            QDomText stationValueText = doc.createTextNode(
                QString::number(static_cast<GeoLib::Station*>((*stations)[i])
                                    ->getStationValue()));
            stationValueTag.appendChild(stationValueText);
        }
 
        if (is_borehole)
        {
            writeBoreholeData(
                doc, stationTag,
                static_cast<GeoLib::StationBorehole*>((*stations)[i]));
        }
    }
 
    std::string xml = doc.toString().toStdString();
    out << xml;
    return true;
}

References _geo_objs, ERR(), BaseLib::IO::XMLInterface::export_name, getName(), GeoLib::GEOObjects::getStationVec(), BaseLib::IO::Writer::out, and writeBoreholeData().

writeBoreholeData()

void GeoLib::IO::XmlStnInterface::writeBoreholeData ( QDomDocument & doc, QDomElement & boreholeTag, GeoLib::StationBorehole * borehole ) const

private

Writes borehole-specific data to a station-xml-file.

the first entry in the profile vector is just the position of the borehole

Definition at line 339 of file XmlStnInterface.cpp.

{
    QDomElement stationDepthTag = doc.createElement("bdepth");
    boreholeTag.appendChild(stationDepthTag);
    QDomText stationDepthText =
        doc.createTextNode(QString::number(borehole->getDepth(), 'f'));
    stationDepthTag.appendChild(stationDepthText);
    if (std::abs(borehole->getDate()) > 0)
    {
        QDomElement stationDateTag = doc.createElement("bdate");
        boreholeTag.appendChild(stationDateTag);
        QDomText stationDateText = doc.createTextNode(
            QString::fromStdString(BaseLib::date2string(borehole->getDate())));
        stationDateTag.appendChild(stationDateText);
    }
 
    std::vector<GeoLib::Point*> profile = borehole->getProfile();
    std::vector<std::string> soilNames = borehole->getSoilNames();
    std::size_t nHorizons(profile.size());
 
    if (nHorizons > 1)
    {
        QDomElement stratTag = doc.createElement("strat");
        boreholeTag.appendChild(stratTag);
 
        for (std::size_t j = 1; j < nHorizons;
             j++)  
        {
            QDomElement horizonTag = doc.createElement("horizon");
            horizonTag.setAttribute("id", QString::number(j));
            horizonTag.setAttribute("x",
                                    QString::number((*profile[j])[0], 'f'));
            horizonTag.setAttribute("y",
                                    QString::number((*profile[j])[1], 'f'));
            horizonTag.setAttribute("z",
                                    QString::number((*profile[j])[2], 'f'));
            stratTag.appendChild(horizonTag);
            QDomElement horizonNameTag = doc.createElement("name");
            horizonTag.appendChild(horizonNameTag);
            QDomText horizonNameText =
                doc.createTextNode(QString::fromStdString(soilNames[j]));
            horizonNameTag.appendChild(horizonNameText);
        }
    }
}

References BaseLib::date2string(), GeoLib::StationBorehole::getDate(), GeoLib::StationBorehole::getDepth(), GeoLib::StationBorehole::getProfile(), and GeoLib::StationBorehole::getSoilNames().

Referenced by write().

Member Data Documentation

_geo_objs

GeoLib::GEOObjects& GeoLib::IO::XmlStnInterface::_geo_objs

private

Definition at line 64 of file XmlStnInterface.h.

Referenced by readFile(), and write().

---

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

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