Cppcheck report - [project name]: kooling/component/osm/overpass.cpp

#include <kooling/component/osm/interface.h>
#include <kooling/http/http.h>
#include <kooling/geo/coordinate.h>
#include <kooling/geo/geometry.h>
#include <kooling/geo/algorithm.h>
#include <kooling/geo/bounding-box.h>
#include <kooling/json/json.h>

#include <plog/Log.h>

#include <boost/algorithm/string/trim_all.hpp>
#include <boost/container_hash/hash.hpp>
#include <boost/range/algorithm/copy.hpp>
#include <boost/range/iterator_range_core.hpp>
#include <boost/format.hpp>

#include <cmath>
#include <string>

namespace kooling::component::osm {

class overpass : public interface
{
    struct ctor_tag {};

public:
    using coordinate_t = kooling::geo::coordinate;
    using distance_t   = kooling::datamodel::distance;

    explicit overpass(ctor_tag, const json_t&);

    ~overpass() override = default;

    static interface::pointer_type create(const json_t& config)
    {
        return std::make_unique<overpass>(ctor_tag{}, config);
    }

    static std::string name()
    {
        return "overpass";
    }

    interface::rail_station_features check_rail_stations(const bounding_box_t&) const override;
    interface::rail_way_features     check_rail_ways(const bounding_box_t&) const override;

    int near_bus_stop(const std::vector<coordinate_t>& points, const distance_t& max_distance, int enough) const override;
    double near_bus_route(const std::vector<coordinate_t>& dps, const std::vector<coordinate_t>& interpolated, const distance_t& max_distance, double enough_pct) const override;

private:
    kooling::geo::multi_line_string bus_routes(const bounding_box_t&) const;
    kooling::geo::multi_point bus_stops(const bounding_box_t&) const;

    json_t send(std::string) const;
    const std::string d_url;
    const distance_t d_bbox_max_diag;
};

static bool registered{ factory().register_component<overpass>() };

overpass::overpass(ctor_tag, const json_t& config)
    : d_url{ config["url"] }
    , d_bbox_max_diag{ distance_t::from_km(config["bbox_max_diag_km"]) }
{}

json_t overpass::send(std::string query) const
{
    boost::algorithm::trim_all(query);

    PLOG_VERBOSE
        << "overpass url: https://overpass-turbo.eu/?R&Q="
        << kooling::http::url_encode(query);

    std::string result;
    const auto write{ [&query](std::string& out) { out = query; } };
    const auto read{ [&result](std::string&& in) { result = std::move(in); } };
    const bool ok{ kooling::http::send(
            kooling::http::post{},
            d_url,
            { { "content-type", "application/x-www-form-urlencoded" } },
            write,
            read) };
    if (!ok)
    {
        PLOG_ERROR << "OSM error: " << result;
        return json_t::value_t::discarded;
    }

    PLOG_VERBOSE << "overpass <- : " << result;
    const auto value = json_t::parse(result, nullptr, false);
    if (value.is_discarded())
    {
        PLOG_ERROR << "OSM error: " << result;
    }
    return value;
}

interface::rail_station_features overpass::check_rail_stations(const bounding_box_t& bbox) const
{
    constexpr auto query{ R"(
        [out:json][bbox:%|1$.7f|, %|2$.7f|, %|3$.7f|, %|4$.7f|];
        (
            node[railway=subway_entrance](%|1$.7f|, %|2$.7f|, %|3$.7f|, %|4$.7f|);
            node[railway=station](%|1$.7f|, %|2$.7f|, %|3$.7f|, %|4$.7f|);
            node[railway=train_station_entrance](%|1$.7f|, %|2$.7f|, %|3$.7f|, %|4$.7f|);
            node[railway=stop](%|1$.7f|, %|2$.7f|, %|3$.7f|, %|4$.7f|);
            node[railway=tram_stop](%|1$.7f|, %|2$.7f|, %|3$.7f|, %|4$.7f|);
        );
        out body qt;
    )" };

    const auto fmt{ boost::format(query) % bbox.min.lat() % bbox.min.lon() % bbox.max.lat() % bbox.max.lon() };
    const json_t out = send(str(fmt));
    if (out.is_discarded())
    {
        return {};
    }

    PLOG_VERBOSE << "osm gather begin";

