geo-activity-playground 0.45.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

geo_activity_playground/webui/blueprints/explorer_blueprint.py

@@ -1,7 +1,10 @@
+import abc
 import datetime
 import io
 import itertools
 import logging
+from collections.abc import Iterable
+from typing import Union
 
 import altair as alt
 import geojson
@@ -12,8 +15,10 @@ import pandas as pd
 import sqlalchemy
 from flask import Blueprint
 from flask import flash
+from flask import json
 from flask import redirect
 from flask import render_template
+from flask import request
 from flask import Response
 from flask import url_for
 
@@ -43,6 +48,80 @@ alt.data_transformers.enable("vegafusion")
 logger = logging.getLogger(__name__)
 
 
+def blend_color(
+    base: np.ndarray, addition: Union[np.ndarray, float], opacity: float
+) -> np.ndarray:
+    return (1 - opacity) * base + opacity * addition
+
+
+class ColorStrategy(abc.ABC):
+    @abc.abstractmethod
+    def color_image(
+        self, tile_xy: tuple[int, int], grayscale: np.ndarray
+    ) -> np.ndarray:
+        pass
+
+
+class ClusterColorStrategy(ColorStrategy):
+    def __init__(self, evolution_state, tile_visits):
+        self.evolution_state = evolution_state
+        self.tile_visits = tile_visits
+        self.max_cluster_members = max(
+            evolution_state.clusters.values(),
+            key=len,
+        )
+
+    def color_image(
+        self, tile_xy: tuple[int, int], grayscale: np.ndarray
+    ) -> np.ndarray:
+        if tile_xy in self.max_cluster_members:
+            return blend_color(grayscale, np.array([[[55, 126, 184]]]) / 256, 0.3)
+        elif tile_xy in self.evolution_state.memberships:
+            return blend_color(grayscale, np.array([[[77, 175, 74]]]) / 256, 0.3)
+        elif tile_xy in self.tile_visits:
+            return blend_color(grayscale, 0.0, 0.3)
+        else:
+            return grayscale
+
+
+class VisitTimeColorStrategy(ColorStrategy):
+    def __init__(self, tile_visits, use_first=True):
+        self.tile_visits = tile_visits
+        self.use_first = use_first
+
+    def color_image(
+        self, tile_xy: tuple[int, int], grayscale: np.ndarray
+    ) -> np.ndarray:
+        if tile_xy in self.tile_visits:
+            today = datetime.date.today()
+            cmap = matplotlib.colormaps["plasma"]
+            tile_info = self.tile_visits[tile_xy]
+            relevant_time = (
+                tile_info["first_time"] if self.use_first else tile_info["last_time"]
+            )
+            last_age_days = (today - relevant_time.date()).days
+            color = cmap(max(1 - last_age_days / (2 * 365), 0.0))
+            return blend_color(grayscale, np.array([[color[:3]]]), 0.3)
+        else:
+            return grayscale
+
+
+class NumVisitsColorStrategy(ColorStrategy):
+    def __init__(self, tile_visits):
+        self.tile_visits = tile_visits
+
+    def color_image(
+        self, tile_xy: tuple[int, int], grayscale: np.ndarray
+    ) -> np.ndarray:
+        if tile_xy in self.tile_visits:
+            cmap = matplotlib.colormaps["viridis"]
+            tile_info = self.tile_visits[tile_xy]
+            color = cmap(min(len(tile_info["activity_ids"]) / 50, 1.0))
+            return blend_color(grayscale, np.array([[color[:3]]]), 0.3)
+        else:
+            return grayscale
+
+
 def make_explorer_blueprint(
     authenticator: Authenticator,
     tile_visit_accessor: TileVisitAccessor,
@@ -52,48 +131,6 @@ def make_explorer_blueprint(
 ) -> Blueprint:
     blueprint = Blueprint("explorer", __name__, template_folder="templates")
 
-    @blueprint.route("/<int:zoom>")
-    def map(zoom: int):
-        if zoom not in config_accessor().explorer_zoom_levels:
-            return {"zoom_level_not_generated": zoom}
-
-        tile_evolution_states = tile_visit_accessor.tile_state["evolution_state"]
-        tile_visits = tile_visit_accessor.tile_state["tile_visits"]
-        tile_histories = tile_visit_accessor.tile_state["tile_history"]
-
-        medians = tile_histories[zoom].median()
-        median_lat, median_lon = get_tile_upper_left_lat_lon(
-            medians["tile_x"], medians["tile_y"], zoom
-        )
-
-        explored = get_three_color_tiles(
-            tile_visits[zoom], tile_evolution_states[zoom], zoom
-        )
-
-        context = {
-            "center": {
-                "latitude": median_lat,
-                "longitude": median_lon,
-                "bbox": (
-                    bounding_box_for_biggest_cluster(
-                        tile_evolution_states[zoom].clusters.values(), zoom
-                    )
-                    if len(tile_evolution_states[zoom].memberships) > 0
-                    else {}
-                ),
-            },
-            "explored": explored,
-            "plot_tile_evolution": plot_tile_evolution(tile_histories[zoom]),
-            "plot_cluster_evolution": plot_cluster_evolution(
-                tile_evolution_states[zoom].cluster_evolution
-            ),
-            "plot_square_evolution": plot_square_evolution(
-                tile_evolution_states[zoom].square_evolution
-            ),
-            "zoom": zoom,
-        }
-        return render_template("explorer/index.html.j2", **context)
-
     @blueprint.route("/enable-zoom-level/<int:zoom>")
     @needs_authentication(authenticator)
     def enable_zoom_level(zoom: int):
@@ -164,10 +201,10 @@ def make_explorer_blueprint(
         if zoom not in config_accessor().explorer_zoom_levels:
             return {"zoom_level_not_generated": zoom}
 
-        tile_evolution_states = tile_visit_accessor.tile_state["evolution_state"]
-        tile_histories = tile_visit_accessor.tile_state["tile_history"]
+        tile_evolution_state = tile_visit_accessor.tile_state["evolution_state"][zoom]
+        tile_history = tile_visit_accessor.tile_state["tile_history"][zoom]
 
-        medians = tile_histories[zoom].median()
+        medians = tile_history.median()
         median_lat, median_lon = get_tile_upper_left_lat_lon(
             medians["tile_x"], medians["tile_y"], zoom
         )
@@ -178,182 +215,257 @@ def make_explorer_blueprint(
                 "longitude": median_lon,
                 "bbox": (
                     bounding_box_for_biggest_cluster(
-                        tile_evolution_states[zoom].clusters.values(), zoom
+                        tile_evolution_state.clusters.values(), zoom
                     )
-                    if len(tile_evolution_states[zoom].memberships) > 0
+                    if len(tile_evolution_state.memberships) > 0
                     else {}
                 ),
             },
-            "plot_tile_evolution": plot_tile_evolution(tile_histories[zoom]),
+            "plot_tile_evolution": plot_tile_evolution(tile_history),
             "plot_cluster_evolution": plot_cluster_evolution(
-                tile_evolution_states[zoom].cluster_evolution
+                tile_evolution_state.cluster_evolution
             ),
             "plot_square_evolution": plot_square_evolution(
-                tile_evolution_states[zoom].square_evolution
+                tile_evolution_state.square_evolution
             ),
             "zoom": zoom,
+            "num_tiles": len(tile_history),
+            "num_cluster_tiles": len(tile_evolution_state.memberships),
+            "square_x": tile_evolution_state.square_x,
+            "square_y": tile_evolution_state.square_y,
+            "square_size": tile_evolution_state.max_square_size,
+            "max_cluster_size": max(map(len, tile_evolution_state.clusters.values())),
         }
         return render_template("explorer/server-side.html.j2", **context)
 
     @blueprint.route("/<int:zoom>/tile/<int:z>/<int:x>/<int:y>.png")
     def tile(zoom: int, z: int, x: int, y: int) -> Response:
         tile_visits = tile_visit_accessor.tile_state["tile_visits"][zoom]
+        evolution_state = tile_visit_accessor.tile_state["evolution_state"][zoom]
 
         map_tile = np.array(tile_getter.get_tile(z, x, y)) / 255
+        grayscale = image_transforms["grayscale"].transform_image(map_tile)
+        square_line_width = 3
+        square_color = np.array([[[228, 26, 28]]]) / 256
+
+        match request.args.get("color_strategy", "cluster"):
+            case "cluster":
+                color_strategy = ClusterColorStrategy(evolution_state, tile_visits)
+            case "first":
+                color_strategy = VisitTimeColorStrategy(tile_visits, use_first=True)
+            case "last":
+                color_strategy = VisitTimeColorStrategy(tile_visits, use_first=False)
+            case "visits":
+                color_strategy = NumVisitsColorStrategy(tile_visits)
+            case _:
+                raise ValueError("Unsupported color strategy.")
+
         if z >= zoom:
             factor = 2 ** (z - zoom)
-            if (x // factor, y // factor) in tile_visits:
-                map_tile = image_transforms["color"].transform_image(map_tile)
-            else:
-                map_tile = image_transforms["color"].transform_image(map_tile) / 1.2
+            tile_x = x // factor
+            tile_y = y // factor
+            tile_xy = (tile_x, tile_y)
+            result = color_strategy.color_image(tile_xy, grayscale)
+
+            if x % factor == 0:
+                result[:, 0, :] = 0.5
+            if y % factor == 0:
+                result[0, :, :] = 0.5
+
+                if (
+                    evolution_state.square_x is not None
+                    and evolution_state.square_y is not None
+                ):
+                    if (
+                        x % factor == 0
+                        and tile_x == evolution_state.square_x
+                        and evolution_state.square_y
+                        <= tile_y
+                        < evolution_state.square_y + evolution_state.max_square_size
+                    ):
+                        result[:, 0:square_line_width] = blend_color(
+                            result[:, 0:square_line_width], square_color, 0.5
+                        )
+                    if (
+                        y % factor == 0
+                        and tile_y == evolution_state.square_y
+                        and evolution_state.square_x
+                        <= tile_x
+                        < evolution_state.square_x + evolution_state.max_square_size
+                    ):
+                        result[0:square_line_width, :] = blend_color(
+                            result[0:square_line_width, :], square_color, 0.5
+                        )
+
+                    if (
+                        (x + 1) % factor == 0
+                        and (x + 1) // factor
+                        == evolution_state.square_x + evolution_state.max_square_size
+                        and evolution_state.square_y
+                        <= tile_y
+                        < evolution_state.square_y + evolution_state.max_square_size
+                    ):
+                        result[:, -square_line_width:] = blend_color(
+                            result[:, -square_line_width:], square_color, 0.5
+                        )
+                    if (
+                        (y + 1) % factor == 0
+                        and (y + 1) // factor
+                        == evolution_state.square_y + evolution_state.max_square_size
+                        and evolution_state.square_x
+                        <= tile_x
+                        < evolution_state.square_x + evolution_state.max_square_size
+                    ):
+                        result[-square_line_width:, :] = blend_color(
+                            result[-square_line_width:, :], square_color, 0.5
+                        )
         else:
-            grayscale = image_transforms["color"].transform_image(map_tile) / 1.2
+            result = grayscale
             factor = 2 ** (zoom - z)
             width = 256 // factor
             for xo in range(factor):
                 for yo in range(factor):
-                    tile = (x * factor + xo, y * factor + yo)
-                    if tile not in tile_visits:
-                        map_tile[
+                    tile_x = x * factor + xo
+                    tile_y = y * factor + yo
+                    tile_xy = (tile_x, tile_y)
+                    if tile_xy in tile_visits:
+                        result[
                             yo * width : (yo + 1) * width, xo * width : (xo + 1) * width
-                        ] = grayscale[
-                            yo * width : (yo + 1) * width, xo * width : (xo + 1) * width
-                        ]
+                        ] = color_strategy.color_image(
+                            tile_xy,
+                            grayscale[
+                                yo * width : (yo + 1) * width,
+                                xo * width : (xo + 1) * width,
+                            ],
+                        )
+
+                        if (
+                            evolution_state.square_x is not None
+                            and evolution_state.square_y is not None
+                        ):
+                            if (
+                                tile_x == evolution_state.square_x
+                                and evolution_state.square_y
+                                <= tile_y
+                                < evolution_state.square_y
+                                + evolution_state.max_square_size
+                            ):
+                                result[
+                                    yo * width : (yo + 1) * width,
+                                    xo * width : xo * width + square_line_width,
+                                ] = blend_color(
+                                    result[
+                                        yo * width : (yo + 1) * width,
+                                        xo * width : xo * width + square_line_width,
+                                    ],
+                                    square_color,
+                                    0.5,
+                                )
+                            if (
+                                tile_y == evolution_state.square_y
+                                and evolution_state.square_x
+                                <= tile_x
+                                < evolution_state.square_x
+                                + evolution_state.max_square_size
+                            ):
+                                result[
+                                    yo * width : yo * width + square_line_width,
+                                    xo * width : (xo + 1) * width,
+                                ] = blend_color(
+                                    result[
+                                        yo * width : yo * width + square_line_width,
+                                        xo * width : (xo + 1) * width,
+                                    ],
+                                    square_color,
+                                    0.5,
+                                )
+
+                            if (
+                                tile_x + 1
+                                == evolution_state.square_x
+                                + evolution_state.max_square_size
+                                and evolution_state.square_y
+                                <= tile_y
+                                < evolution_state.square_y
+                                + evolution_state.max_square_size
+                            ):
+                                result[
+                                    yo * width : (yo + 1) * width,
+                                    (xo + 1) * width
+                                    - square_line_width : (xo + 1) * width,
+                                ] = blend_color(
+                                    result[
+                                        yo * width : (yo + 1) * width,
+                                        (xo + 1) * width
+                                        - square_line_width : (xo + 1) * width,
+                                    ],
+                                    square_color,
+                                    0.5,
+                                )
+
+                            if (
+                                tile_y + 1
+                                == evolution_state.square_y
+                                + evolution_state.max_square_size
+                                and evolution_state.square_x
+                                <= tile_x
+                                < evolution_state.square_x
+                                + evolution_state.max_square_size
+                            ):
+                                result[
+                                    (yo + 1) * width
+                                    - square_line_width : (yo + 1) * width,
+                                    xo * width : (xo + 1) * width,
+                                ] = blend_color(
+                                    result[
+                                        (yo + 1) * width
+                                        - square_line_width : (yo + 1) * width,
+                                        xo * width : (xo + 1) * width,
+                                    ],
+                                    square_color,
+                                    0.5,
+                                )
+                    if width >= 64:
+                        result[yo * width, :, :] = 0.5
+                        result[:, xo * width, :] = 0.5
         f = io.BytesIO()
-        pl.imsave(f, map_tile, format="png")
+        pl.imsave(f, result, format="png")
         return Response(bytes(f.getbuffer()), mimetype="image/png")
 
-    return blueprint
-
-
-def get_three_color_tiles(
-    tile_visits: dict,
-    cluster_state: TileEvolutionState,
-    zoom: int,
-) -> str:
-    logger.info("Generate data for explorer tile map …")
-    today = datetime.date.today()
-    cmap_first = matplotlib.colormaps["plasma"]
-    cmap_last = matplotlib.colormaps["plasma"]
-    tile_dict = {}
-    for tile, tile_data in tile_visits.items():
-        if not pd.isna(tile_data["first_time"]):
-            first_age_days = (today - tile_data["first_time"].date()).days
-            last_age_days = (today - tile_data["last_time"].date()).days
+    @blueprint.route("/<int:zoom>/info/<float:latitude>/<float:longitude>")
+    def info(zoom: int, latitude: float, longitude: float) -> dict:
+        tile_visits = tile_visit_accessor.tile_state["tile_visits"][zoom]
+        evolution_state = tile_visit_accessor.tile_state["evolution_state"][zoom]
+        tile_xy = compute_tile(latitude, longitude, zoom)
+        if tile_xy in tile_visits:
+            tile_info = tile_visits[tile_xy]
+            first = DB.session.get_one(Activity, tile_info["first_id"])
+            last = DB.session.get_one(Activity, tile_info["last_id"])
+            result = {
+                "tile_xy": f"{tile_xy}",
+                "num_visits": len(tile_info["activity_ids"]),
+                "first_activity_id": first.id,
+                "first_activity_name": first.name,
+                "first_time": tile_info["first_time"].isoformat(),
+                "last_activity_id": last.id,
+                "last_activity_name": last.name,
+                "last_time": tile_info["last_time"].isoformat(),
+                "is_cluster": tile_xy in evolution_state.memberships,
+                "this_cluster_size": len(
+                    evolution_state.clusters.get(
+                        evolution_state.memberships.get(tile_xy, None), []
+                    )
+                ),
+            }
         else:
-            first_age_days = 10000
-            last_age_days = 10000
-        tile_dict[tile] = {
-            "first_activity_id": str(tile_data["first_id"]),
-            "first_activity_name": DB.session.scalar(
-                sqlalchemy.select(Activity.name).where(
-                    Activity.id == tile_data["first_id"]
-                )
-            ),
-            "last_activity_id": str(tile_data["last_id"]),
-            "last_activity_name": DB.session.scalar(
-                sqlalchemy.select(Activity.name).where(
-                    Activity.id == tile_data["last_id"]
-                )
-            ),
-            "first_age_days": first_age_days,
-            "first_age_color": matplotlib.colors.to_hex(
-                cmap_first(max(1 - first_age_days / (2 * 365), 0.0))
-            ),
-            "last_age_days": last_age_days,
-            "last_age_color": matplotlib.colors.to_hex(
-                cmap_last(max(1 - last_age_days / (2 * 365), 0.0))
-            ),
-            "cluster": False,
-            "color": "#303030",
-            "first_visit": tile_data["first_time"].date().isoformat(),
-            "last_visit": tile_data["last_time"].date().isoformat(),
-            "num_visits": len(tile_data["activity_ids"]),
-            "square": False,
-            "tile": f"({zoom}, {tile[0]}, {tile[1]})",
-        }
+            result = {}
+        return result
 
-    # Mark biggest square.
-    if cluster_state.max_square_size:
-        for x in range(
-            cluster_state.square_x,
-            cluster_state.square_x + cluster_state.max_square_size,
-        ):
-            for y in range(
-                cluster_state.square_y,
-                cluster_state.square_y + cluster_state.max_square_size,
-            ):
-                tile_dict[(x, y)]["square"] = True
-
-    # Add cluster information.
-    for members in cluster_state.clusters.values():
-        for member in members:
-            tile_dict[member]["this_cluster_size"] = len(members)
-            tile_dict[member]["cluster"] = True
-    if len(cluster_state.cluster_evolution) > 0:
-        max_cluster_size = cluster_state.cluster_evolution["max_cluster_size"].iloc[-1]
-    else:
-        max_cluster_size = 0
-    num_cluster_tiles = len(cluster_state.memberships)
-
-    # Apply cluster colors.
-    cluster_cmap = matplotlib.colormaps["tab10"]
-    for color, members in zip(
-        itertools.cycle(map(cluster_cmap, [0, 1, 2, 3, 4, 5, 6, 8, 9])),
-        sorted(
-            cluster_state.clusters.values(),
-            key=lambda members: len(members),
-            reverse=True,
-        ),
-    ):
-        hex_color = matplotlib.colors.to_hex(color)
-        for member in members:
-            tile_dict[member]["color"] = hex_color
-
-    if cluster_state.max_square_size:
-        square_geojson = geojson.dumps(
-            geojson.FeatureCollection(
-                features=[
-                    make_explorer_rectangle(
-                        cluster_state.square_x,
-                        cluster_state.square_y,
-                        cluster_state.square_x + cluster_state.max_square_size,
-                        cluster_state.square_y + cluster_state.max_square_size,
-                        zoom,
-                    )
-                ]
-            )
-        )
-    else:
-        square_geojson = "{}"
-
-    try:
-        feature_collection = geojson.FeatureCollection(
-            features=[
-                make_explorer_tile(x, y, v, zoom) for (x, y), v in tile_dict.items()
-            ]
-        )
-        explored_geojson = geojson.dumps(feature_collection)
-    except TypeError as e:
-        logger.error(f"Encountered TypeError while building GeoJSON: {e=}")
-        logger.error(f"{tile_dict = }")
-        raise
-
-    result = {
-        "explored_geojson": explored_geojson,
-        "max_cluster_size": max_cluster_size,
-        "num_cluster_tiles": num_cluster_tiles,
-        "num_tiles": len(tile_dict),
-        "square_size": cluster_state.max_square_size,
-        "square_x": cluster_state.square_x,
-        "square_y": cluster_state.square_y,
-        "square_geojson": square_geojson,
-    }
-    return result
+    return blueprint
 
 
 def bounding_box_for_biggest_cluster(
-    clusters: list[list[tuple[int, int]]], zoom: int
+    clusters: Iterable[list[tuple[int, int]]], zoom: int
 ) -> str:
     biggest_cluster = max(clusters, key=lambda members: len(members))
     min_x = min(x for x, y in biggest_cluster)

geo_activity_playground/webui/blueprints/export_blueprint.py

@@ -0,0 +1,30 @@
+from flask import Blueprint
+from flask import render_template
+from flask import request
+from flask import Response
+
+from ...core.export import export_all
+from ..authenticator import Authenticator
+from ..authenticator import needs_authentication
+
+
+def make_export_blueprint(authenticator: Authenticator) -> Blueprint:
+    blueprint = Blueprint("export", __name__, template_folder="templates")
+
+    @needs_authentication(authenticator)
+    @blueprint.route("/")
+    def index():
+        return render_template("export/index.html.j2")
+
+    @needs_authentication(authenticator)
+    @blueprint.route("/export")
+    def export():
+        meta_format = request.args["meta_format"]
+        activity_format = request.args["activity_format"]
+        return Response(
+            bytes(export_all(meta_format, activity_format)),
+            mimetype="application/zip",
+            headers={"Content-disposition": 'attachment; filename="export.zip"'},
+        )
+
+    return blueprint

geo_activity_playground/webui/blueprints/upload_blueprint.py

@@ -25,6 +25,8 @@ from ...importers.strava_api import import_from_strava_api
 from ...importers.strava_checkout import import_from_strava_checkout
 from ..authenticator import Authenticator
 from ..authenticator import needs_authentication
+from ..flasher import Flasher
+from ..flasher import FlashTypes
 
 
 def make_upload_blueprint(
@@ -32,6 +34,7 @@ def make_upload_blueprint(
     tile_visit_accessor: TileVisitAccessor,
     config: Config,
     authenticator: Authenticator,
+    flasher: Flasher,
 ) -> Blueprint:
     blueprint = Blueprint("upload", __name__, template_folder="templates")
 
@@ -72,6 +75,12 @@ def make_upload_blueprint(
                 ".tcx",
             ]
             assert target_path.is_relative_to("Activities")
+            if target_path.exists():
+                flasher.flash_message(
+                    f"An activity with path '{target_path}' already exists. Rename the file and try again.",
+                    FlashTypes.DANGER,
+                )
+                return redirect(url_for(".index"))
             file.save(target_path)
             scan_for_activities(
                 repository,

geo_activity_playground/webui/static/server-side-explorer.js

@@ -0,0 +1,55 @@
+
+let tile_layer = null
+
+function changeColor(method) {
+    if (tile_layer) {
+        map.removeLayer(tile_layer)
+    }
+    tile_layer = L.tileLayer(`/explorer/${zoom}/tile/{z}/{x}/{y}.png?color_strategy=${method}`, {
+        maxZoom: 19,
+        attribution: map_tile_attribution
+    }).addTo(map)
+}
+
+let map = L.map('explorer-map', {
+    fullscreenControl: true,
+    center: [center_latitude, center_longitude],
+    zoom: 12
+});
+
+changeColor('cluster')
+
+if (bbox) {
+    map.fitBounds(L.geoJSON(bbox).getBounds())
+}
+
+map.on('click', e => {
+    fetch(`/explorer/${zoom}/info/${e.latlng.lat}/${e.latlng.lng}`)
+        .then(response => response.json())
+        .then(data => {
+            if (!data.tile_xy) {
+                return;
+            }
+            console.debug(data);
+
+            let lines = [
+                `<dt>Tile</dt>`,
+                `<dd>${data.tile_xy}</dd>`,
+                `<dt>First visit</dt>`,
+                `<dd>${data.first_time}</br><a href=/activity/${data.first_activity_id}>${data.first_activity_name}</a></dd>`,
+                `<dt>Last visit</dt>`,
+                `<dd>${data.last_time}</br><a href=/activity/${data.last_activity_id}>${data.last_activity_name}</a></dd>`,
+                `<dt>Number of visits</dt>`,
+                `<dd>${data.num_visits}</dd>`,
+            ]
+            if (data.this_cluster_size) {
+                lines.push(`<dt>This cluster size</dt><dd>${data.this_cluster_size}</dd>`)
+            }
+
+            L.popup()
+                .setLatLng(e.latlng)
+                .setContent('<dl>' + lines.join('') + '</dl>')
+                .openOn(map);
+        }
+        );
+});