File indexing completed on 2024-11-17 04:17:22

 /*
     SPDX-FileCopyrightText: 2020 Volker Krause <vkrause@kde.org>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "equipmentmodel.h"
 #include "../loader/levelparser_p.h"
 
 #include <osm/geomath.h>
 
 #include <QDebug>
 
 using namespace KOSMIndoorMap;
 
 float Equipment::distanceTo(const OSM::DataSet &dataSet, float lat, float lon) const
 {
     if (sourceElements.empty()) {
         return std::numeric_limits<float>::max();
     }
 
     switch (sourceElements[0].type()) {
         case OSM::Type::Null:
             return std::numeric_limits<float>::max();
         case OSM::Type::Node:
             return OSM::distance(sourceElements[0].center(), OSM::Coordinate(lat, lon));
         case OSM::Type::Way:
         case OSM::Type::Relation:
         {
             const auto path = sourceElements[0].outerPath(dataSet);
             return OSM::distance(path, OSM::Coordinate(lat, lon));
         }
     }
     Q_UNREACHABLE();
     return std::numeric_limits<float>::max();
 }
 
 
 EquipmentModel::EquipmentModel(QObject* parent)
     : AbstractOverlaySource(nullptr, parent)
 {
 }
 
 EquipmentModel::~EquipmentModel() = default;
 
 MapData EquipmentModel::mapData() const
 {
     return m_data;
 }
 
 void EquipmentModel::setMapData(const MapData &data)
 {
     if (m_data == data) {
         return;
     }
 
     m_equipment.clear();
     m_data = data;
 
     if (!m_data.isEmpty()) {
         m_tagKeys.building = m_data.dataSet().tagKey("building");
         m_tagKeys.buildling_part = m_data.dataSet().tagKey("building:part");
         m_tagKeys.conveying = m_data.dataSet().tagKey("conveying");
         m_tagKeys.elevator = m_data.dataSet().tagKey("elevator");
         m_tagKeys.highway = m_data.dataSet().tagKey("highway");
         m_tagKeys.indoor = m_data.dataSet().tagKey("indoor");
         m_tagKeys.level = m_data.dataSet().tagKey("level");
         m_tagKeys.room = m_data.dataSet().tagKey("room");
         m_tagKeys.stairwell = m_data.dataSet().tagKey("stairwell");
 
         m_tagKeys.mxoid = m_data.dataSet().makeTagKey("mx:oid");
         m_tagKeys.realtimeStatus = m_data.dataSet().makeTagKey("mx:realtime_status");
         findEquipment();
     }
 
     for (const auto &eq : m_equipment) {
         qDebug() << "  E" << eq.sourceElements.size() << eq.levels << eq.type;
     }
 
     Q_EMIT update();
 }
 
 void EquipmentModel::forEach(int floorLevel, const std::function<void (OSM::Element, int)> &func) const
 {
     for (const auto &eq : m_equipment) {
         if (!eq.syntheticElement || std::find_if(eq.levels.begin(), eq.levels.end(), [floorLevel](int lvl) { return std::abs(floorLevel - lvl) < 10; }) == eq.levels.end()) {
             continue;
         }
         func(eq.syntheticElement, floorLevel);
     }
 }
 
 void EquipmentModel::hiddenElements(std::vector<OSM::Element> &elems) const
 {
     for (const auto &eq : m_equipment) {
         if (!eq.syntheticElement) {
             continue;
         }
         elems.insert(elems.end(), eq.sourceElements.begin(), eq.sourceElements.end());
     }
 }
 
 static bool isConveying(const QByteArray &b)
 {
     return b == "yes" || b == "forward" || b == "backward" || b == "reversible";
 }
 
 void EquipmentModel::findEquipment()
 {
     OSM::for_each(m_data.dataSet(), [this](OSM::Element e) {
         if (!e.hasTags()) {
             return;
         }
 
         // escalators
         const auto highway = e.tagValue(m_tagKeys.highway);
         const auto conveying = e.tagValue(m_tagKeys.conveying);
         if ((highway == "footway" || highway == "steps") && isConveying(conveying)) {
             Equipment escalator;
             escalator.type = Equipment::Escalator;
             escalator.sourceElements.push_back(e);
             LevelParser::parse(e.tagValue(m_tagKeys.level), e, [&escalator](int level, OSM::Element) {
                 escalator.levels.push_back(level);
             });
             m_equipment.push_back(std::move(escalator));
         }
 
         // elevators
         const auto building = e.tagValue(m_tagKeys.building);
         const auto buildling_part = e.tagValue(m_tagKeys.buildling_part);
         const auto elevator = e.tagValue(m_tagKeys.elevator);
         const auto indoor = e.tagValue(m_tagKeys.indoor);
         const auto room = e.tagValue(m_tagKeys.room);
         const auto stairwell = e.tagValue(m_tagKeys.stairwell);
 
         if (building == "elevator"
          || buildling_part == "elevator" || (buildling_part == "yes" && elevator == "yes")
          || highway == "elevator"
          || room == "elevator"
          || stairwell == "elevator"
          || (indoor == "room" && elevator == "yes"))
         {
             Equipment elevator;
             elevator.type = Equipment::Elevator;
             elevator.sourceElements.push_back(e);
             LevelParser::parse(e.tagValue(m_tagKeys.level), e, [&elevator](int level, OSM::Element) {
                 elevator.levels.push_back(level);
             });
             if (elevator.levels.empty()) {
                 elevator.levels.push_back(0);
             }
 
             // try to find duplicate elements on other levels
             for (auto &e : m_equipment) {
                 if (e.type != Equipment::Elevator) {
                     continue;
                 }
                 if (OSM::intersects(e.sourceElements[0].boundingBox(), elevator.sourceElements[0].boundingBox())) {
                     // TODO check for non-intersecting but present level sets?
                     qDebug() << "merging elevator elements:" << elevator.sourceElements[0].url() << e.sourceElements[0].url();
                     e.sourceElements.push_back(elevator.sourceElements[0]);
                     e.levels.insert(e.levels.end(), elevator.levels.begin(), elevator.levels.end());
                     return;
                 }
             }
 
             m_equipment.push_back(std::move(elevator));
         }
 
     }, OSM::IncludeNodes | OSM::IncludeWays);
 
     // finalize elevator merging
     for (auto &elevator : m_equipment) {
         if (elevator.type != Equipment::Elevator || elevator.sourceElements.size() < 2) {
             continue;
         }
 
         std::sort(elevator.levels.begin(), elevator.levels.end());
         elevator.levels.erase(std::unique(elevator.levels.begin(), elevator.levels.end()), elevator.levels.end());
         if (elevator.levels.size() < 2) {
             continue;
         }
 
         std::sort(elevator.sourceElements.begin(), elevator.sourceElements.end(), [](auto lhs, auto rhs) { return lhs.type() > rhs.type(); });
         createSyntheticElement(elevator);
     }
 }
 
 void EquipmentModel::createSyntheticElement(Equipment& eq) const
 {
     if (eq.syntheticElement) {
         return;
     }
 
     eq.syntheticElement = OSM::copy_element(eq.sourceElements[0]);
     eq.syntheticElement.setTagValue(m_tagKeys.mxoid, QByteArray::number((qlonglong)eq.syntheticElement.element().id()));
     eq.syntheticElement.setId(m_data.dataSet().nextInternalId());
 
     // clone tags
     for (auto it = std::next(eq.sourceElements.begin()); it != eq.sourceElements.end(); ++it) {
         for (auto tagIt = (*it).tagsBegin(); tagIt != (*it).tagsEnd(); ++tagIt) {
             if ((*tagIt).key == m_tagKeys.level) {
                 continue;
             }
 
             if (eq.syntheticElement.element().hasTag((*tagIt).key)) {
                 // ### for testing only
                 if (eq.syntheticElement.element().tagValue((*tagIt).key) != (*tagIt).value) {
                     qDebug() << "  tag value conflict:" << (*tagIt).key.name() << (*tagIt).value << eq.sourceElements[0].url() << eq.syntheticElement.element().tagValue((*tagIt).key);
                 }
                 continue;
             }
             eq.syntheticElement.setTagValue((*tagIt).key, QByteArray((*tagIt).value));
         }
     }
 
     if (eq.levels.size() > 1) {
         auto levelValue = QByteArray::number(eq.levels.at(0) / 10.0);
         for (auto it = std::next(eq.levels.begin()); it != eq.levels.end(); ++it) {
             levelValue += ';' + QByteArray::number((*it) / 10.0);
         }
         eq.syntheticElement.setTagValue(m_tagKeys.level, std::move(levelValue));
     }
 }
 
 #include "moc_equipmentmodel.cpp"