Added mapview module

sbapp/mapview/__init__.py

@@ -0,0 +1,27 @@
+# coding=utf-8
+"""
+MapView
+=======
+
+MapView is a Kivy widget that display maps.
+"""
+from mapview.source import MapSource
+from mapview.types import Bbox, Coordinate
+from mapview.view import (
+    MapLayer,
+    MapMarker,
+    MapMarkerPopup,
+    MapView,
+    MarkerMapLayer,
+)
+
+__all__ = [
+    "Coordinate",
+    "Bbox",
+    "MapView",
+    "MapSource",
+    "MapMarker",
+    "MapLayer",
+    "MarkerMapLayer",
+    "MapMarkerPopup",
+]

sbapp/mapview/_version.py

@@ -0,0 +1 @@
+__version__ = "1.0.6"

sbapp/mapview/clustered_marker_layer.py

@@ -0,0 +1,449 @@
+# coding=utf-8
+"""
+Layer that support point clustering
+===================================
+"""
+
+from math import atan, exp, floor, log, pi, sin, sqrt
+from os.path import dirname, join
+
+from kivy.lang import Builder
+from kivy.metrics import dp
+from kivy.properties import (
+    ListProperty,
+    NumericProperty,
+    ObjectProperty,
+    StringProperty,
+)
+
+from mapview.view import MapLayer, MapMarker
+
+Builder.load_string(
+    """
+<ClusterMapMarker>:
+    size_hint: None, None
+    source: root.source
+    size: list(map(dp, self.texture_size))
+    allow_stretch: True
+
+    Label:
+        color: root.text_color
+        pos: root.pos
+        size: root.size
+        text: "{}".format(root.num_points)
+        font_size: dp(18)
+"""
+)
+
+
+# longitude/latitude to spherical mercator in [0..1] range
+def lngX(lng):
+    return lng / 360.0 + 0.5
+
+
+def latY(lat):
+    if lat == 90:
+        return 0
+    if lat == -90:
+        return 1
+    s = sin(lat * pi / 180.0)
+    y = 0.5 - 0.25 * log((1 + s) / (1 - s)) / pi
+    return min(1, max(0, y))
+
+
+# spherical mercator to longitude/latitude
+def xLng(x):
+    return (x - 0.5) * 360
+
+
+def yLat(y):
+    y2 = (180 - y * 360) * pi / 180
+    return 360 * atan(exp(y2)) / pi - 90
+
+
+class KDBush:
+    """
+    kdbush implementation from:
+    https://github.com/mourner/kdbush/blob/master/src/kdbush.js
+    """
+
+    def __init__(self, points, node_size=64):
+        self.points = points
+        self.node_size = node_size
+
+        self.ids = ids = [0] * len(points)
+        self.coords = coords = [0] * len(points) * 2
+        for i, point in enumerate(points):
+            ids[i] = i
+            coords[2 * i] = point.x
+            coords[2 * i + 1] = point.y
+
+        self._sort(ids, coords, node_size, 0, len(ids) - 1, 0)
+
+    def range(self, min_x, min_y, max_x, max_y):
+        return self._range(
+            self.ids, self.coords, min_x, min_y, max_x, max_y, self.node_size
+        )
+
+    def within(self, x, y, r):
+        return self._within(self.ids, self.coords, x, y, r, self.node_size)
+
+    def _sort(self, ids, coords, node_size, left, right, depth):
+        if right - left <= node_size:
+            return
+        m = int(floor((left + right) / 2.0))
+        self._select(ids, coords, m, left, right, depth % 2)
+        self._sort(ids, coords, node_size, left, m - 1, depth + 1)
+        self._sort(ids, coords, node_size, m + 1, right, depth + 1)
+
+    def _select(self, ids, coords, k, left, right, inc):
+        swap_item = self._swap_item
+        while right > left:
+            if (right - left) > 600:
+                n = float(right - left + 1)
+                m = k - left + 1
+                z = log(n)
+                s = 0.5 + exp(2 * z / 3.0)
+                sd = 0.5 * sqrt(z * s * (n - s) / n) * (-1 if (m - n / 2.0) < 0 else 1)
+                new_left = max(left, int(floor(k - m * s / n + sd)))
+                new_right = min(right, int(floor(k + (n - m) * s / n + sd)))
+                self._select(ids, coords, k, new_left, new_right, inc)
+
+            t = coords[2 * k + inc]
+            i = left
+            j = right
+
+            swap_item(ids, coords, left, k)
+            if coords[2 * right + inc] > t:
+                swap_item(ids, coords, left, right)
+
+            while i < j:
+                swap_item(ids, coords, i, j)
+                i += 1
+                j -= 1
+                while coords[2 * i + inc] < t:
+                    i += 1
+                while coords[2 * j + inc] > t:
+                    j -= 1
+
+            if coords[2 * left + inc] == t:
+                swap_item(ids, coords, left, j)
+            else:
+                j += 1
+                swap_item(ids, coords, j, right)
+
+            if j <= k:
+                left = j + 1
+            if k <= j:
+                right = j - 1
+
+    def _swap_item(self, ids, coords, i, j):
+        swap = self._swap
+        swap(ids, i, j)
+        swap(coords, 2 * i, 2 * j)
+        swap(coords, 2 * i + 1, 2 * j + 1)
+
+    def _swap(self, arr, i, j):
+        tmp = arr[i]
+        arr[i] = arr[j]
+        arr[j] = tmp
+
+    def _range(self, ids, coords, min_x, min_y, max_x, max_y, node_size):
+        stack = [0, len(ids) - 1, 0]
+        result = []
+        x = y = 0
+
+        while stack:
+            axis = stack.pop()
+            right = stack.pop()
+            left = stack.pop()
+
+            if right - left <= node_size:
+                for i in range(left, right + 1):
+                    x = coords[2 * i]
+                    y = coords[2 * i + 1]
+                    if x >= min_x and x <= max_x and y >= min_y and y <= max_y:
+                        result.append(ids[i])
+                continue
+
+            m = int(floor((left + right) / 2.0))
+
+            x = coords[2 * m]
+            y = coords[2 * m + 1]
+
+            if x >= min_x and x <= max_x and y >= min_y and y <= max_y:
+                result.append(ids[m])
+
+            nextAxis = (axis + 1) % 2
+
+            if min_x <= x if axis == 0 else min_y <= y:
+                stack.append(left)
+                stack.append(m - 1)
+                stack.append(nextAxis)
+            if max_x >= x if axis == 0 else max_y >= y:
+                stack.append(m + 1)
+                stack.append(right)
+                stack.append(nextAxis)
+
+        return result
+
+    def _within(self, ids, coords, qx, qy, r, node_size):
+        sq_dist = self._sq_dist
+        stack = [0, len(ids) - 1, 0]
+        result = []
+        r2 = r * r
+
+        while stack:
+            axis = stack.pop()
+            right = stack.pop()
+            left = stack.pop()
+
+            if right - left <= node_size:
+                for i in range(left, right + 1):
+                    if sq_dist(coords[2 * i], coords[2 * i + 1], qx, qy) <= r2:
+                        result.append(ids[i])
+                continue
+
+            m = int(floor((left + right) / 2.0))
+
+            x = coords[2 * m]
+            y = coords[2 * m + 1]
+
+            if sq_dist(x, y, qx, qy) <= r2:
+                result.append(ids[m])
+
+            nextAxis = (axis + 1) % 2
+
+            if (qx - r <= x) if axis == 0 else (qy - r <= y):
+                stack.append(left)
+                stack.append(m - 1)
+                stack.append(nextAxis)
+            if (qx + r >= x) if axis == 0 else (qy + r >= y):
+                stack.append(m + 1)
+                stack.append(right)
+                stack.append(nextAxis)
+
+        return result
+
+    def _sq_dist(self, ax, ay, bx, by):
+        dx = ax - bx
+        dy = ay - by
+        return dx * dx + dy * dy
+
+
+class Cluster:
+    def __init__(self, x, y, num_points, id, props):
+        self.x = x
+        self.y = y
+        self.num_points = num_points
+        self.zoom = float("inf")
+        self.id = id
+        self.props = props
+        self.parent_id = None
+        self.widget = None
+
+        # preprocess lon/lat
+        self.lon = xLng(x)
+        self.lat = yLat(y)
+
+
+class Marker:
+    def __init__(self, lon, lat, cls=MapMarker, options=None):
+        self.lon = lon
+        self.lat = lat
+        self.cls = cls
+        self.options = options
+
+        # preprocess x/y from lon/lat
+        self.x = lngX(lon)
+        self.y = latY(lat)
+
+        # cluster information
+        self.id = None
+        self.zoom = float("inf")
+        self.parent_id = None
+        self.widget = None
+
+    def __repr__(self):
+        return "<Marker lon={} lat={} source={}>".format(
+            self.lon, self.lat, self.source
+        )
+
+
+class SuperCluster:
+    """Port of supercluster from mapbox in pure python
+    """
+
+    def __init__(self, min_zoom=0, max_zoom=16, radius=40, extent=512, node_size=64):
+        self.min_zoom = min_zoom
+        self.max_zoom = max_zoom
+        self.radius = radius
+        self.extent = extent
+        self.node_size = node_size
+
+    def load(self, points):
+        """Load an array of markers.
+        Once loaded, the index is immutable.
+        """
+        from time import time
+
+        self.trees = {}
+        self.points = points
+
+        for index, point in enumerate(points):
+            point.id = index
+
+        clusters = points
+        for z in range(self.max_zoom, self.min_zoom - 1, -1):
+            start = time()
+            print("build tree", z)
+            self.trees[z + 1] = KDBush(clusters, self.node_size)
+            print("kdbush", (time() - start) * 1000)
+            start = time()
+            clusters = self._cluster(clusters, z)
+            print(len(clusters))
+            print("clustering", (time() - start) * 1000)
+        self.trees[self.min_zoom] = KDBush(clusters, self.node_size)
+
+    def get_clusters(self, bbox, zoom):
+        """For the given bbox [westLng, southLat, eastLng, northLat], and
+        integer zoom, returns an array of clusters and markers
+        """
+        tree = self.trees[self._limit_zoom(zoom)]
+        ids = tree.range(lngX(bbox[0]), latY(bbox[3]), lngX(bbox[2]), latY(bbox[1]))
+        clusters = []
+        for i in range(len(ids)):
+            c = tree.points[ids[i]]
+            if isinstance(c, Cluster):
+                clusters.append(c)
+            else:
+                clusters.append(self.points[c.id])
+        return clusters
+
+    def _limit_zoom(self, z):
+        return max(self.min_zoom, min(self.max_zoom + 1, z))
+
+    def _cluster(self, points, zoom):
+        clusters = []
+        c_append = clusters.append
+        trees = self.trees
+        r = self.radius / float(self.extent * pow(2, zoom))
+
+        # loop through each point
+        for i in range(len(points)):
+            p = points[i]
+            # if we've already visited the point at this zoom level, skip it
+            if p.zoom <= zoom:
+                continue
+            p.zoom = zoom
+
+            # find all nearby points
+            tree = trees[zoom + 1]
+            neighbor_ids = tree.within(p.x, p.y, r)
+
+            num_points = 1
+            if isinstance(p, Cluster):
+                num_points = p.num_points
+            wx = p.x * num_points
+            wy = p.y * num_points
+
+            props = None
+
+            for j in range(len(neighbor_ids)):
+                b = tree.points[neighbor_ids[j]]
+                # filter out neighbors that are too far or already processed
+                if zoom < b.zoom:
+                    num_points2 = 1
+                    if isinstance(b, Cluster):
+                        num_points2 = b.num_points
+                    # save the zoom (so it doesn't get processed twice)
+                    b.zoom = zoom
+                    #  accumulate coordinates for calculating weighted center
+                    wx += b.x * num_points2
+                    wy += b.y * num_points2
+                    num_points += num_points2
+                    b.parent_id = i
+
+            if num_points == 1:
+                c_append(p)
+            else:
+                p.parent_id = i
+                c_append(
+                    Cluster(wx / num_points, wy / num_points, num_points, i, props)
+                )
+        return clusters
+
+
+class ClusterMapMarker(MapMarker):
+    source = StringProperty(join(dirname(__file__), "icons", "cluster.png"))
+    cluster = ObjectProperty()
+    num_points = NumericProperty()
+    text_color = ListProperty([0.1, 0.1, 0.1, 1])
+
+    def on_cluster(self, instance, cluster):
+        self.num_points = cluster.num_points
+
+    def on_touch_down(self, touch):
+        return False
+
+
+class ClusteredMarkerLayer(MapLayer):
+    cluster_cls = ObjectProperty(ClusterMapMarker)
+    cluster_min_zoom = NumericProperty(0)
+    cluster_max_zoom = NumericProperty(16)
+    cluster_radius = NumericProperty("40dp")
+    cluster_extent = NumericProperty(512)
+    cluster_node_size = NumericProperty(64)
+
+    def __init__(self, **kwargs):
+        self.cluster = None
+        self.cluster_markers = []
+        super().__init__(**kwargs)
+
+    def add_marker(self, lon, lat, cls=MapMarker, options=None):
+        if options is None:
+            options = {}
+        marker = Marker(lon, lat, cls, options)
+        self.cluster_markers.append(marker)
+        return marker
+
+    def remove_marker(self, marker):
+        self.cluster_markers.remove(marker)
+
+    def reposition(self):
+        if self.cluster is None:
+            self.build_cluster()
+        margin = dp(48)
+        mapview = self.parent
+        set_marker_position = self.set_marker_position
+        bbox = mapview.get_bbox(margin)
+        bbox = (bbox[1], bbox[0], bbox[3], bbox[2])
+        self.clear_widgets()
+        for point in self.cluster.get_clusters(bbox, mapview.zoom):
+            widget = point.widget
+            if widget is None:
+                widget = self.create_widget_for(point)
+            set_marker_position(mapview, widget)
+            self.add_widget(widget)
+
+    def build_cluster(self):
+        self.cluster = SuperCluster(
+            min_zoom=self.cluster_min_zoom,
+            max_zoom=self.cluster_max_zoom,
+            radius=self.cluster_radius,
+            extent=self.cluster_extent,
+            node_size=self.cluster_node_size,
+        )
+        self.cluster.load(self.cluster_markers)
+
+    def create_widget_for(self, point):
+        if isinstance(point, Marker):
+            point.widget = point.cls(lon=point.lon, lat=point.lat, **point.options)
+        elif isinstance(point, Cluster):
+            point.widget = self.cluster_cls(lon=point.lon, lat=point.lat, cluster=point)
+        return point.widget
+
+    def set_marker_position(self, mapview, marker):
+        x, y = mapview.get_window_xy_from(marker.lat, marker.lon, mapview.zoom)
+        marker.x = int(x - marker.width * marker.anchor_x)
+        marker.y = int(y - marker.height * marker.anchor_y)

