File indexing completed on 2024-11-24 04:15:37

 /*
     SPDX-FileCopyrightText: 2020 Volker Krause <vkrause@kde.org>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "boundarysearch_p.h"
 
 #include <osm/datatypes.h>
 #include <osm/element.h>
 #include <osm/geomath.h>
 
 #include <QDebug>
 
 using namespace KOSMIndoorMap;
 
 enum {
     BoundingBoxMargin = 100, // margin around the final result, in meters
     BoundingBoxMaxSize = 2000, // maximum width/height of the bounding box, in meters
 };
 
 void BoundarySearch::init(OSM::Coordinate coord)
 {
     m_center = coord;
 
     m_bbox = {coord, coord};
     m_relevantIds.clear();
 }
 
 static OSM::Id actualId(OSM::Element e, OSM::TagKey mxoidTag)
 {
     const auto mxoid = e.tagValue(mxoidTag);
     if (!mxoid.isEmpty()) {
         return mxoid.toLongLong();
     }
     return e.id();
 }
 
 static bool isPolygon(OSM::Element e)
 {
     return (e.type() == OSM::Type::Way && e.way()->isClosed())
         || (e.type() == OSM::Type::Relation && e.tagValue("type") == "multipolygon");
 }
 
 void BoundarySearch::resolveTagKeys(const OSM::DataSet& dataSet)
 {
     // cache tag keys for fast lookup
     m_tag.mxoid = dataSet.tagKey("mx:oid");
     m_tag.building = dataSet.tagKey("building");
     m_tag.railway = dataSet.tagKey("railway");
     m_tag.aeroway = dataSet.tagKey("aeroway");
     m_tag.public_transport = dataSet.tagKey("public_transport");
     m_tag.amenity = dataSet.tagKey("amenity");
     m_tag.tourism =  dataSet.tagKey("tourism");
     m_tag.leisure = dataSet.tagKey("leisure");
     m_tag.shop = dataSet.tagKey("shop");
 }
 
 bool BoundarySearch::isRelevantPolygon(const OSM::Element e) const
 {
     if (!isPolygon(e) || !OSM::contains(e.boundingBox(), m_center)) {
         return false;
     }
 
     return !e.tagValue(m_tag.amenity).isEmpty()
         || !e.tagValue(m_tag.tourism).isEmpty()
         || !e.tagValue(m_tag.leisure).isEmpty()
         || !e.tagValue(m_tag.shop).isEmpty();
 }
 
 /* There's a number of critieria being considered here:
  * - a certain minimum radius around center (see BoundingBoxMargin)
  * - an upper limit (BoundingBoxMaxSize), to avoid this growing out of control
  * - buildings, stations or airports containing the center position
  * -- for now with manual geometry re-assmbly from Marble vector tiles, ideally this will happen in a general step beforehand
  * - relevant elements (e.g. platforms or terminal buildings) in the vicinity of center (TODO)
  */
 OSM::BoundingBox BoundarySearch::boundingBox(const OSM::DataSet& dataSet)
 {
     resolveTagKeys(dataSet);
 
     if (m_relevantIds.empty()) { // first pass over the center tile
         OSM::for_each(dataSet, [this, &dataSet](OSM::Element e) {
             if (!e.boundingBox().isValid()) {
                 e.recomputeBoundingBox(dataSet);
             }
 
             const bool isRelevant = !e.tagValue(m_tag.building).isEmpty()
                 || !e.tagValue(m_tag.railway).isEmpty()
                 || !e.tagValue(m_tag.aeroway).isEmpty()
                 || isRelevantPolygon(e);
 
             if (!isRelevant) {
                 return;
             }
 
             m_relevantIds.insert(actualId(e, m_tag.mxoid));
             m_bbox = OSM::unite(m_bbox, e.boundingBox());
         }, OSM::IncludeRelations | OSM::IncludeWays);
     }
 
     OSM::BoundingBox bbox = m_bbox;
     OSM::for_each(dataSet, [&](OSM::Element e) {
         const auto railwayValue = e.tagValue(m_tag.railway);
         const bool isStation = railwayValue == "station"
             || railwayValue == "platform"
             || e.tagValue(m_tag.building) == "train_station"
             || e.tagValue(m_tag.public_transport) == "platform";
         const bool isAirport = (e.tagValue(m_tag.aeroway) == "aerodrome");
         const bool isRelevant = isRelevantPolygon(e);
         if (!isStation && !isAirport && !isRelevant) {
             return;
         }
 
         e.recomputeBoundingBox(dataSet); // unconditionally as this obviously grows as we load more data
 
         if (m_relevantIds.count(actualId(e, m_tag.mxoid))) {
             m_bbox = OSM::unite(m_bbox, e.boundingBox());
             bbox = OSM::unite(m_bbox, bbox);
         } else if (!isRelevant && OSM::intersects(e.boundingBox(), m_bbox)) {
             bbox = OSM::unite(bbox, e.boundingBox());
         }
     }, OSM::IncludeRelations | OSM::IncludeWays);
 
     return clampBoundingBox(growBoundingBox(bbox, BoundingBoxMargin), BoundingBoxMaxSize);
 }
 
 OSM::BoundingBox BoundarySearch::growBoundingBox(const OSM::BoundingBox &bbox, double meters) const
 {
     const auto dlon = meters / OSM::distance(m_center.latF(), 0.0, m_center.latF(), 1.0);
     const auto dlat = meters / OSM::distance(0.0, m_center.lonF(), 1.0, m_center.lonF());
     return OSM::BoundingBox(OSM::Coordinate(bbox.min.latF() - dlat, bbox.min.lonF() - dlon),
                             OSM::Coordinate(bbox.max.latF() + dlat, bbox.max.lonF() + dlon));
 }
 
 OSM::BoundingBox BoundarySearch::clampBoundingBox(const OSM::BoundingBox &bbox, double meters) const
 {
     // TODO don'T do this around the bbox center, but biased towards m_center
     const auto dlon = std::max(0.0, bbox.widthF() - (meters / OSM::distance(m_center.latF(), 0.0, m_center.latF(), 1.0))) / 2.0;
     const auto dlat = std::max(0.0, bbox.heightF() - (meters / OSM::distance(0.0, m_center.lonF(), 1.0, m_center.lonF()))) / 2.0;
     return OSM::BoundingBox(OSM::Coordinate(bbox.min.latF() + dlat, bbox.min.lonF() + dlon),
                             OSM::Coordinate(bbox.max.latF() - dlat, bbox.max.lonF() - dlon));
 }