maplibre_native 0.8.0

Rust bindings to the MapLibre Native map rendering engine
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

#include "maplibre_native/src/bridge.rs.h"

#include "geojson/geojson.h"
#include <mbgl/util/geojson.hpp>
#include <mbgl/util/geometry.hpp>
#include <mapbox/geojson.hpp>
#include <vector>

namespace mln {
namespace bridge {
namespace {

// Reduces a GeoJSON value (geometry / feature / feature collection) to a single
// geometry suitable for `Map::cameraForGeometry`.
mbgl::Geometry<double> toGeometry(const mbgl::GeoJSON& geojson) {
    return geojson.match(
        [](const mapbox::geojson::geometry& geometry) -> mbgl::Geometry<double> { return geometry; },
        [](const mapbox::geojson::feature& feature) -> mbgl::Geometry<double> {
            return feature.geometry;
        },
        [](const mapbox::geojson::feature_collection& features) -> mbgl::Geometry<double> {
            mapbox::geometry::geometry_collection<double> collection;
            collection.reserve(features.size());
            for (const auto& feature : features) {
                collection.push_back(feature.geometry);
            }
            return collection;
        });
}

mbgl::CameraOptions toCameraOptions(const FfiCameraOptions& camera) {
    mbgl::CameraOptions options;
    if (camera.has_center) {
        options.withCenter(mbgl::LatLng{camera.center.lat, camera.center.lng});
    }
    if (camera.has_padding) {
        options.withPadding(mbgl::EdgeInsets{
            camera.padding.top,
            camera.padding.left,
            camera.padding.bottom,
            camera.padding.right,
        });
    }
    if (camera.has_anchor) {
        options.withAnchor(camera.anchor);
    }
    if (camera.has_zoom) {
        options.withZoom(camera.zoom);
    }
    if (camera.has_bearing) {
        options.withBearing(camera.bearing);
    }
    if (camera.has_pitch) {
        options.withPitch(camera.pitch);
    }
    return options;
}

FfiCameraOptions fromCameraOptions(const mbgl::CameraOptions& options) {
    FfiCameraOptions camera{};
    if (options.center) {
        camera.has_center = true;
        camera.center = LatLng{options.center->latitude(), options.center->longitude()};
    }
    if (options.padding) {
        camera.has_padding = true;
        camera.padding = EdgeInsets{
            options.padding->top(),
            options.padding->left(),
            options.padding->bottom(),
            options.padding->right(),
        };
    }
    if (options.anchor) {
        camera.has_anchor = true;
        camera.anchor = *options.anchor;
    }
    if (options.zoom) {
        camera.has_zoom = true;
        camera.zoom = *options.zoom;
    }
    if (options.bearing) {
        camera.has_bearing = true;
        camera.bearing = *options.bearing;
    }
    if (options.pitch) {
        camera.has_pitch = true;
        camera.pitch = *options.pitch;
    }
    return camera;
}

} // namespace

FfiCameraOptions MapRenderer::cameraForLatLngBounds(const LatLngBounds& bounds,
                                                   const EdgeInsets& padding,
                                                   double bearing,
                                                   double pitch) {
    const mbgl::LatLngBounds mbglBounds = mbgl::LatLngBounds::hull(
        {bounds.southwest.lat, bounds.southwest.lng},
        {bounds.northeast.lat, bounds.northeast.lng});
    const mbgl::EdgeInsets mbglPadding{padding.top, padding.left, padding.bottom, padding.right};

    return fromCameraOptions(map->cameraForLatLngBounds(mbglBounds, mbglPadding, bearing, pitch));
}

FfiCameraOptions MapRenderer::cameraForLatLngs(rust::Slice<const LatLng> latLngs,
                                               const EdgeInsets& padding,
                                               double bearing,
                                               double pitch) {
    std::vector<mbgl::LatLng> mbglLatLngs;
    mbglLatLngs.reserve(latLngs.size());
    for (const auto& latLng : latLngs) {
        mbglLatLngs.emplace_back(latLng.lat, latLng.lng);
    }

    const mbgl::EdgeInsets mbglPadding{padding.top, padding.left, padding.bottom, padding.right};
    return fromCameraOptions(map->cameraForLatLngs(mbglLatLngs, mbglPadding, bearing, pitch));
}

FfiCameraOptions MapRenderer::cameraForGeoJson(const mln::bridge::geojson::GeoJson& geojson,
                                               const EdgeInsets& padding,
                                               double bearing,
                                               double pitch) {
    const mbgl::EdgeInsets mbglPadding{padding.top, padding.left, padding.bottom, padding.right};

    return fromCameraOptions(
        map->cameraForGeometry(toGeometry(geojson.get()), mbglPadding, bearing, pitch));
}

void MapRenderer::jumpTo(const FfiCameraOptions& cameraOptions) {
    map->jumpTo(toCameraOptions(cameraOptions));
}

} // namespace bridge
} // namespace mln