sbapp/mapview/constants.py

@@ -0,0 +1,5 @@
+MIN_LATITUDE = -90.0
+MAX_LATITUDE = 90.0
+MIN_LONGITUDE = -180.0
+MAX_LONGITUDE = 180.0
+CACHE_DIR = "cache"

sbapp/mapview/downloader.py

@@ -0,0 +1,123 @@
+# coding=utf-8
+
+__all__ = ["Downloader"]
+
+import logging
+import traceback
+from concurrent.futures import ThreadPoolExecutor, TimeoutError, as_completed
+from os import environ, makedirs
+from os.path import exists, join
+from random import choice
+from time import time
+
+import requests
+from kivy.clock import Clock
+from kivy.logger import LOG_LEVELS, Logger
+
+from mapview.constants import CACHE_DIR
+
+if "MAPVIEW_DEBUG_DOWNLOADER" in environ:
+    Logger.setLevel(LOG_LEVELS['debug'])
+
+# user agent is needed because since may 2019 OSM gives me a 429 or 403 server error
+# I tried it with a simpler one (just Mozilla/5.0) this also gets rejected
+USER_AGENT = 'Kivy-garden.mapview'
+
+
+class Downloader:
+    _instance = None
+    MAX_WORKERS = 5
+    CAP_TIME = 0.064  # 15 FPS
+
+    @staticmethod
+    def instance(cache_dir=None):
+        if Downloader._instance is None:
+            if not cache_dir:
+                cache_dir = CACHE_DIR
+            Downloader._instance = Downloader(cache_dir=cache_dir)
+        return Downloader._instance
+
+    def __init__(self, max_workers=None, cap_time=None, **kwargs):
+        self.cache_dir = kwargs.get('cache_dir', CACHE_DIR)
+        if max_workers is None:
+            max_workers = Downloader.MAX_WORKERS
+        if cap_time is None:
+            cap_time = Downloader.CAP_TIME
+        self.is_paused = False
+        self.cap_time = cap_time
+        self.executor = ThreadPoolExecutor(max_workers=max_workers)
+        self._futures = []
+        Clock.schedule_interval(self._check_executor, 1 / 60.0)
+        if not exists(self.cache_dir):
+            makedirs(self.cache_dir)
+
+    def submit(self, f, *args, **kwargs):
+        future = self.executor.submit(f, *args, **kwargs)
+        self._futures.append(future)
+
+    def download_tile(self, tile):
+        Logger.debug(
+            "Downloader: queue(tile) zoom={} x={} y={}".format(
+                tile.zoom, tile.tile_x, tile.tile_y
+            )
+        )
+        future = self.executor.submit(self._load_tile, tile)
+        self._futures.append(future)
+
+    def download(self, url, callback, **kwargs):
+        Logger.debug("Downloader: queue(url) {}".format(url))
+        future = self.executor.submit(self._download_url, url, callback, kwargs)
+        self._futures.append(future)
+
+    def _download_url(self, url, callback, kwargs):
+        Logger.debug("Downloader: download(url) {}".format(url))
+        response = requests.get(url, **kwargs)
+        response.raise_for_status()
+        return callback, (url, response)
+
+    def _load_tile(self, tile):
+        if tile.state == "done":
+            return
+        cache_fn = tile.cache_fn
+        if exists(cache_fn):
+            Logger.debug("Downloader: use cache {}".format(cache_fn))
+            return tile.set_source, (cache_fn,)
+        tile_y = tile.map_source.get_row_count(tile.zoom) - tile.tile_y - 1
+        uri = tile.map_source.url.format(
+            z=tile.zoom, x=tile.tile_x, y=tile_y, s=choice(tile.map_source.subdomains)
+        )
+        Logger.debug("Downloader: download(tile) {}".format(uri))
+        response = requests.get(uri, headers={'User-agent': USER_AGENT}, timeout=5)
+        try:
+            response.raise_for_status()
+            data = response.content
+            with open(cache_fn, "wb") as fd:
+                fd.write(data)
+            Logger.debug("Downloaded {} bytes: {}".format(len(data), uri))
+            return tile.set_source, (cache_fn,)
+        except Exception as e:
+            print("Downloader error: {!r}".format(e))
+
+    def _check_executor(self, dt):
+        start = time()
+        try:
+            for future in as_completed(self._futures[:], 0):
+                self._futures.remove(future)
+                try:
+                    result = future.result()
+                except Exception:
+                    traceback.print_exc()
+                    # make an error tile?
+                    continue
+                if result is None:
+                    continue
+                callback, args = result
+                callback(*args)
+
+                # capped executor in time, in order to prevent too much
+                # slowiness.
+                # seems to works quite great with big zoom-in/out
+                if time() - start > self.cap_time:
+                    break
+        except TimeoutError:
+            pass