    interface::rail_station_features features;
    // TODO - reserve the vectors based on out["elements"].size() ?
    for (const auto& elem : out["elements"])
    {
        if (elem["type"] == "node")
        {
            if (elem.contains("tags"))
            {
                const coordinate_t coord{ elem["lat"], elem["lon"] };
                const auto& tags{ elem["tags"] };
                if (const auto it{ tags.find("railway") }; it != tags.end())
                {
                    if (*it == "station")
                    {
                        const auto& station{ tags.value("station", "train") };
                        if (station == "subway")
                        {
                            features.subway.points.push_back(coord);
                        }
                        else if (station == "train" || station == "light_rail")
                        {
                            features.train.points.push_back(coord);
                        }
                    }
                    else if (*it == "subway_entrance")
                    {
                        features.subway.points.push_back(coord);
                    }
                    else if (*it == "tram_stop")
                    {
                        features.tram.points.push_back(coord);
                    }
                    else if (*it == "train_station_entrance" || *it == "stop")
                    {
                        features.train.points.push_back(coord);
                    }
                }
            }
        }
    }

    PLOG_VERBOSE << "osm gather end";
    return features;
}

interface::rail_way_features overpass::check_rail_ways(const bounding_box_t& bbox) const
{
    constexpr auto query{ R"(
        [out:json][bbox:%|1$.7f|, %|2$.7f|, %|3$.7f|, %|4$.7f|];
        (
            way[railway=rail](%|1$.7f|, %|2$.7f|, %|3$.7f|, %|4$.7f|);
            way[railway=subway](%|1$.7f|, %|2$.7f|, %|3$.7f|, %|4$.7f|);
            way[railway=tram](%|1$.7f|, %|2$.7f|, %|3$.7f|, %|4$.7f|);
            way[railway=light_rail](%|1$.7f|, %|2$.7f|, %|3$.7f|, %|4$.7f|);
        );
        out body qt; >; out skel;
    )" };

    const auto fmt{ boost::format(query) % bbox.min.lat() % bbox.min.lon() % bbox.max.lat() % bbox.max.lon() };
    const json_t out = send(str(fmt));
    if (out.is_discarded())
    {
        return {};
    }

    PLOG_VERBOSE << "osm gather begin";

    interface::rail_way_features features;
    std::unordered_map<uint64_t, kooling::geo::multi_line_string*> node_to_multi_line_string;
    auto gather_nodes{ [&node_to_multi_line_string](const json_t& elem, kooling::geo::multi_line_string& mls)
    {
        if (elem.contains("nodes"))
        {
            const auto& nodes{ elem["nodes"] };
            for (const auto& node : nodes)
            {
                node_to_multi_line_string.emplace(node.get<uint64_t>(), &mls);
            }

            const auto curr_idx{ mls.is_start.size() };
            const auto new_size{ mls.is_start.size() + nodes.size() };
            mls.points.reserve(new_size);
            mls.is_start.resize(new_size, false);
            mls.is_end.  resize(new_size, false);
            mls.is_start[curr_idx] = true;
            mls.is_end.back() = true;
        }
        else
        {
            PLOG_WARNING << "way doesn't contain nodes: " << elem;
        }
    } };
    for (const auto& elem : out["elements"])
    {
        if (elem["type"] == "way")
        {
            if (elem.contains("tags"))
            {
                const auto& tags{ elem["tags"] };
                if (const auto it{ tags.find("railway") }; it != tags.end())
                {
                    if (*it == "rail" || *it == "light_rail")
                    {
                        gather_nodes(elem, features.train);
                    }
                    else if (*it == "subway")
                    {
                        gather_nodes(elem, features.subway);
                    }
                    else if (*it == "tram")
                    {
                        gather_nodes(elem, features.tram);
                    }
                }
            }
            else
            {
                PLOG_WARNING << "way doesn't contain tags: " << elem;
            }
        }
        else if (elem["type"] == "node")
        {
            const uint64_t id{ elem["id"] };
            if (const auto it{ node_to_multi_line_string.find(id) }; it != node_to_multi_line_string.end())
            {
                it->second->points.push_back(coordinate_t{ elem["lat"], elem["lon"] });
            }
        }
    }

