diff --git a/.github/workflows/map_workflow.yml b/.github/workflows/map_workflow.yml
index 478ab90..ddf2c48 100644
--- a/.github/workflows/map_workflow.yml
+++ b/.github/workflows/map_workflow.yml
@@ -21,11 +21,13 @@ jobs:
           pip    install -r requirements.txt
           bash   download_prerequistes.sh
           python generate_map.py
+          python generate_map.py germany
       - name: Release Map
         uses: "softprops/action-gh-release@v1"
         if: startsWith(github.ref, 'refs/tags/')
         with:
           token: "${{ secrets.GITHUB_TOKEN }}"
           files: |
-            map.svg
+            germany.svg
+            europe.svg
             map.html
diff --git a/.gitignore b/.gitignore
index 90212b6..cdd9c8d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,8 +1,13 @@
 # font files
 data/*.ttf
-# NUTS files
+# NUTS/geojson files
 data/NUTS*.json
+data/*.geojson
 # python env files
 .mapenv
 # output files
-map.*
\ No newline at end of file
+map.html
+europe.*
+germany.*
+# .vscode folder
+.vscode
\ No newline at end of file
diff --git a/data/plotted_locations.json b/data/plotted_locations.json
index f987644..bef5f91 100644
--- a/data/plotted_locations.json
+++ b/data/plotted_locations.json
@@ -1,149 +1,184 @@
 [
   {
     "common_name": "Lausanne",
-    "nuts_lvl3": "Genève",
-    "stage": "production",
+    "id_name": "Genève",
+    "stage": "Production",
     "num_users": 1,
     "country_code": "CH"
   },
   {
     "common_name": "Zürich",
-    "nuts_lvl3": "Zürich",
-    "stage": "mixed",
+    "id_name": "Zürich",
+    "stage": "Mixed",
     "num_users": 4,
     "country_code": "CH"
   },
   {
     "common_name": "Aachen",
-    "nuts_lvl3": "Städteregion Aachen",
-    "stage": "production",
+    "id_name": "Städteregion Aachen",
+    "stage": "Production",
     "num_users": 4,
     "country_code": "DE"
   },
   {
     "common_name": "Braunschweig",
-    "nuts_lvl3": "Braunschweig, Kreisfreie Stadt",
-    "stage": "test",
+    "id_name": "Braunschweig, Kreisfreie Stadt",
+    "stage": "Test",
     "num_users": 2,
     "country_code": "DE"
   },
   {
     "common_name": "Chemnitz",
-    "nuts_lvl3": "Chemnitz, Kreisfreie Stadt",
-    "stage": "production",
+    "id_name": "Chemnitz, Kreisfreie Stadt",
+    "stage": "Production",
     "num_users": 1,
     "country_code": "DE"
   },
   {
     "common_name": "Dresden",
-    "nuts_lvl3": "Dresden, Kreisfreie Stadt",
-    "stage": "test",
+    "id_name": "Dresden, Kreisfreie Stadt",
+    "stage": "Test",
     "num_users": 1,
     "country_code": "DE"
   },
   {
     "common_name": "Duisburg-Essen",
-    "nuts_lvl3": "Duisburg, Kreisfreie Stadt",
-    "stage": "production",
+    "id_name": "Duisburg, Kreisfreie Stadt",
+    "stage": "Production",
     "num_users": 1,
     "country_code": "DE"
   },
   {
     "common_name": "Freiburg",
-    "nuts_lvl3": "Freiburg im Breisgau, Stadtkreis",
-    "stage": "test",
+    "id_name": "Freiburg im Breisgau, Stadtkreis",
+    "stage": "Test",
     "num_users": 1,
     "country_code": "DE"
   },
   {
     "common_name": "Greifswald",
-    "nuts_lvl3": "Vorpommern-Greifswald",
-    "stage": "production",
+    "id_name": "Vorpommern-Greifswald",
+    "stage": "Production",
     "num_users": 1,
     "country_code": "DE"
   },
   {
     "common_name": "Heidelberg",
-    "nuts_lvl3": "Heidelberg, Stadtkreis",
-    "stage": "production",
+    "id_name": "Heidelberg, Stadtkreis",
+    "stage": "Production",
     "num_users": 1,
     "country_code": "DE"
   },
   {
     "common_name": "Jena",
-    "nuts_lvl3": "Jena, Kreisfreie Stadt",
-    "stage": "production",
+    "id_name": "Jena, Kreisfreie Stadt",
+    "stage": "Production",
     "num_users": 1,
     "country_code": "DE"
   },
   {
     "common_name": "Kaiserslautern",
-    "nuts_lvl3": "Kaiserslautern, Kreisfreie Stadt",
-    "stage": "production",
+    "id_name": "Kaiserslautern, Kreisfreie Stadt",
+    "stage": "Production",
     "num_users": 1,
     "country_code": "DE"
   },
   {
     "common_name": "Karlsruhe",
-    "nuts_lvl3": "Karlsruhe, Stadtkreis",
-    "stage": "mixed",
+    "id_name": "Karlsruhe, Stadtkreis",
+    "stage": "Mixed",
     "num_users": 5,
     "country_code": "DE"
   },
   {
     "common_name": "Kiel",
-    "nuts_lvl3": "Kiel, Kreisfreie Stadt",
-    "stage": "test",
+    "id_name": "Kiel, Kreisfreie Stadt",
+    "stage": "Test",
     "num_users": 1,
     "country_code": "DE"
   },
   {
-    "common_name": "Köln",
-    "nuts_lvl3": "Köln, Kreisfreie Stadt",
-    "stage": "test",
+    "common_name": "Colonge",
+    "id_name": "Köln, Kreisfreie Stadt",
+    "stage": "Test",
     "num_users": 1,
     "country_code": "DE"
   },
   {
     "common_name": "Mainz",
-    "nuts_lvl3": "Mainz, Kreisfreie Stadt",
-    "stage": "test",
+    "id_name": "Mainz, Kreisfreie Stadt",
+    "stage": "Test",
     "num_users": 1,
     "country_code": "DE"
   },
   {
     "common_name": "Munich",
-    "nuts_lvl3": "München, Kreisfreie Stadt",
-    "stage": "mixed",
+    "id_name": "München, Kreisfreie Stadt",
+    "stage": "Mixed",
     "num_users": 1,
     "country_code": "DE"
   },
   {
     "common_name": "Paderborn",
-    "nuts_lvl3": "Paderborn",
-    "stage": "production",
+    "id_name": "Paderborn",
+    "stage": "Production",
     "num_users": 1,
     "country_code": "DE"
   },
   {
     "common_name": "Stuttgart",
-    "nuts_lvl3": "Stuttgart, Stadtkreis",
-    "stage": "production",
+    "id_name": "Stuttgart, Stadtkreis",
+    "stage": "Production",
     "num_users": 2,
     "country_code": "DE"
   },
   {
     "common_name": "Ulm",
-    "nuts_lvl3": "Ulm, Stadtkreis",
-    "stage": "planned",
+    "id_name": "Ulm, Stadtkreis",
+    "stage": "Planned",
     "num_users": 1,
     "country_code": "DE"
   },
   {
     "common_name": "Würzburg",
-    "nuts_lvl3": "Würzburg, Kreisfreie Stadt",
-    "stage": "production",
+    "id_name": "Würzburg, Kreisfreie Stadt",
+    "stage": "Production",
     "num_users": 1,
     "country_code": "DE"
+  },
+  {
+    "common_name": "Barcelona",
+    "id_name": "Barcelona",
+    "stage": "Production",
+    "num_users": 1,
+    "country_code": "ES"
+  },
+  {
+    "common_name": "Grenoble",
+    "id_name": "Isère",
+    "stage": "Production",
+    "num_users": 1,
+    "country_code": "FR"
+  },
+  {
+    "common_name": "Nijmegen",
+    "id_name": "Arnhem/Nijmegen",
+    "stage": "Production",
+    "num_users": 1,
+    "country_code": "NL"
+  },
+  {
+    "common_name": "Utrecht",
+    "id_name": "Utrecht",
+    "stage": "Planned",
+    "num_users": 1,
+    "country_code": "NL"
+  },
+  {
+    "common_name": "Chennai",
+    "id_name": "Chennai",
+    "stage": "Planned",
+    "num_users": 1,
+    "country_code": "IN"
   }
-]
+]
\ No newline at end of file
diff --git a/data/template.html b/data/template.html
index 264b3f8..48fb99c 100644
--- a/data/template.html
+++ b/data/template.html
@@ -19,10 +19,8 @@
     </style>
     <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" />
     <!-- import Leaflet -->
-    <link rel="stylesheet" href="https://unpkg.com/leaflet@1.9.3/dist/leaflet.css"
-        integrity="sha256-kLaT2GOSpHechhsozzB+flnD+zUyjE2LlfWPgU04xyI=" crossorigin="" />
-    <script src="https://unpkg.com/leaflet@1.9.3/dist/leaflet.js"
-        integrity="sha256-WBkoXOwTeyKclOHuWtc+i2uENFpDZ9YPdf5Hf+D7ewM=" crossorigin=""></script>
+    <link rel="stylesheet" href="https://unpkg.com/leaflet/dist/leaflet.css" />
+    <script src="https://unpkg.com/leaflet/dist/leaflet.js"></script>
     <!-- Leaflet styling i.e. full page -->
     <style>
         #map {
@@ -60,13 +58,12 @@
     var map = L.map(
         "map",
         {
-            crs: L.CRS.EPSG3857,
             zoom: $STARTZOOM$,
             zoomControl: true,
             preferCanvas: false,
         }
     );
-    map.fitBounds([[$LATMIN$, $LONMIN$], [$LATMAX$, $LONMAX$]])
+    map.fitBounds([[$LONMIN$, $LATMIN$], [$LONMAX$, $LATMAX$]])
 
     var tiles = L.tileLayer(
         "https://cartodb-basemaps-{s}.global.ssl.fastly.net/light_all/{z}/{x}/{y}.png",
@@ -76,7 +73,6 @@
         }
     ).addTo(map);
     // $MARKERS-GO-HERE$
-    // $POLYLINES-GO-HERE$
     // $LAYERCONTROL-GO-HERE$
     var legend = L.control({ position: 'bottomleft' });
     legend.onAdd = function (map) {
diff --git a/download_prerequistes.sh b/download_prerequistes.sh
index 73d4ede..3d03477 100755
--- a/download_prerequistes.sh
+++ b/download_prerequistes.sh
@@ -5,5 +5,6 @@ cd data
 # download and save the font
 wget -N https://github.com/googlefonts/opensans/raw/main/fonts/ttf/OpenSans-Bold.ttf
 # download and save the topojson files
-wget -N https://gisco-services.ec.europa.eu/distribution/v2/nuts/topojson/NUTS_RG_01M_2021_3035_LEVL_1.json
-wget -N https://gisco-services.ec.europa.eu/distribution/v2/nuts/topojson/NUTS_RG_01M_2021_3035_LEVL_3.json
\ No newline at end of file
+wget -N https://gisco-services.ec.europa.eu/distribution/v2/nuts/geojson/NUTS_RG_01M_2021_4326_LEVL_1.geojson
+wget -N https://gisco-services.ec.europa.eu/distribution/v2/nuts/geojson/NUTS_RG_01M_2021_4326_LEVL_3.geojson
+wget -N https://raw.githubusercontent.com/nvkelso/natural-earth-vector/master/geojson/ne_10m_populated_places_simple.geojson
\ No newline at end of file
diff --git a/generate_map.py b/generate_map.py
index 8e9cd91..aa1a687 100644
--- a/generate_map.py
+++ b/generate_map.py
@@ -1,127 +1,88 @@
 from pathlib import Path
 from matplotlib.colors import rgb2hex
 from matplotlib import colormaps
-import matplotlib.patches as pat
+from matplotlib.patches import Circle
 import matplotlib.pyplot as plt
 import pandas as pd
 import geopandas as gpd
-
-# change this as required
-connections = []  # [("Karlsruhe","Aachen")] # to be stored as common_name
+import sys
 
 # no need to change unless changes in apprearance are required. Please know what you are doing.
-color = {"production": "green",  # color codes for different types of instances
-         "mixed": "blue",  # color supported in dynamic map are listed here https://github.com/pointhi/leaflet-color-markers
-         "test": "orange",
-         "planned": "grey"}
-ordered_stages = ["planned", "test", "production", "mixed"]
-static_map_patch_size = 20000
+only_germany = len(sys.argv) > 1 and sys.argv[1] == "germany" # static map only for Germany, not other european countries
+color = {"Production": "green",  # color codes for different types of instances
+         "Mixed": "blue",  # color supported in dynamic map are listed here https://github.com/pointhi/leaflet-color-markers
+         "Test": "orange",
+         "Planned": "grey"}
+ordered_stages = ["Planned", "Test", "Production", "Mixed"]
+static_map_patch_size = 300
+static_number_fontsize = 12
 dynamic_map_start_zoom = 6
 dynamic_map_max_zoom = 9
 dynamic_map_padding = 0.3  # works in tandem with the start zoom setting
 overlay_icon = "https://raw.githubusercontent.com/harivyasi/ELNmap/main/data/favicon.ico"
 legend_header = "<a href='https://chemotion.net/'>Chemotion</a>"
-legend_location = "lower right"
+if only_germany:
+    legend_location = (0.2,0.7)
+    color_based_on = "NUTS_NAME"
+    map_filename = "germany.svg"
+else:
+    legend_location = (1.0,0.4)
+    color_based_on="CNTR_CODE"
+    map_filename = "europe.svg"
 
 # access font and JSON data
 data_dir = Path("data")
 font_file = data_dir / "OpenSans-Bold.ttf"
 # NUTS level 1 is 'states' or 'group of states' or something similar
 # NUTS level 3 is (usually) city-level boundary
-jsons = {"country":  data_dir / "NUTS_RG_01M_2021_3035_LEVL_1.json",
-         "city":  data_dir / "NUTS_RG_01M_2021_3035_LEVL_3.json",
-         "plotted":  data_dir / "plotted_locations.json"}
+geojsons = {"eur_country":  data_dir / "NUTS_RG_01M_2021_4326_LEVL_1.geojson",
+         "eur_location":  data_dir / "NUTS_RG_01M_2021_4326_LEVL_3.geojson",
+         "int_location": data_dir / "ne_10m_populated_places_simple.geojson"}
 
 # read all locations to be plotted
-locations = pd.read_json(jsons["plotted"])
-
-# determine included countries
-countries_included = locations["country_code"].unique().tolist()
+locations = pd.read_json(data_dir / "plotted_locations.json")
+locations['longitude'] = [0.0]*len(locations)
+locations['latitude'] = [0.0]*len(locations)
 
+# prepare europe map
 # read country boundaries, specify the format, limit to countries that are included
-map_country = gpd.read_file(jsons["country"])
-map_country.crs = "EPSG:3035"
-map_country = map_country[map_country.CNTR_CODE.isin(countries_included)]
-
-# modifications to map, if any
-if "FR" in countries_included:
-    # include only mainland France for conciseness
-    map_country.drop(map_country[map_country.FID.isin(
-        ["FRY", "FRM"])].index, inplace=True)
-    
-if "ES" in countries_included:
-    # include only mainland Spain for conciseness
-    map_country.drop(map_country[map_country.FID.isin(
-        ["ES7"])].index, inplace=True)
-
-# read city boundaries, specify the format, subset to countries included
-map_city = gpd.read_file(jsons["city"])
-map_city.crs = "EPSG:3035"
-map_city = map_city[map_city.CNTR_CODE.isin(countries_included)]
-
-# reduce city representation to their centroid point
-map_city['geometry'] = map_city.centroid
-
-# Copy city map and convert it latitue longitude map format for the sake of Leaflet
-# CAUTION: They are arranged such that x = lon and y = lat
-llm_city = map_city.to_crs("EPSG:4326")
+eur_country = gpd.read_file(geojsons["eur_country"])
+if only_germany:
+    eur_country_list = ["DE"]
+    eur_country = eur_country[eur_country.CNTR_CODE.isin(eur_country_list)]
+else:
+    eur_country = eur_country[eur_country.CNTR_CODE.isin(locations["country_code"].unique().tolist())]
+    eur_country_list = eur_country.CNTR_CODE.unique().tolist()
+
+# modifications to eur map, if any
+eur_country_drop_parts = {"FR":["FRY", "FRM"], "ES":["ES7"]} # keep only mainland parts for conciseness
+for v in eur_country_drop_parts.values():
+    eur_country.drop(eur_country[eur_country.FID.isin(v)].index, inplace=True)
+
+# read location boundaries, specify the format, reduce location representation to their centroid point
+eur_location = gpd.read_file(geojsons["eur_location"])
+# reduce size by limiting to included cities, then find centroid
+eur_location = eur_location[eur_location.NUTS_NAME.isin(locations.id_name)]
+crs = eur_location.crs
+eur_location = eur_location.to_crs('+proj=cea')
+eur_location['geometry'] = eur_location.centroid
+eur_location = eur_location.to_crs(crs)
+
+# read international cities
+int_location = gpd.read_file(geojsons["int_location"]).to_crs(crs)
 
-# Create polygons to draw connections
-mpl_polygon = []  # matplotlib
-lfl_polylin = []  # leafelt, needs lat lon format
-for idx, connection in enumerate(connections):
-    mpl_polygon.append([])
-    lfl_polylin.append([])
-    for city in connection:
-        # get the level 3 name of the city
-        lvl3_name = locations[locations['common_name']
-                              == city]['nuts_lvl3'].values[0]
-        matched_city = map_city['NAME_LATN'] == lvl3_name
-        coord = list(map_city[matched_city]['geometry'].item().coords)[
-            0]  # then get the coords associated with it
-        latlon = list(llm_city[matched_city]['geometry'].item().coords)[
-            0][::-1]  # reversed because lon = x, lat = y
-        mpl_polygon[-1].append(coord)
-        lfl_polylin[-1].append(latlon)
-    if mpl_polygon[-1]:
-        # repeat the first point to create a 'closed loop' # see https://stackoverflow.com/questions/43971259/
-        mpl_polygon[-1].append(mpl_polygon[-1][0])
-
-# Create table of cities to plot
-# cities segregated according to their stage, keys are the possible stages
-city_in_stages = {}
-for stage in ordered_stages:
-    # each entry is a dictionary with city+idx as key and common_name as value
-    city_in_stages[stage] = {}
-cities = []  # cities as a list of dictionaries, containing all relevant info
-
-map_limits = {"lon": {"max": -180.0, "min": 180.0},  # useful for determining canvas of the static map
-              "lat": {"max":    0.0, "min":  90.0}}  # opposite of what can happen so that the values are always overwritten
 for idx, row in locations.iterrows():
-    # identify the city
-    matched_city = map_city['NAME_LATN'] == row['nuts_lvl3']
-    coord = list(map_city[matched_city]['geometry'].item().coords)[
-        0]  # then get the coords associated with it
-    latlon = list(llm_city[matched_city]['geometry'].item().coords)[
-        0][::-1]  # reversed because lon = x, lat = y
-    map_limits["lat"]["max"] = max(map_limits["lat"]["max"], latlon[0])
-    map_limits["lat"]["min"] = min(map_limits["lat"]["min"], latlon[0])
-    map_limits["lon"]["max"] = max(map_limits["lon"]["max"], latlon[1])
-    map_limits["lon"]["min"] = min(map_limits["lon"]["min"], latlon[1])
-    cities.append({"name": row["common_name"], "coord": coord, "latlon": latlon,
-                  "stage": row["stage"], "num_users": row["num_users"]})
-    city_in_stages[row["stage"]]["city{}".format(idx)] = row["common_name"]
-map_limits["lon"]["max"] += dynamic_map_padding
-map_limits["lon"]["min"] -= dynamic_map_padding
-map_limits["lat"]["max"] += dynamic_map_padding
-map_limits["lat"]["min"] -= dynamic_map_padding
-
-# preserve only used patches in the ordered list
-# remove empty dictionary entries
-city_in_stages = {k: v for k, v in city_in_stages.items() if v}
-remove_stages = set(ordered_stages) - set(city_in_stages.keys())
-for stage in remove_stages:
-    ordered_stages.remove(stage)
+    # try and get location from the european city list
+    geometry = eur_location[eur_location.NUTS_NAME == row.id_name].geometry
+    if geometry.empty: # if not then check international cities list
+        geometry = int_location[int_location.name == row.id_name].geometry
+    if geometry.empty: # if still not found then raise error
+        raise IndexError("Could not place the following location on map: "+row.common_name)
+    else:
+        locations.loc[locations.id_name == row.id_name, 'latitude'] = geometry.x.values[0]
+        locations.loc[locations.id_name == row.id_name, 'longitude'] = geometry.y.values[0]
+
+locations = gpd.GeoDataFrame(locations, geometry=gpd.points_from_xy(locations.latitude, locations.longitude), crs=crs)
 
 #######################
 # Plot the static map #
@@ -131,58 +92,34 @@
     raise FileNotFoundError(
         "Failed to find the font file. Please make sure that you have it.")
 
-# draw the canvas for static map
-fig, ax = plt.subplots(1, figsize=(9, 15), tight_layout=True)
+# change projection for static map
+eur_country = eur_country.to_crs("EPSG:3857")
+eur_locations = locations[locations.country_code.isin(eur_country.CNTR_CODE)].to_crs("EPSG:3857")
 
 # plot countries map
-map_country.plot(ax=ax, column="CNTR_CODE", cmap='tab20', edgecolor='w')
-
-# color map for connections
-tab10 = colormaps["tab10"]
-
-# plot the connections
-connection_colors = []
-for idx, polygon in enumerate(mpl_polygon):
-    if polygon:
-        xs, ys = zip(*polygon)
-        connection_colors.append(tab10(idx))
-        conn, = plt.plot(xs, ys, color=connection_colors[-1], ls=":", lw=2)
+fig, ax = plt.subplots(1, figsize=(10,10), tight_layout=True)
+ax = eur_country.plot(ax=ax, column=color_based_on, cmap='tab20', edgecolor='w')
+# plot the patches
+ax = eur_locations.plot(column="stage", cmap = 'Dark2', ax=ax, markersize=static_map_patch_size, zorder=2, legend=True, legend_kwds={'prop':{'size': 25}, 'frameon': False, 'framealpha': 0.2, 'handletextpad': 0.1, 'markerscale': 2, 'bbox_to_anchor': legend_location})
+# plot the number of users
+for x, y, num_users in zip(eur_locations.geometry.x, eur_locations.geometry.y, eur_locations.num_users):
+    ax.annotate(num_users, xy=(x, y), horizontalalignment='center', verticalalignment='center', color='white', font=font_file, size=static_number_fontsize)
 
-# plot the cities
-for city in cities:
-    ax.add_patch(pat.Circle(
-        city["coord"], static_map_patch_size, color=color[city["stage"]], zorder=2))
-    plt.annotate(text=city["num_users"], xy=city["coord"], horizontalalignment='center',
-                 verticalalignment='center', color='white', font=font_file, size=20)
-
-# create patches and connection-line for legend
-patches_for_legend = [[], []]
-for stage in ordered_stages:
-    patches_for_legend[0].append(plt.Circle(
-        coord, static_map_patch_size, color=color[stage]))
-    patches_for_legend[1].append(stage.title())
-if connection_colors:  # when more than one connections exist, represent them just once with a black dotted line
-    conn_text = ["Connected Repository"]
-    if len(connection_colors) > 1:
-        conn_text = ["Connected Repositories"]
-        from copy import copy
-        conn = copy(conn)
-        conn.set_visible = False
-        conn.set_color("black")
-    conn = [conn]
-else:  # do not include connections entry in legend if no connections are present
-    conn = []
-    conn_text = []
-
-plt.legend(conn+patches_for_legend[0], conn_text +
-           patches_for_legend[1], loc=legend_location, prop={'size': 30}, frameon=False, framealpha=0)
 plt.axis('off')
-plt.savefig("map.svg")
-
+plt.savefig(map_filename)
+if only_germany:
+    exit() # exit after producing the static map
 
 ########################
 # Plot the dynamic map #
-########################
+######################## 
+
+map_limits = {"lon": {}, "lat": {}} # opposite of what can happen so that the values are always overwritten
+
+map_limits["lat"]["max"] = locations.latitude.max() + dynamic_map_padding
+map_limits["lat"]["min"] = locations.latitude.min() - dynamic_map_padding
+map_limits["lon"]["max"] = locations.longitude.max() + dynamic_map_padding
+map_limits["lon"]["min"] = locations.longitude.min() - dynamic_map_padding
 
 # load templated text for the dynamic map
 html_text = (data_dir / "template.html").read_text()
@@ -200,7 +137,7 @@
 html_text = html_text.replace(
     "$LONMAX$", "{}".format(map_limits["lon"]["max"]))
 
-# set up all the city markers
+# set up all the location markers
 marker_text = ""
 
 # first setup the icons
@@ -214,64 +151,42 @@
             shadowAnchor: [13, 40]}}  
     );""".format(stage, overlay_icon, color[stage])
 
-# create markers for all the cities and add them to the corresponding layer
+# create markers for all the locations and add them to the corresponding layer
 layers = {}
 for stage in ordered_stages:
     layers[stage] = "\n    var {} = L.layerGroup([".format(stage)
 
-for idx, city in enumerate(cities):
-    marker_text += "\n    var city{} = L.marker([{}, {}], {{icon: icon_{}}} )".format(
-        idx, city["latlon"][0], city["latlon"][1], city["stage"])
-    plural = "s" if city['num_users'] > 1 else ""
-    marker_text += "\n    city{}.bindTooltip(`<div>{}: {} installation{} in {} usage.<div>`, {{\"sticky\": true}});".format(
-        idx, city["name"], city["num_users"], plural, city["stage"])
-    for stage, city_dict in city_in_stages.items():
-        if "city{}".format(idx) in city_dict:
-            layers[stage] += "city{},".format(idx)
+locations['inHTML'] = ["location"]*len(locations)
+for idx, location in locations.iterrows():
+    marker_text += "\n    var location{} = L.marker([{}, {}], {{icon: icon_{}}} )".format(
+        idx, location.longitude, location.latitude, location.stage)
+    plural = "s" if location.num_users > 1 else ""
+    marker_text += "\n    location{}.bindTooltip(`<div>{}: {} installation{} in {} usage.<div>`, {{\"sticky\": true}});".format(
+        idx, location.common_name, location.num_users, plural, location.stage)
+    locations.loc[idx, "inHTML"] += str(idx)
 
-for stage in layers:
-    layers[stage] = layers[stage].rstrip(',')+"]).addTo(map)"
+for stage in ordered_stages:
+    layers[stage] += ",".join(locations[locations.stage == stage].inHTML.tolist())+"]).addTo(map)"
 
 for stage in ordered_stages:
     marker_text += layers[stage]
 
 html_text = html_text.replace("// $MARKERS-GO-HERE$", marker_text)
 
-# if connections exist, draw all polylines, club them together into 'connections' so as to be used by the control later
-
-polyline_text = ""
-if connection_colors:  # shorthand to check if connections exists
-    for idx, polyline in enumerate(lfl_polylin):
-        latlon_str = ""
-        for latlon in polyline:
-            latlon_str += "[{}, {}],".format(latlon[0], latlon[1])
-        latlon_str = latlon_str.rstrip(',')
-        polyline_text += """\n    var polyline{} = L.polyline(
-        [{}],
-        {{"color": "{}", "lineCap": "round", "lineJoin": "round", "opacity": 0.8, "smoothFactor": 1.0, "stroke": true, "weight": 5}}
-        )""".format(idx, latlon_str, rgb2hex(connection_colors[idx]))
-    polyline_text += "\n    var connections = L.layerGroup([" + ",".join(
-        ["polyline{}".format(idx) for idx in range(len(lfl_polylin))]) + "]).addTo(map)"
-
-html_text = html_text.replace("// $POLYLINES-GO-HERE$", polyline_text)
-
 # add layer control
 # start
 layercontrol_text = "\n    var overlays = {"
 # include markers
 for stage in ordered_stages:
     layercontrol_text += "\n        \"{} usage\": {},".format(
-        stage.capitalize(), stage)
-# include connections
-if connection_colors:
-    layercontrol_text += "\n        \"Connections\": connections"
+        stage, stage)
 # end
 layercontrol_text += "\n    };"
 
 legend_html = "<b>{}</b><br>".format(legend_header)
 for stage in ordered_stages:
     legend_html += "\n        <img src='https://raw.githubusercontent.com/pointhi/leaflet-color-markers/master/img/marker-icon-{}.png' width=12>  {} usage<br>".format(
-        color[stage], stage.capitalize())
+        color[stage], stage)
 
 html_text = html_text.replace("$LEGEND_HTML$", legend_html)
 html_text = html_text.replace("// $LAYERCONTROL-GO-HERE$", layercontrol_text)