sbapp/mapview/geojson.py

@@ -0,0 +1,387 @@
+# coding=utf-8
+"""
+Geojson layer
+=============
+
+.. note::
+
+    Currently experimental and a work in progress, not fully optimized.
+
+
+Supports:
+
+- html color in properties
+- polygon geometry are cached and not redrawed when the parent mapview changes
+- linestring are redrawed everymove, it's ugly and slow.
+- marker are NOT supported
+
+"""
+
+__all__ = ["GeoJsonMapLayer"]
+
+import json
+
+from kivy.graphics import (
+    Canvas,
+    Color,
+    Line,
+    MatrixInstruction,
+    Mesh,
+    PopMatrix,
+    PushMatrix,
+    Scale,
+    Translate,
+)
+from kivy.graphics.tesselator import TYPE_POLYGONS, WINDING_ODD, Tesselator
+from kivy.metrics import dp
+from kivy.properties import ObjectProperty, StringProperty
+from kivy.utils import get_color_from_hex
+
+from mapview.constants import CACHE_DIR
+from mapview.downloader import Downloader
+from mapview.view import MapLayer
+
+COLORS = {
+    'aliceblue': '#f0f8ff',
+    'antiquewhite': '#faebd7',
+    'aqua': '#00ffff',
+    'aquamarine': '#7fffd4',
+    'azure': '#f0ffff',
+    'beige': '#f5f5dc',
+    'bisque': '#ffe4c4',
+    'black': '#000000',
+    'blanchedalmond': '#ffebcd',
+    'blue': '#0000ff',
+    'blueviolet': '#8a2be2',
+    'brown': '#a52a2a',
+    'burlywood': '#deb887',
+    'cadetblue': '#5f9ea0',
+    'chartreuse': '#7fff00',
+    'chocolate': '#d2691e',
+    'coral': '#ff7f50',
+    'cornflowerblue': '#6495ed',
+    'cornsilk': '#fff8dc',
+    'crimson': '#dc143c',
+    'cyan': '#00ffff',
+    'darkblue': '#00008b',
+    'darkcyan': '#008b8b',
+    'darkgoldenrod': '#b8860b',
+    'darkgray': '#a9a9a9',
+    'darkgrey': '#a9a9a9',
+    'darkgreen': '#006400',
+    'darkkhaki': '#bdb76b',
+    'darkmagenta': '#8b008b',
+    'darkolivegreen': '#556b2f',
+    'darkorange': '#ff8c00',
+    'darkorchid': '#9932cc',
+    'darkred': '#8b0000',
+    'darksalmon': '#e9967a',
+    'darkseagreen': '#8fbc8f',
+    'darkslateblue': '#483d8b',
+    'darkslategray': '#2f4f4f',
+    'darkslategrey': '#2f4f4f',
+    'darkturquoise': '#00ced1',
+    'darkviolet': '#9400d3',
+    'deeppink': '#ff1493',
+    'deepskyblue': '#00bfff',
+    'dimgray': '#696969',
+    'dimgrey': '#696969',
+    'dodgerblue': '#1e90ff',
+    'firebrick': '#b22222',
+    'floralwhite': '#fffaf0',
+    'forestgreen': '#228b22',
+    'fuchsia': '#ff00ff',
+    'gainsboro': '#dcdcdc',
+    'ghostwhite': '#f8f8ff',
+    'gold': '#ffd700',
+    'goldenrod': '#daa520',
+    'gray': '#808080',
+    'grey': '#808080',
+    'green': '#008000',
+    'greenyellow': '#adff2f',
+    'honeydew': '#f0fff0',
+    'hotpink': '#ff69b4',
+    'indianred': '#cd5c5c',
+    'indigo': '#4b0082',
+    'ivory': '#fffff0',
+    'khaki': '#f0e68c',
+    'lavender': '#e6e6fa',
+    'lavenderblush': '#fff0f5',
+    'lawngreen': '#7cfc00',
+    'lemonchiffon': '#fffacd',
+    'lightblue': '#add8e6',
+    'lightcoral': '#f08080',
+    'lightcyan': '#e0ffff',
+    'lightgoldenrodyellow': '#fafad2',
+    'lightgray': '#d3d3d3',
+    'lightgrey': '#d3d3d3',
+    'lightgreen': '#90ee90',
+    'lightpink': '#ffb6c1',
+    'lightsalmon': '#ffa07a',
+    'lightseagreen': '#20b2aa',
+    'lightskyblue': '#87cefa',
+    'lightslategray': '#778899',
+    'lightslategrey': '#778899',
+    'lightsteelblue': '#b0c4de',
+    'lightyellow': '#ffffe0',
+    'lime': '#00ff00',
+    'limegreen': '#32cd32',
+    'linen': '#faf0e6',
+    'magenta': '#ff00ff',
+    'maroon': '#800000',
+    'mediumaquamarine': '#66cdaa',
+    'mediumblue': '#0000cd',
+    'mediumorchid': '#ba55d3',
+    'mediumpurple': '#9370d8',
+    'mediumseagreen': '#3cb371',
+    'mediumslateblue': '#7b68ee',
+    'mediumspringgreen': '#00fa9a',
+    'mediumturquoise': '#48d1cc',
+    'mediumvioletred': '#c71585',
+    'midnightblue': '#191970',
+    'mintcream': '#f5fffa',
+    'mistyrose': '#ffe4e1',
+    'moccasin': '#ffe4b5',
+    'navajowhite': '#ffdead',
+    'navy': '#000080',
+    'oldlace': '#fdf5e6',
+    'olive': '#808000',
+    'olivedrab': '#6b8e23',
+    'orange': '#ffa500',
+    'orangered': '#ff4500',
+    'orchid': '#da70d6',
+    'palegoldenrod': '#eee8aa',
+    'palegreen': '#98fb98',
+    'paleturquoise': '#afeeee',
+    'palevioletred': '#d87093',
+    'papayawhip': '#ffefd5',
+    'peachpuff': '#ffdab9',
+    'peru': '#cd853f',
+    'pink': '#ffc0cb',
+    'plum': '#dda0dd',
+    'powderblue': '#b0e0e6',
+    'purple': '#800080',
+    'red': '#ff0000',
+    'rosybrown': '#bc8f8f',
+    'royalblue': '#4169e1',
+    'saddlebrown': '#8b4513',
+    'salmon': '#fa8072',
+    'sandybrown': '#f4a460',
+    'seagreen': '#2e8b57',
+    'seashell': '#fff5ee',
+    'sienna': '#a0522d',
+    'silver': '#c0c0c0',
+    'skyblue': '#87ceeb',
+    'slateblue': '#6a5acd',
+    'slategray': '#708090',
+    'slategrey': '#708090',
+    'snow': '#fffafa',
+    'springgreen': '#00ff7f',
+    'steelblue': '#4682b4',
+    'tan': '#d2b48c',
+    'teal': '#008080',
+    'thistle': '#d8bfd8',
+    'tomato': '#ff6347',
+    'turquoise': '#40e0d0',
+    'violet': '#ee82ee',
+    'wheat': '#f5deb3',
+    'white': '#ffffff',
+    'whitesmoke': '#f5f5f5',
+    'yellow': '#ffff00',
+    'yellowgreen': '#9acd32',
+}
+
+
+def flatten(lst):
+    return [item for sublist in lst for item in sublist]
+
+
+class GeoJsonMapLayer(MapLayer):
+
+    source = StringProperty()
+    geojson = ObjectProperty()
+    cache_dir = StringProperty(CACHE_DIR)
+
+    def __init__(self, **kwargs):
+        self.first_time = True
+        self.initial_zoom = None
+        super().__init__(**kwargs)
+        with self.canvas:
+            self.canvas_polygon = Canvas()
+            self.canvas_line = Canvas()
+        with self.canvas_polygon.before:
+            PushMatrix()
+            self.g_matrix = MatrixInstruction()
+            self.g_scale = Scale()
+            self.g_translate = Translate()
+        with self.canvas_polygon:
+            self.g_canvas_polygon = Canvas()
+        with self.canvas_polygon.after:
+            PopMatrix()
+
+    def reposition(self):
+        vx, vy = self.parent.delta_x, self.parent.delta_y
+        pzoom = self.parent.zoom
+        zoom = self.initial_zoom
+        if zoom is None:
+            self.initial_zoom = zoom = pzoom
+        if zoom != pzoom:
+            diff = 2 ** (pzoom - zoom)
+            vx /= diff
+            vy /= diff
+            self.g_scale.x = self.g_scale.y = diff
+        else:
+            self.g_scale.x = self.g_scale.y = 1.0
+        self.g_translate.xy = vx, vy
+        self.g_matrix.matrix = self.parent._scatter.transform
+
+        if self.geojson:
+            update = not self.first_time
+            self.on_geojson(self, self.geojson, update=update)
+            self.first_time = False
+
+    def traverse_feature(self, func, part=None):
+        """Traverse the whole geojson and call the func with every element
+        found.
+        """
+        if part is None:
+            part = self.geojson
+        if not part:
+            return
+        tp = part["type"]
+        if tp == "FeatureCollection":
+            for feature in part["features"]:
+                func(feature)
+        elif tp == "Feature":
+            func(part)
+
+    @property
+    def bounds(self):
+        # return the min lon, max lon, min lat, max lat
+        bounds = [float("inf"), float("-inf"), float("inf"), float("-inf")]
+
+        def _submit_coordinate(coord):
+            lon, lat = coord
+            bounds[0] = min(bounds[0], lon)
+            bounds[1] = max(bounds[1], lon)
+            bounds[2] = min(bounds[2], lat)
+            bounds[3] = max(bounds[3], lat)
+
+        def _get_bounds(feature):
+            geometry = feature["geometry"]
+            tp = geometry["type"]
+            if tp == "Point":
+                _submit_coordinate(geometry["coordinates"])
+            elif tp == "Polygon":
+                for coordinate in geometry["coordinates"][0]:
+                    _submit_coordinate(coordinate)
+            elif tp == "MultiPolygon":
+                for polygon in geometry["coordinates"]:
+                    for coordinate in polygon[0]:
+                        _submit_coordinate(coordinate)
+
+        self.traverse_feature(_get_bounds)
+        return bounds
+
+    @property
+    def center(self):
+        min_lon, max_lon, min_lat, max_lat = self.bounds
+        cx = (max_lon - min_lon) / 2.0
+        cy = (max_lat - min_lat) / 2.0
+        return min_lon + cx, min_lat + cy
+
+    def on_geojson(self, instance, geojson, update=False):
+        if self.parent is None:
+            return
+        if not update:
+            self.g_canvas_polygon.clear()
+            self._geojson_part(geojson, geotype="Polygon")
+        self.canvas_line.clear()
+        self._geojson_part(geojson, geotype="LineString")
+
+    def on_source(self, instance, value):
+        if value.startswith(("http://", "https://")):
+            Downloader.instance(cache_dir=self.cache_dir).download(
+                value, self._load_geojson_url
+            )
+        else:
+            with open(value, "rb") as fd:
+                geojson = json.load(fd)
+            self.geojson = geojson
+
+    def _load_geojson_url(self, url, response):
+        self.geojson = response.json()
+
+    def _geojson_part(self, part, geotype=None):
+        tp = part["type"]
+        if tp == "FeatureCollection":
+            for feature in part["features"]:
+                if geotype and feature["geometry"]["type"] != geotype:
+                    continue
+                self._geojson_part_f(feature)
+        elif tp == "Feature":
+            if geotype and part["geometry"]["type"] == geotype:
+                self._geojson_part_f(part)
+        else:
+            # unhandled geojson part
+            pass
+
+    def _geojson_part_f(self, feature):
+        properties = feature["properties"]
+        geometry = feature["geometry"]
+        graphics = self._geojson_part_geometry(geometry, properties)
+        for g in graphics:
+            tp = geometry["type"]
+            if tp == "Polygon":
+                self.g_canvas_polygon.add(g)
+            else:
+                self.canvas_line.add(g)
+
+    def _geojson_part_geometry(self, geometry, properties):
+        tp = geometry["type"]
+        self.tp = tp
+
+        graphics = []
+        if tp == "Polygon":
+            tess = Tesselator()
+            for c in geometry["coordinates"]:
+                xy = list(self._lonlat_to_xy(c))
+                xy = flatten(xy)
+                tess.add_contour(xy)
+
+            tess.tesselate(WINDING_ODD, TYPE_POLYGONS)
+
+            color = self._get_color_from(properties.get("color", "FF000088"))
+            graphics.append(Color(*color))
+            for vertices, indices in tess.meshes:
+                graphics.append(
+                    Mesh(vertices=vertices, indices=indices, mode="triangle_fan")
+                )
+
+        elif tp == "LineString":
+            stroke = get_color_from_hex(properties.get("stroke", "#ffffff"))
+            stroke_width = dp(properties.get("stroke-width"))
+            xy = list(self._lonlat_to_xy(geometry["coordinates"]))
+            xy = flatten(xy)
+            graphics.append(Color(*stroke))
+            graphics.append(Line(points=xy, width=stroke_width))
+
+        return graphics
+
+    def _lonlat_to_xy(self, lonlats):
+        view = self.parent
+        zoom = view.zoom
+        for lon, lat in lonlats:
+            p = view.get_window_xy_from(lat, lon, zoom)
+
+            # Make LineString and Polygon works at the same time
+            if self.tp == "Polygon":
+                p = p[0] - self.parent.delta_x, p[1] - self.parent.delta_y
+                p = self.parent._scatter.to_local(*p)
+
+            yield p
+
+    def _get_color_from(self, value):
+        color = COLORS.get(value.lower(), value)
+        color = get_color_from_hex(color)
+        return color

