osmparser.cpp

#include "osmparser.h"
#include "osmpbfparser.h"
#include "shapefileparser.h"
#include "garminimgparser.h"
#include "mpparser.h"

#include <QFile>
#include <QFileInfo>
#include <QXmlStreamReader>
#include <QDebug>

OsmAbstractParser::OsmAbstractParser(QObject *parent)
    : QObject(parent)
{
}

void OsmAbstractParser::emitProgress(int percent, const QString &message)
{
    emit progressChanged(percent, message);
}

std::unique_ptr<OsmAbstractParser> OsmAbstractParser::createForFile(const QString &fileName)
{
    QString suffix = QFileInfo(fileName).suffix().toLower();
    if (suffix == QStringLiteral("pbf")) {
        return std::make_unique<OsmPbfParser>();
    } else if (suffix == QStringLiteral("osm") || suffix == QStringLiteral("xml")) {
        return std::make_unique<OsmXmlParser>();
    } else if (suffix == QStringLiteral("shp")) {
        return std::make_unique<OsmShapefileParser>();
    } else if (suffix == QStringLiteral("img")) {
        return std::make_unique<GarminIMGParser>();
    } else if (suffix == QStringLiteral("mp")) {
        return std::make_unique<MPParser>();
    }
    return nullptr;
}

OsmXmlParser::OsmXmlParser(QObject *parent)
    : OsmAbstractParser(parent)
{
}

bool OsmXmlParser::parse(const QString &fileName, OsmModel &model, OsmStyle &style)
{
    Q_UNUSED(style);
    QFile file(fileName);
    if (!file.exists()) {
        emitProgress(0, QStringLiteral("File does not exist: %1").arg(fileName));
        emit parseFinished(false, tr("File does not exist"));
        return false;
    }
    if (!file.open(QIODevice::ReadOnly)) {
        emitProgress(0, QStringLiteral("Cannot open file: %1").arg(fileName));
        emit parseFinished(false, tr("Cannot open file"));
        return false;
    }

    model.clear();

    emitProgress(5, QStringLiteral("Starting XML parsing..."));
    bool ok = parseStream(&file, model, style);
    file.close();

    if (ok) {
        emitProgress(90, QStringLiteral("Building draw list..."));
        model.finalizeAfterLoad();
        emitProgress(100,
            QStringLiteral("Parsing complete: nodes=%1 ways=%2 relations=%3")
                .arg(model.nodeCount()).arg(model.wayCount()).arg(model.relationCount()));
        emit parseFinished(true);
    } else {
        emit parseFinished(false, tr("Parsing failed"));
    }
    return ok;
}

bool OsmXmlParser::parseStream(QIODevice *device, OsmModel &model, OsmStyle &style)
{
    Q_UNUSED(style);

    QXmlStreamReader xml(device);

    qint64 fileSize = device->size();
    qint64 lastReport = 0;

    while (!xml.atEnd() && !xml.hasError()) {
        xml.readNext();
        if (xml.isStartElement()) {
            QStringView name = xml.name();
            if (name == "node") {
                qint64 id = xml.attributes().value("id").toLongLong();
                double lat = xml.attributes().value("lat").toDouble();
                double lon = xml.attributes().value("lon").toDouble();
                OsmNode node(id, lat, lon);

                int tagHead = -1;
                while (!(xml.isEndElement() && xml.name() == "node")) {
                    xml.readNext();
                    if (xml.isStartElement() && xml.name() == "tag") {
                        QString k = xml.attributes().value("k").toString();
                        QString v = xml.attributes().value("v").toString();
                        int keyId = model.registerKey(k);
                        tagHead = model.addTag(keyId, v, tagHead);
                    }
                    if (xml.atEnd() || xml.hasError()) break;
                }
                node.m_tagHead = tagHead;
                model.addNode(node);
            }
            else if (name == "way") {
                qint64 id = xml.attributes().value("id").toLongLong();
                OsmWay way(id);

                int tagHead = -1;
                int ndHead = -1;
                while (!(xml.isEndElement() && xml.name() == "way")) {
                    xml.readNext();
                    if (xml.isStartElement()) {
                        if (xml.name() == "nd") {
                            qint64 ref = xml.attributes().value("ref").toLongLong();
                            ndHead = model.addNd(ref, ndHead);
                        } else if (xml.name() == "tag") {
                            QString k = xml.attributes().value("k").toString();
                            QString v = xml.attributes().value("v").toString();
                            int keyId = model.registerKey(k);
                            tagHead = model.addTag(keyId, v, tagHead);
                        }
                    }
                    if (xml.atEnd() || xml.hasError()) break;
                }
                way.m_tagHead = tagHead;
                way.m_ndHead = ndHead;
                model.addWay(way);
            }
            else if (name == "relation") {
                qint64 id = xml.attributes().value("id").toLongLong();
                OsmRelation rel(id);

                int tagHead = -1;
                int memberHead = -1;
                while (!(xml.isEndElement() && xml.name() == "relation")) {
                    xml.readNext();
                    if (xml.isStartElement()) {
                        if (xml.name() == "tag") {
                            QString k = xml.attributes().value("k").toString();
                            QString v = xml.attributes().value("v").toString();
                            int keyId = model.registerKey(k);
                            tagHead = model.addTag(keyId, v, tagHead);
                        } else if (xml.name() == "member") {
                            QString typeStr = xml.attributes().value("type").toString();
                            qint64 ref = xml.attributes().value("ref").toLongLong();
                            QString role = xml.attributes().value("role").toString();
                            OsmRelationMember::MemberType mtype = OsmRelationMember::NODE;
                            if (typeStr == "way") mtype = OsmRelationMember::WAY;
                            else if (typeStr == "relation") mtype = OsmRelationMember::RELATION;
                            memberHead = model.addMember(mtype, ref, role, memberHead);
                        }
                    }
                    if (xml.atEnd() || xml.hasError()) break;
                }
                rel.setMemberHead(memberHead);
                rel.m_tagHead = tagHead;
                model.addRelation(rel);
            }
        }

        if (fileSize > 0) {
            qint64 pos = device->pos();
            if (pos - lastReport > fileSize / 20) {
                lastReport = pos;
                int pct = 5 + int((80 * pos) / fileSize);
                emitProgress(pct,
                    QStringLiteral("Parsing... nodes=%1 ways=%2 relations=%3")
                        .arg(model.nodeCount()).arg(model.wayCount()).arg(model.relationCount()));
            }
        }
    }

    if (xml.hasError()) {
        emitProgress(0,
            QStringLiteral("XML error: %1").arg(xml.errorString()));
        return false;
    }

    return true;
}