Generating_maps.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Generating maps",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3FH8VHXPbLKT"
      },
      "outputs": [],
      "source": [
        "#REQUIREMENTS\n",
        "! pip install ipyleaflet\n",
        "! pip install bs4\n",
        "! pip install requests\n",
        "! pip install shapely"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#IMPORTING LIBRARIES\n",
        "from ipyleaflet import Map, basemaps, AntPath,  Heatmap, LayersControl, basemap_to_tiles, TileLayer, Marker, MarkerCluster, VectorTileLayer, SearchControl, AwesomeIcon, WKTLayer, WidgetControl, LayerGroup, SplitMapControl, DrawControl\n",
        "from ipywidgets import HTML\n",
        "from bs4 import BeautifulSoup\n",
        "import requests"
      ],
      "metadata": {
        "id": "ixUyLNh-b_wE"
      },
      "execution_count": 131,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class CustomWKTLayer(WKTLayer):\n",
        "    \"\"\"Modified from the original WKT Class (https://ipyleaflet.readthedocs.io/en/latest/_modules/ipyleaflet/leaflet.html#WKTLayer)\n",
        "\n",
        "    Layer created from a local WKT file or WKT string input.\n",
        "\n",
        "    Attributes\n",
        "    ----------\n",
        "    path: string, default \"\"\n",
        "      file path of local WKT file.\n",
        "    wkt_string: string, default \"\"\n",
        "      WKT string.\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, annotation, **kwargs):\n",
        "        super().__init__(**kwargs)\n",
        "        self.data = self._get_data1(annotation)\n",
        "\n",
        "    def _get_data1(self,annotation):\n",
        "        try:\n",
        "            from shapely import geometry, wkt\n",
        "        except ImportError:\n",
        "            raise RuntimeError(\"The WKTLayer needs shapely to be installed, please run `pip install shapely`\")\n",
        "\n",
        "        if self.path:\n",
        "            with open(self.path) as f:\n",
        "                parsed_wkt = wkt.load(f)\n",
        "        elif self.wkt_string:\n",
        "            parsed_wkt = wkt.loads(self.wkt_string)\n",
        "        else:\n",
        "            raise ValueError(\"Please provide either WKT file path or WKT string\")\n",
        "\n",
        "        geo = geometry.mapping(parsed_wkt)\n",
        "        if geo[\"type\"] == \"GeometryCollection\":\n",
        "            features = [{\"geometry\": g, \"properties\": annotation, \"type\": \"Feature\"} for g in geo[\"geometries\"]]\n",
        "            feature_collection = {\"type\": \"FeatureCollection\", \"features\": features}\n",
        "            return feature_collection\n",
        "        else:\n",
        "            feature = {\"geometry\": geo, \"properties\": annotation, \"type\": \"Feature\"}\n",
        "            return feature\n"
      ],
      "metadata": {
        "id": "yZbNrsQnfpfr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class Build_Map(object):\n",
        "\n",
        "    \"\"\" Build a flatmap into jupyter notebbook using URL's from the SPARC research community. \n",
        "\n",
        "    Attributes\n",
        "    ----------\n",
        "    server_url: string, default \"\"\n",
        "      Server URL containing the flatmap \n",
        "    tag: string, default 0\n",
        "      Tag given to a model (0-11)\n",
        "      0: 'vagus_test',\n",
        "      1: 'whole-human',\n",
        "      2: 'whole-rat',\n",
        "      3: 'whole-pig',\n",
        "      4: 'whole-rat',\n",
        "      5: 'whole-rat',\n",
        "      6: 'whole-rat',\n",
        "      7: 'whole-rat',\n",
        "      8: 'whole-mouse',\n",
        "      9: 'whole-cat',\n",
        "      10: 'whole-human',\n",
        "      11: 'whole-rat'])  \n",
        "    \"\"\"\n",
        "  \n",
        "  def __init__(self, server_url, tag):\n",
        "    self.server_url = server_url\n",
        "    self.tag = tag\n",
        "\n",
        "  def get_url_dict(self):\n",
        "    try:\n",
        "        req= requests.get(self.server_url)\n",
        "        url_dict = req.json()\n",
        "        return url_dict\n",
        "    except NameError:\n",
        "        raise RuntimeError(\"Please provide a flatmap URL\")\n",
        "\n",
        "  def get_model_id(self):\n",
        "    '''\n",
        "    Returns a list of model ids\n",
        "    '''\n",
        "    return [model_dict['id'] for model_dict in self.get_url_dict() if 'name' in model_dict.keys() and 'id' in model_dict.keys()]\n",
        "\n",
        "  def get_model_name(self):\n",
        "    '''\n",
        "    Returns a list of model names\n",
        "    '''\n",
        "    return [model_dict['name'] for model_dict in self.get_url_dict() if 'name' in model_dict.keys() and 'id' in model_dict.keys()]\n",
        "\n",
        "  def get_model_layer_url(self, model_ids, model_name):\n",
        "    '''\n",
        "    Returns a list of model wise layer urls for each model\n",
        "    '''\n",
        "    return [f'{self.server_url}/flatmap/{id}/layers' for id, name in zip(model_ids, model_name)]\n",
        "\n",
        "  def get_model_image_layer(self, model_layer_url_list):\n",
        "    '''\n",
        "    Returns a list of key value pairs containing model id and model layers \n",
        "    '''\n",
        "    model_image_layers = []\n",
        "    for url in model_layer_url_list:\n",
        "      req= requests.get(url)\n",
        "      layer_url_dict = req.json()\n",
        "      model_image_layers.append({layer_url_dict[0]['id'] : layer_url_dict[0]['image-layers']})\n",
        "    return model_image_layers\n",
        "\n",
        "  def get_tile_urls(self):\n",
        "\n",
        "    '''\n",
        "    Returns a list of urls for each tile for each layer\n",
        "    '''\n",
        "\n",
        "    #Obtain model ids and names\n",
        "    model_ids = self.get_model_id()\n",
        "    model_names = self.get_model_name()\n",
        "\n",
        "    #Get model image layers\n",
        "    model_layer_url_list = self.get_model_layer_url(model_ids, model_names)\n",
        "    model_image_layers = self.get_model_image_layer(model_layer_url_list)\n",
        "\n",
        "    #Get URLS for vector tile\n",
        "    tile_urls = [f'{self.server_url}/flatmap/{model_ids[self.tag]}/tiles/{layer}/{{z}}/{{x}}/{{y}}' \\\n",
        "                 for layer in model_image_layers[self.tag][model_names[self.tag]]]\n",
        "    vector_tile_url = f'{self.server_url}/flatmap/{model_ids[self.tag]}/mvtiles/{{z}}/{{x}}/{{y}}'\n",
        "    req = requests.get(f'{self.server_url}/flatmap/{model_ids[self.tag]}',headers={'Accept':'json'})\n",
        "    index_json = req.json()\n",
        "\n",
        "    return tile_urls, vector_tile_url, index_json\n",
        "\n",
        "  def get_annotations(self):\n",
        "    '''\n",
        "    Returns a list of model annotations\n",
        "    '''\n",
        "    model_ids = self.get_model_id()\n",
        "    req = requests.get(f'{self.server_url}/flatmap/{model_ids[self.tag]}/annotations')\n",
        "    annotations = req.json()\n",
        "    return annotations\n",
        "\n",
        "  def split_map(self, second_model_number):\n",
        "\n",
        "    '''\n",
        "    Splits current map into two maps for cross species comparisons\n",
        "    '''\n",
        "\n",
        "    left_layer_urls, _, _ =  self.get_tile_urls()\n",
        "    left_layers = [TileLayer(url = url) for url in left_layer_urls]\n",
        "    print(left_layers)\n",
        "\n",
        "    second_model_object = Build_Map(self.server_url, second_model_number)\n",
        "    right_layer_urls,_, _ =  second_model_object.get_tile_urls()\n",
        "    right_layers = [TileLayer(url = url) for url in right_layer_urls]\n",
        "    print(right_layers)\n",
        "\n",
        "    control = SplitMapControl(left_layer=left_layers, right_layer=right_layers)\n",
        "\n",
        "    map = Map(basemap=left_layers[0])\n",
        "    for layer in left_layers[1:]:\n",
        "      map.add(layer)\n",
        "    map.add_control(control)\n",
        "    return map\n",
        "\n",
        "  def build_map_without_markers(self):\n",
        "\n",
        "    '''\n",
        "    Builds the flat map as a sequential layer addition. \n",
        "    '''\n",
        "\n",
        "    tile_urls, vector_tile_url, index_json = self.get_tile_urls()\n",
        "    \n",
        "    #Construct the map Object\n",
        "    map = Map(\n",
        "      basemap=TileLayer(url=tile_urls[0], \n",
        "                        min_zoom=index_json['min-zoom']),\n",
        "                        min_zoom=index_json['min-zoom'],\n",
        "                        max_zoom=index_json['max-zoom'],\n",
        "                        zoom=5,\n",
        "                        scroll_wheel_zoom=True,\n",
        "                        dragging=True,\n",
        "                        attribution_control=False,\n",
        "                        zoom_snap=False,\n",
        "                        )\n",
        "\n",
        "    #vector tiles styles\n",
        "    vector_tiles_styles = dict(\n",
        "        fill=\"true\",\n",
        "        weight=1,\n",
        "        fillColor=\"#f2b648\",\n",
        "        color=\"#f2b648\",\n",
        "        fillOpacity=0.2,\n",
        "        opacity=0.8,\n",
        "    )\n",
        "\n",
        "    #Create tile objects for the model with each layer added\n",
        "    for tile_url in tile_urls[1:]:\n",
        "      map.add(TileLayer(\n",
        "          url=tile_url, \n",
        "          min_zoom=index_json['min-zoom']))\n",
        "\n",
        "    # Add vector tile layer\n",
        "    map.add_layer(VectorTileLayer(url=vector_tile_url, vector_tile_layer_styles = vector_tiles_styles))\n",
        "\n",
        "    bounds = index_json['bounds']\n",
        "    map.fit_bounds([[bounds[1],bounds[0]],[bounds[3],bounds[2]]])\n",
        "\n",
        "    return map\n",
        "\n"
      ],
      "metadata": {
        "id": "5PfnKd_JbwbU"
      },
      "execution_count": 111,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class leaflet_addons(Build_Map):\n",
        "\n",
        "    \"\"\" Methods for interacting with flatmaps using leaflet add-ons  - Markers, \n",
        "    custom drawings, layer_control, antpath, heatmap, search bar and hover capabilities.\n",
        "\n",
        "    Attributes\n",
        "    ----------\n",
        "    build_map_object: A Build_Map object \n",
        "      Object of the class Build_Map \n",
        "    const_map: Flatmap\n",
        "      The flatmap to be interacted with   \n",
        "\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, build_map_obj, const_map):\n",
        "        self.build_map_obj = build_map_obj \n",
        "        self.const_map = const_map\n",
        "\n",
        "    def add_markers(self):\n",
        "        annotations = self.build_map_obj.get_annotations()\n",
        "        markers = []\n",
        "        for key in annotations.keys():\n",
        "            y,x = annotations[key]['centroid'] # Centroid coordinates are reversed\n",
        "            if 'label' in annotations[key].keys():\n",
        "                marker = Marker(location=[x,y],title=annotations[key]['label'])\n",
        "            else:\n",
        "                marker = Marker(location=[x,y])\n",
        "            markers.append(marker)\n",
        "        self.const_map.add_layer(MarkerCluster(markers=markers))\n",
        "\n",
        "    def add_custom_drawings(self):\n",
        "        \n",
        "        draw_control = DrawControl()\n",
        "        draw_control.polyline =  {\n",
        "            \"shapeOptions\": {\n",
        "                \"color\": \"#6bc2e5\",\n",
        "                \"weight\": 8,\n",
        "                \"opacity\": 1.0\n",
        "            }\n",
        "        }\n",
        "        draw_control.polygon = {\n",
        "            \"shapeOptions\": {\n",
        "                \"fillColor\": \"#6be5c3\",\n",
        "                \"color\": \"#6be5c3\",\n",
        "                \"fillOpacity\": 1.0\n",
        "            },\n",
        "            \"drawError\": {\n",
        "                \"color\": \"#dd253b\",\n",
        "                \"message\": \"Oups!\"\n",
        "            },\n",
        "            \"allowIntersection\": False\n",
        "        }\n",
        "        draw_control.circle = {\n",
        "            \"shapeOptions\": {\n",
        "                \"fillColor\": \"#efed69\",\n",
        "                \"color\": \"#efed69\",\n",
        "                \"fillOpacity\": 1.0\n",
        "            }\n",
        "        }\n",
        "        draw_control.rectangle = {\n",
        "            \"shapeOptions\": {\n",
        "                \"fillColor\": \"#fca45d\",\n",
        "                \"color\": \"#fca45d\",\n",
        "                \"fillOpacity\": 1.0\n",
        "            }\n",
        "        }\n",
        "\n",
        "        self.const_map.add_control(draw_control)\n",
        "\n",
        "    def add_layers_control(self):\n",
        "        control = LayersControl(position='topright')\n",
        "        self.const_map.add_control(control)\n",
        "\n",
        "    def add_search_bar(self):\n",
        "        #NOT WORKING\n",
        "        search_marker = Marker(icon=AwesomeIcon(name=\"check\", marker_color='green', icon_color='darkred'))\n",
        "\n",
        "        self.const_map.add_control(SearchControl(\n",
        "        position=\"topleft\",\n",
        "        url = 'https://nominatim.openstreetmap.org/search?format=json&q={s}',\n",
        "        zoom=4,\n",
        "        property_name='name',\n",
        "        marker=search_marker\n",
        "        ))\n",
        "\n",
        "    def add_antpath(self, locations, use = 'polyline'):\n",
        "        ant_path = AntPath(\n",
        "        locations= locations,\n",
        "        use = use,\n",
        "        dash_array=[1, 10],\n",
        "        delay=1000,\n",
        "        color='#7590ba',\n",
        "        pulse_color='#3f6fba'\n",
        "        )\n",
        "\n",
        "        self.const_map.add_layer(ant_path)\n",
        "\n",
        "    def add_heat_map(self, locations, radius = 30):\n",
        "        heatmap = Heatmap(\n",
        "        locations= locations,\n",
        "        radius=30)\n",
        "\n",
        "        self.const_map.add_layer(heatmap)\n",
        "\n",
        "    def hover(self): \n",
        "\n",
        "        html = HTML('Hover over regions')\n",
        "        html.value = '<h3>Hover over regions</h3>'\n",
        "        html.layout.margin = '0px 20px 20px 20px'\n",
        "        control = WidgetControl(widget=html,position='bottomright')\n",
        "        self.const_map.add_control(control)\n",
        "\n",
        "        def update_html(event,feature,**kwargs):\n",
        "            annotation = feature['properties']\n",
        "            label = annotation['label']\n",
        "            html.value=f\"<h3>{label}</h3>\"\n",
        "\n",
        "        # Create WKT layers using bounding boxes\n",
        "        wlayers = []\n",
        "        #Get annotations dictionary.\n",
        "        annotations = self.build_map_obj.get_annotations()\n",
        "        for key in annotations.keys():\n",
        "            if 'label' not in annotations[key].keys():\n",
        "                continue        \n",
        "            bounds = annotations[key]['bounds']\n",
        "            s,w,n,e = bounds\n",
        "\n",
        "            wlayer = CustomWKTLayer(\n",
        "            annotations[key],\n",
        "            wkt_string=f'POLYGON(({s} {w},{s} {e},{n} {e},{n} {w},{s} {w}))',\n",
        "            style={'opacity':0,'fillOpacity':0}\n",
        "            )\n",
        "            wlayer.on_hover(update_html)\n",
        "            wlayers.append(wlayer)        \n",
        "        wlayer_group = LayerGroup(layers=wlayers)        \n",
        "        self.const_map.add_layer(wlayer_group)\n",
        "\n",
        "    def add_all_leaflet_functions(self):\n",
        "        self.add_markers()\n",
        "        self.add_custom_drawings()\n",
        "        self.add_layers_control()\n",
        "        self.add_search_bar()\n",
        "        \n",
        "        "
      ],
      "metadata": {
        "id": "enNrt0SQmm3f"
      },
      "execution_count": 125,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "SgDZZ2wzyTxB"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}