sbapp/mapview/mbtsource.py

@@ -0,0 +1,121 @@
+# coding=utf-8
+"""
+MBTiles provider for MapView
+============================
+
+This provider is based on .mbfiles from MapBox.
+See: http://mbtiles.org/
+"""
+
+__all__ = ["MBTilesMapSource"]
+
+
+import io
+import sqlite3
+import threading
+
+from kivy.core.image import Image as CoreImage
+from kivy.core.image import ImageLoader
+
+from mapview.downloader import Downloader
+from mapview.source import MapSource
+
+
+class MBTilesMapSource(MapSource):
+    def __init__(self, filename, **kwargs):
+        super().__init__(**kwargs)
+        self.filename = filename
+        self.db = sqlite3.connect(filename)
+
+        # read metadata
+        c = self.db.cursor()
+        metadata = dict(c.execute("SELECT * FROM metadata"))
+        if metadata["format"] == "pbf":
+            raise ValueError("Only raster maps are supported, not vector maps.")
+        self.min_zoom = int(metadata["minzoom"])
+        self.max_zoom = int(metadata["maxzoom"])
+        self.attribution = metadata.get("attribution", "")
+        self.bounds = bounds = None
+        cx = cy = 0.0
+        cz = 5
+        if "bounds" in metadata:
+            self.bounds = bounds = tuple(map(float, metadata["bounds"].split(",")))
+        if "center" in metadata:
+            cx, cy, cz = tuple(map(float, metadata["center"].split(",")))
+        elif self.bounds:
+            cx = (bounds[2] + bounds[0]) / 2.0
+            cy = (bounds[3] + bounds[1]) / 2.0
+            cz = self.min_zoom
+        self.default_lon = cx
+        self.default_lat = cy
+        self.default_zoom = int(cz)
+        self.projection = metadata.get("projection", "")
+        self.is_xy = self.projection == "xy"
+
+    def fill_tile(self, tile):
+        if tile.state == "done":
+            return
+        Downloader.instance(self.cache_dir).submit(self._load_tile, tile)
+
+    def _load_tile(self, tile):
+        # global db context cannot be shared across threads.
+        ctx = threading.local()
+        if not hasattr(ctx, "db"):
+            ctx.db = sqlite3.connect(self.filename)
+
+        # get the right tile
+        c = ctx.db.cursor()
+        c.execute(
+            (
+                "SELECT tile_data FROM tiles WHERE "
+                "zoom_level=? AND tile_column=? AND tile_row=?"
+            ),
+            (tile.zoom, tile.tile_x, tile.tile_y),
+        )
+        row = c.fetchone()
+        if not row:
+            tile.state = "done"
+            return
+
+        # no-file loading
+        try:
+            data = io.BytesIO(row[0])
+        except Exception:
+            # android issue, "buffer" does not have the buffer interface
+            # ie row[0] buffer is not compatible with BytesIO on Android??
+            data = io.BytesIO(bytes(row[0]))
+        im = CoreImage(
+            data,
+            ext='png',
+            filename="{}.{}.{}.png".format(tile.zoom, tile.tile_x, tile.tile_y),
+        )
+
+        if im is None:
+            tile.state = "done"
+            return
+
+        return self._load_tile_done, (tile, im,)
+
+    def _load_tile_done(self, tile, im):
+        tile.texture = im.texture
+        tile.state = "need-animation"
+
+    def get_x(self, zoom, lon):
+        if self.is_xy:
+            return lon
+        return super().get_x(zoom, lon)
+
+    def get_y(self, zoom, lat):
+        if self.is_xy:
+            return lat
+        return super().get_y(zoom, lat)
+
+    def get_lon(self, zoom, x):
+        if self.is_xy:
+            return x
+        return super().get_lon(zoom, x)
+
+    def get_lat(self, zoom, y):
+        if self.is_xy:
+            return y
+        return super().get_lat(zoom, y)