    PLOG_VERBOSE << "osm gather end";
    return features;
}

kooling::geo::multi_line_string overpass::bus_routes(const bounding_box_t& bbox) const
{
    constexpr auto query{ R"(
        [out:json][bbox:%|1$.7f|, %|2$.7f|, %|3$.7f|, %|4$.7f|];
        rel[type=route][route=bus](%|1$.7f|, %|2$.7f|, %|3$.7f|, %|4$.7f|)->.all_rels;
        way(r.all_rels)->.all_ways;
        way.all_ways(%|1$.7f|, %|2$.7f|, %|3$.7f|, %|4$.7f|)->.ways_inside;
        node(w.ways_inside)->.nodes_inside;
        .ways_inside; out skel;
        .nodes_inside; out skel;
    )" };

    const auto fmt{ boost::format(query) % bbox.min.lat() % bbox.min.lon() % bbox.max.lat() % bbox.max.lon() };
    const json_t out = send(str(fmt));
    if (out.is_discarded())
    {
        return {};
    }

    PLOG_VERBOSE << "osm gather begin";

    std::vector<std::vector<uint64_t>> ways;
    std::unordered_map<uint64_t, coordinate_t> id_to_nodes;
    for (const auto& elem : out["elements"])
    {
        const std::string& type{ elem["type"] };
        if (type == "way")
        {
            const auto& nodes{ elem["nodes"] };
            auto& way{ ways.emplace_back() };
            way.reserve(elem.size());
            boost::copy(nodes, std::back_inserter(way));
        }
        else if (type == "node")
        {
            id_to_nodes.emplace(elem["id"], coordinate_t{ elem["lat"], elem["lon"] });
        }
    }

    kooling::geo::multi_line_string multi_line;
    multi_line.reserve(id_to_nodes.size());

    for (const auto& way : ways)
    {
        for (const auto& node_id : way)
        {
            multi_line.points.push_back(id_to_nodes[node_id]);
        }
        const auto start{ multi_line.is_start.size() };
        multi_line.is_start.insert(multi_line.is_start.end(), way.size(), false);
        multi_line.is_end  .insert(multi_line.is_end  .end(), way.size(), false);
        multi_line.is_start[start] = true;
        multi_line.is_end.back() = true;
    }

    PLOG_VERBOSE << "osm gather end";
    return multi_line;
}

kooling::geo::multi_point overpass::bus_stops(const bounding_box_t& bbox) const
{
    constexpr auto query{ R"(
        [out:json][bbox:%|1$.7f|, %|2$.7f|, %|3$.7f|, %|4$.7f|];
        node[highway=bus_stop](%|1$.7f|, %|2$.7f|, %|3$.7f|, %|4$.7f|);
        out skel;
    )" };

    const auto fmt{ boost::format(query) % bbox.min.lat() % bbox.min.lon() % bbox.max.lat() % bbox.max.lon() };
    const json_t out = send(str(fmt));
    if (out.is_discarded())
    {
        return {};
    }

    PLOG_VERBOSE << "osm gather begin";

    const auto& elems{ out["elements"] };
    kooling::geo::multi_point points;
    points.points.reserve(elems.size());
    for (const auto& elem : elems)
    {
        if (elem["type"] == "node")
        {
            points.points.emplace_back(elem["lat"], elem["lon"]);
        }
    }

    PLOG_VERBOSE << "osm gather end";
    return points;
}

int overpass::near_bus_stop(const std::vector<coordinate_t>& points, const distance_t& max_distance, int enough) const
{
    const auto range{ boost::make_iterator_range(points) };
    const auto bboxes{ kooling::geo::make_bounding_box(range, d_bbox_max_diag) };

    kooling::geo::multi_point stops;
    for (const auto& bbox : bboxes)
    {
        stops += bus_stops(add_border(bbox, max_distance));<--- Consider using std::accumulate algorithm instead of a raw loop.
    }

    return kooling::geo::near(stops, points, max_distance, enough).points.size();
}

double overpass::near_bus_route(const std::vector<coordinate_t>& dps, const std::vector<coordinate_t>& interpolated, const distance_t& max_distance, double enough_pct) const
{
    const auto range{ boost::make_iterator_range(dps) };
    const auto bboxes{ kooling::geo::make_bounding_box(range, d_bbox_max_diag) };

    kooling::geo::multi_line_string routes;
    for (const auto& bbox : bboxes)
    {
        routes += bus_routes(add_border(bbox, max_distance));<--- Consider using std::accumulate algorithm instead of a raw loop.
    }

    const auto check_points{
        [&routes, &max_distance, &enough_pct](const std::vector<coordinate_t>& points)
        {
            const auto required{ std::ceil(points.size() * enough_pct / 100.) };
            const auto found{ kooling::geo::near(routes, points, max_distance, required).points.size() };
            return 1. * found / points.size();
        } };

    if (const auto pct{ check_points(dps) }; pct >= enough_pct / 100.)
    {
        return pct;
    }
    return check_points(interpolated);
}

} // namespace kooling::component::osm