sbapp/mapview/source.py

@@ -0,0 +1,212 @@
+# coding=utf-8
+
+__all__ = ["MapSource"]
+
+import hashlib
+from math import atan, ceil, cos, exp, log, pi, tan
+
+from kivy.metrics import dp
+
+from mapview.constants import (
+    CACHE_DIR,
+    MAX_LATITUDE,
+    MAX_LONGITUDE,
+    MIN_LATITUDE,
+    MIN_LONGITUDE,
+)
+from mapview.downloader import Downloader
+from mapview.utils import clamp
+
+
+class MapSource:
+    """Base class for implementing a map source / provider
+    """
+
+    attribution_osm = 'Maps & Data © [i][ref=http://www.osm.org/copyright]OpenStreetMap contributors[/ref][/i]'
+    attribution_thunderforest = 'Maps © [i][ref=http://www.thunderforest.com]Thunderforest[/ref][/i], Data © [i][ref=http://www.osm.org/copyright]OpenStreetMap contributors[/ref][/i]'
+
+    # list of available providers
+    # cache_key: (is_overlay, minzoom, maxzoom, url, attribution)
+    providers = {
+        "osm": (
+            0,
+            0,
+            19,
+            "http://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png",
+            attribution_osm,
+        ),
+        "osm-hot": (
+            0,
+            0,
+            19,
+            "http://{s}.tile.openstreetmap.fr/hot/{z}/{x}/{y}.png",
+            "",
+        ),
+        "osm-de": (
+            0,
+            0,
+            18,
+            "http://{s}.tile.openstreetmap.de/tiles/osmde/{z}/{x}/{y}.png",
+            "Tiles @ OSM DE",
+        ),
+        "osm-fr": (
+            0,
+            0,
+            20,
+            "http://{s}.tile.openstreetmap.fr/osmfr/{z}/{x}/{y}.png",
+            "Tiles @ OSM France",
+        ),
+        "cyclemap": (
+            0,
+            0,
+            17,
+            "http://{s}.tile.opencyclemap.org/cycle/{z}/{x}/{y}.png",
+            "Tiles @ Andy Allan",
+        ),
+        "thunderforest-cycle": (
+            0,
+            0,
+            19,
+            "http://{s}.tile.thunderforest.com/cycle/{z}/{x}/{y}.png",
+            attribution_thunderforest,
+        ),
+        "thunderforest-transport": (
+            0,
+            0,
+            19,
+            "http://{s}.tile.thunderforest.com/transport/{z}/{x}/{y}.png",
+            attribution_thunderforest,
+        ),
+        "thunderforest-landscape": (
+            0,
+            0,
+            19,
+            "http://{s}.tile.thunderforest.com/landscape/{z}/{x}/{y}.png",
+            attribution_thunderforest,
+        ),
+        "thunderforest-outdoors": (
+            0,
+            0,
+            19,
+            "http://{s}.tile.thunderforest.com/outdoors/{z}/{x}/{y}.png",
+            attribution_thunderforest,
+        ),
+        # no longer available
+        # "mapquest-osm": (0, 0, 19, "http://otile{s}.mqcdn.com/tiles/1.0.0/map/{z}/{x}/{y}.jpeg", "Tiles Courtesy of Mapquest", {"subdomains": "1234", "image_ext": "jpeg"}),
+        # "mapquest-aerial": (0, 0, 19, "http://oatile{s}.mqcdn.com/tiles/1.0.0/sat/{z}/{x}/{y}.jpeg", "Tiles Courtesy of Mapquest", {"subdomains": "1234", "image_ext": "jpeg"}),
+        # more to add with
+        # https://github.com/leaflet-extras/leaflet-providers/blob/master/leaflet-providers.js
+        # not working ?
+        # "openseamap": (0, 0, 19, "http://tiles.openseamap.org/seamark/{z}/{x}/{y}.png",
+        #    "Map data @ OpenSeaMap contributors"),
+    }
+
+    def __init__(
+        self,
+        url="http://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png",
+        cache_key=None,
+        min_zoom=0,
+        max_zoom=19,
+        tile_size=256,
+        image_ext="png",
+        attribution="© OpenStreetMap contributors",
+        subdomains="abc",
+        **kwargs
+    ):
+        if cache_key is None:
+            # possible cache hit, but very unlikely
+            cache_key = hashlib.sha224(url.encode("utf8")).hexdigest()[:10]
+        self.url = url
+        self.cache_key = cache_key
+        self.min_zoom = min_zoom
+        self.max_zoom = max_zoom
+        self.tile_size = tile_size
+        self.image_ext = image_ext
+        self.attribution = attribution
+        self.subdomains = subdomains
+        self.cache_fmt = "{cache_key}_{zoom}_{tile_x}_{tile_y}.{image_ext}"
+        self.dp_tile_size = min(dp(self.tile_size), self.tile_size * 2)
+        self.default_lat = self.default_lon = self.default_zoom = None
+        self.bounds = None
+        self.cache_dir = kwargs.get('cache_dir', CACHE_DIR)
+
+    @staticmethod
+    def from_provider(key, **kwargs):
+        provider = MapSource.providers[key]
+        cache_dir = kwargs.get('cache_dir', CACHE_DIR)
+        options = {}
+        is_overlay, min_zoom, max_zoom, url, attribution = provider[:5]
+        if len(provider) > 5:
+            options = provider[5]
+        return MapSource(
+            cache_key=key,
+            min_zoom=min_zoom,
+            max_zoom=max_zoom,
+            url=url,
+            cache_dir=cache_dir,
+            attribution=attribution,
+            **options
+        )
+
+    def get_x(self, zoom, lon):
+        """Get the x position on the map using this map source's projection
+        (0, 0) is located at the top left.
+        """
+        lon = clamp(lon, MIN_LONGITUDE, MAX_LONGITUDE)
+        return ((lon + 180.0) / 360.0 * pow(2.0, zoom)) * self.dp_tile_size
+
+    def get_y(self, zoom, lat):
+        """Get the y position on the map using this map source's projection
+        (0, 0) is located at the top left.
+        """
+        lat = clamp(-lat, MIN_LATITUDE, MAX_LATITUDE)
+        lat = lat * pi / 180.0
+        return (
+            (1.0 - log(tan(lat) + 1.0 / cos(lat)) / pi) / 2.0 * pow(2.0, zoom)
+        ) * self.dp_tile_size
+
+    def get_lon(self, zoom, x):
+        """Get the longitude to the x position in the map source's projection
+        """
+        dx = x / float(self.dp_tile_size)
+        lon = dx / pow(2.0, zoom) * 360.0 - 180.0
+        return clamp(lon, MIN_LONGITUDE, MAX_LONGITUDE)
+
+    def get_lat(self, zoom, y):
+        """Get the latitude to the y position in the map source's projection
+        """
+        dy = y / float(self.dp_tile_size)
+        n = pi - 2 * pi * dy / pow(2.0, zoom)
+        lat = -180.0 / pi * atan(0.5 * (exp(n) - exp(-n)))
+        return clamp(lat, MIN_LATITUDE, MAX_LATITUDE)
+
+    def get_row_count(self, zoom):
+        """Get the number of tiles in a row at this zoom level
+        """
+        if zoom == 0:
+            return 1
+        return 2 << (zoom - 1)
+
+    def get_col_count(self, zoom):
+        """Get the number of tiles in a col at this zoom level
+        """
+        if zoom == 0:
+            return 1
+        return 2 << (zoom - 1)
+
+    def get_min_zoom(self):
+        """Return the minimum zoom of this source
+        """
+        return self.min_zoom
+
+    def get_max_zoom(self):
+        """Return the maximum zoom of this source
+        """
+        return self.max_zoom
+
+    def fill_tile(self, tile):
+        """Add this tile to load within the downloader
+        """
+        if tile.state == "done":
+            return
+        Downloader.instance(cache_dir=self.cache_dir).download_tile(tile)

sbapp/mapview/types.py

@@ -0,0 +1,29 @@
+# coding=utf-8
+
+__all__ = ["Coordinate", "Bbox"]
+
+from collections import namedtuple
+
+Coordinate = namedtuple("Coordinate", ["lat", "lon"])
+
+
+class Bbox(tuple):
+    def collide(self, *args):
+        if isinstance(args[0], Coordinate):
+            coord = args[0]
+            lat = coord.lat
+            lon = coord.lon
+        else:
+            lat, lon = args
+        lat1, lon1, lat2, lon2 = self[:]
+
+        if lat1 < lat2:
+            in_lat = lat1 <= lat <= lat2
+        else:
+            in_lat = lat2 <= lat <= lat2
+        if lon1 < lon2:
+            in_lon = lon1 <= lon <= lon2
+        else:
+            in_lon = lon2 <= lon <= lon2
+
+        return in_lat and in_lon

sbapp/mapview/utils.py

@@ -0,0 +1,50 @@
+# coding=utf-8
+
+__all__ = ["clamp", "haversine", "get_zoom_for_radius"]
+
+from math import asin, cos, pi, radians, sin, sqrt
+
+from kivy.core.window import Window
+from kivy.metrics import dp
+
+
+def clamp(x, minimum, maximum):
+    return max(minimum, min(x, maximum))
+
+
+def haversine(lon1, lat1, lon2, lat2):
+    """
+    Calculate the great circle distance between two points
+    on the earth (specified in decimal degrees)
+
+    Taken from: http://stackoverflow.com/questions/4913349/haversine-formula-in-python-bearing-and-distance-between-two-gps-points
+    """
+    # convert decimal degrees to radians
+    lon1, lat1, lon2, lat2 = map(radians, [lon1, lat1, lon2, lat2])
+    # haversine formula
+    dlon = lon2 - lon1
+    dlat = lat2 - lat1
+    a = sin(dlat / 2) ** 2 + cos(lat1) * cos(lat2) * sin(dlon / 2) ** 2
+
+    c = 2 * asin(sqrt(a))
+    km = 6367 * c
+    return km
+
+
+def get_zoom_for_radius(radius_km, lat=None, tile_size=256.0):
+    """See: https://wiki.openstreetmap.org/wiki/Zoom_levels"""
+    radius = radius_km * 1000.0
+    if lat is None:
+        lat = 0.0  # Do not compensate for the latitude
+
+    # Calculate the equatorial circumference based on the WGS-84 radius
+    earth_circumference = 2.0 * pi * 6378137.0 * cos(lat * pi / 180.0)
+
+    # Check how many tiles that are currently in view
+    nr_tiles_shown = min(Window.size) / dp(tile_size)
+
+    # Keep zooming in until we find a zoom level where the circle can fit inside the screen
+    zoom = 1
+    while earth_circumference / (2 << (zoom - 1)) * nr_tiles_shown > 2 * radius:
+        zoom += 1
+    return zoom - 1  # Go one zoom level back