notebooks/3. Get sidewalk widths on network.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "5f034096",
      "metadata": {},
      "source": [
        "# 3. Add sidewalk widths to basic pedestrian network"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "071158b6",
      "metadata": {
        "gather": {
          "logged": 1705481745888
        }
      },
      "outputs": [],
      "source": [
        "# Standard library and path imports\n",
        "import set_path\n",
        "import math\n",
        "import warnings\n",
        "\n",
        "# Third-party library imports\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import shapely.ops as so\n",
        "import shapely.geometry as sg\n",
        "import geopandas as gpd\n",
        "from geopandas import GeoDataFrame\n",
        "import networkx as nx\n",
        "import momepy\n",
        "from tqdm.notebook import tqdm_notebook\n",
        "tqdm_notebook.pandas()\n",
        "import folium\n",
        "\n",
        "# Local or project-specific imports\n",
        "import plot_utils\n",
        "import poly_utils\n",
        "import bgt_utils\n",
        "import settings as st\n",
        "\n",
        "if st.my_run == \"azure\":\n",
        "    import config_azure as cf\n",
        "elif st.my_run == \"local\":\n",
        "    import config as cf\n",
        "\n",
        "from shapely.errors import ShapelyDeprecationWarning\n",
        "warnings.filterwarnings(\"ignore\", category=ShapelyDeprecationWarning)\n",
        "warnings.filterwarnings(\"ignore\", category=pd.errors.SettingWithCopyWarning)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "1a9eb9f4-b48c-4fdf-844d-c351d80edd4c",
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "source": [
        "## Import basic network data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "a1cf3786-59f2-4b44-bd1f-7ac104ed0c4e",
      "metadata": {
        "gather": {
          "logged": 1705481763846
        },
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "outputs": [],
      "source": [
        "# Get basic pedestrian network and sidewalks\n",
        "df_bgt_nw = gpd.read_file(cf.output_basic_network)\n",
        "df_bgt_sw = gpd.read_file(cf.output_sidewalks_basic_network)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e7e22d70-d922-474e-a33b-6bbb423a78ef",
      "metadata": {
        "gather": {
          "logged": 1705481780372
        },
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "outputs": [],
      "source": [
        "df_bgt_nw.rename(columns={'geometry': 'centerlines'}, inplace=True)\n",
        "df_bgt_exp = pd.merge(df_bgt_nw, df_bgt_sw, on='sidewalk_id', how='left')\n",
        "df_bgt_exp = df_bgt_exp.set_geometry('centerlines')\n",
        "df_bgt_exp.head(3)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "65658aaf",
      "metadata": {},
      "source": [
        "## Create relevant variable - full width"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "70725eb3",
      "metadata": {},
      "source": [
        "### Get width and color"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "4fdea8e0",
      "metadata": {
        "gather": {
          "logged": 1705481869598
        }
      },
      "outputs": [],
      "source": [
        "df_bgt_exp[['avg_width', 'min_width']] = df_bgt_exp.progress_apply(\n",
        "    lambda row: poly_utils.get_avg_width_cl(row.geometry, row.centerlines, \n",
        "                                            st.width_resolution, st.width_precision), axis=1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "0ae7a34a",
      "metadata": {
        "gather": {
          "logged": 1705481890506
        }
      },
      "outputs": [],
      "source": [
        "conditions = [\n",
        "    (df_bgt_exp['min_width'] < st.width_1),\n",
        "    (df_bgt_exp['min_width'] >= st.width_1) & (df_bgt_exp['min_width'] < st.width_2),\n",
        "    (df_bgt_exp['min_width'] >= st.width_2) & (df_bgt_exp['min_width'] < st.width_3),\n",
        "    (df_bgt_exp['min_width'] >= st.width_3) & (df_bgt_exp['min_width'] < st.width_4),\n",
        "    (df_bgt_exp['min_width'] >= st.width_4) & (df_bgt_exp['min_width'] < st.width_5),\n",
        "    (df_bgt_exp['min_width'] >= st.width_5) & (df_bgt_exp['min_width'] < st.width_6),\n",
        "    (df_bgt_exp['min_width'] >= st.width_6)\n",
        "]\n",
        "\n",
        "values_float = [st.min_path_width, st.width_1, st.width_2, st.width_3, st.width_4, st.width_5, st.width_6]\n",
        "values_indication = ['<' + str(st.width_1) + 'm', \n",
        "                     str(st.width_1) + '-' + str(st.width_2) + 'm', \n",
        "                     str(st.width_2) + '-' + str(st.width_3) + 'm', \n",
        "                     str(st.width_3) + '-' + str(st.width_5) + 'm', \n",
        "                     str(st.width_4) + '-' + str(st.width_5) + 'm', \n",
        "                     str(st.width_5) + '-' + str(st.width_6) + 'm', \n",
        "                     '>' + str(st.width_6) + 'm']"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "b148d1fb",
      "metadata": {
        "gather": {
          "logged": 1705481892306
        }
      },
      "outputs": [],
      "source": [
        "df_bgt_exp['full_width_float'] = np.select(conditions, values_float)\n",
        "df_bgt_exp['full_width'] = np.select(conditions, values_indication)\n",
        "df_bgt_exp['full_width'].value_counts()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "3f55cc94",
      "metadata": {},
      "source": [
        "### Remove too narrow paths and short-ends"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "761ed7e8",
      "metadata": {
        "gather": {
          "logged": 1705481899353
        }
      },
      "outputs": [],
      "source": [
        "# Apply minimal path width on BGT centerlines\n",
        "print(df_bgt_exp.shape)\n",
        "df_bgt_exp = df_bgt_exp[df_bgt_exp['min_width'] > st.min_path_width].reset_index(drop=True)\n",
        "print(df_bgt_exp.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "a0f232f8",
      "metadata": {
        "gather": {
          "logged": 1705483783985
        }
      },
      "outputs": [],
      "source": [
        "# Remove short lines\n",
        "df_bgt_exp = df_bgt_exp.rename(columns={'geometry':'geometry_sidewalks', 'centerlines':'geometry'}) \n",
        "mls_per_id = poly_utils.create_mls_per_sidewalk(df_bgt_exp, crs=st.CRS)\n",
        "mls_per_id['geometry'] = mls_per_id['geometry'].progress_apply(\n",
        "    lambda x: poly_utils.remove_short_lines(x, st.min_se_length_fw))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "bd88bd59",
      "metadata": {
        "gather": {
          "logged": 1705483784437
        }
      },
      "outputs": [],
      "source": [
        "# Apply selection of longer lines to original dataframe\n",
        "long_segments_df = gpd.GeoDataFrame(mls_per_id.geometry.explode())\n",
        "df_bgt_exp = df_bgt_exp.merge(long_segments_df, how='inner')\n",
        "df_bgt_exp.shape"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "9a555a6e",
      "metadata": {},
      "source": [
        "## Import segments data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "2a69b43f",
      "metadata": {
        "gather": {
          "logged": 1705484898221
        }
      },
      "outputs": [],
      "source": [
        "# Read lines with widths (calculated using notebook 5 of https://github.com/Amsterdam-AI-Team/Urban_PointCloud_Sidewalk_Width)\n",
        "df_segments_full = gpd.read_file(cf.segments_file, crs=st.CRS)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "38f75bda-2d1f-44ea-97d6-f13388a0a5b3",
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "source": [
        "### Selection of segments within pilot area"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "4d89cf85-2592-40c5-9115-3611a98b7349",
      "metadata": {
        "gather": {
          "logged": 1705484901347
        },
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "outputs": [],
      "source": [
        "# Import areas\n",
        "df_areas = gpd.read_file(cf.output_pilot_area)\n",
        "\n",
        "# Only keep BGT data within pilot areas\n",
        "df_segments = df_segments_full.sjoin(df_areas, how='inner', predicate='within')  # note: only sidewalk polygons fully inside area are included"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "1a75dd16",
      "metadata": {},
      "source": [
        "## Create relevant variable - obstacle-free width"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "339d6256",
      "metadata": {},
      "source": [
        "### Remove too narrow paths and short-ends"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "efd9d0b7",
      "metadata": {
        "gather": {
          "logged": 1705484901695
        }
      },
      "outputs": [],
      "source": [
        "# Apply minimal path width\n",
        "df_segments_wide = df_segments[df_segments['min_width'] > st.min_path_width].reset_index(drop=True)\n",
        "print(df_segments.shape)\n",
        "print(df_segments_wide.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "206c47a6",
      "metadata": {
        "collapsed": false,
        "gather": {
          "logged": 1705490194243
        }
      },
      "outputs": [],
      "source": [
        "# Remove short lines (this takes a while)\n",
        "mls_per_id = poly_utils.create_mls_per_sidewalk(df_segments_wide, crs=st.CRS)\n",
        "mls_per_id['geometry'] = mls_per_id['geometry'].progress_apply(poly_utils.remove_short_lines)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "f00d2b0e",
      "metadata": {
        "gather": {
          "logged": 1705490195033
        }
      },
      "outputs": [],
      "source": [
        "# Apply selection of longer lines to original dataframe\n",
        "long_segments_df = gpd.GeoDataFrame(mls_per_id.geometry.explode())\n",
        "df_segments_wide = df_segments_wide.merge(long_segments_df, how='inner')\n",
        "df_segments_wide.shape"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "2c9faf42",
      "metadata": {},
      "source": [
        "### Apply width factor"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "c493347c",
      "metadata": {
        "gather": {
          "logged": 1705490205522
        }
      },
      "outputs": [],
      "source": [
        "# Add width factor, for calculating the weights of the paths later\n",
        "conditions = [\n",
        "    (df_segments_wide['min_width'] < st.width_1),\n",
        "    (df_segments_wide['min_width'] >= st.width_1) & (df_segments_wide['min_width'] < st.width_2),\n",
        "    (df_segments_wide['min_width'] >= st.width_2) & (df_segments_wide['min_width'] < st.width_3),\n",
        "    (df_segments_wide['min_width'] >= st.width_3) & (df_segments_wide['min_width'] < st.width_4),\n",
        "    (df_segments_wide['min_width'] >= st.width_4) & (df_segments_wide['min_width'] < st.width_5),\n",
        "    (df_segments_wide['min_width'] >= st.width_5) & (df_segments_wide['min_width'] < st.width_6),\n",
        "    (df_segments_wide['min_width'] >= st.width_6)\n",
        "]\n",
        "values_factor = [1000000000000, 10000000000, 100000000, 1000000, 10000, 100, 1]\n",
        "df_segments_wide['min_width_factor'] = np.select(conditions, values_factor).astype('int64')"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "4c484f08",
      "metadata": {},
      "source": [
        "### Take point cloud coverage into account"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "1490e750",
      "metadata": {
        "gather": {
          "logged": 1705490205964
        }
      },
      "outputs": [],
      "source": [
        "df_segments_wide['min_width_factor'][df_segments_wide['pc_coverage'] == False] = 100000000000001"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "1007b745",
      "metadata": {
        "gather": {
          "logged": 1705490206436
        }
      },
      "outputs": [],
      "source": [
        "df_segments_wide['min_width_factor'].value_counts()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ea288a1f",
      "metadata": {},
      "source": [
        "### Do network calculation"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "35b2a910",
      "metadata": {
        "gather": {
          "logged": 1705490206934
        }
      },
      "outputs": [],
      "source": [
        "df_bgt_exp['route_weight'] = np.nan\n",
        "print('start doing network calculation on ' + str(len(df_bgt_sw['sidewalk_id'])) + ' rows')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "f26bd1a9",
      "metadata": {
        "gather": {
          "logged": 1705491776096
        }
      },
      "outputs": [],
      "source": [
        "# Create final dataframe\n",
        "final_df = pd.DataFrame()\n",
        "\n",
        "for i in range(len(df_bgt_sw['sidewalk_id'])):\n",
        "    print(i)\n",
        "      \n",
        "    # Get sidewalk polygon for this centerline \n",
        "    my_sidewalk = df_bgt_sw['geometry'].values[i]   \n",
        "    \n",
        "    # Create graph for all paths withing this sidewalk polygon\n",
        "    df_sidewalk = df_segments_wide[df_segments_wide['geometry'].within(my_sidewalk)].reset_index(drop=True)\n",
        "    G = momepy.gdf_to_nx(df_sidewalk, approach=\"primal\", multigraph=True)\n",
        "    \n",
        "    # Create dataframe with linestrings of centerline\n",
        "    centerline_df = df_bgt_exp[df_bgt_exp['sidewalk_id'] == i].reset_index(drop=True)\n",
        "    \n",
        "    for j in range(len(centerline_df['geometry'])):  \n",
        "        \n",
        "        # Get line\n",
        "        my_line = centerline_df.iloc[[j]]['geometry'].values[0]\n",
        "        \n",
        "        if len(list(G.nodes)) > 0:\n",
        "            # Check if my_line has start and end (not a ring)\n",
        "            if len(my_line.boundary) == 0:\n",
        "                print('no route calculated for line (j)', j, 'in sidewalk (i)', i, '(ring)')\n",
        "                centerline_df['route_weight'][j] = 0\n",
        "            else:\n",
        "                # Get origin and destination location\n",
        "                origin_point, dest_point = my_line.boundary\n",
        "                origin_node_loc = so.nearest_points(origin_point, sg.MultiPoint(list(G.nodes)))[1]\n",
        "                dest_node_loc = so.nearest_points(dest_point, sg.MultiPoint(list(G.nodes)))[1]\n",
        "\n",
        "                # Get origin and destination node\n",
        "                origin_node = (origin_node_loc.x, origin_node_loc.y)\n",
        "                dest_node = (dest_node_loc.x, dest_node_loc.y)   \n",
        "\n",
        "                # Get weight of optimal route in graph\n",
        "                try:\n",
        "                    route_weight = nx.shortest_path_length(G, origin_node, dest_node,\n",
        "                                                           weight='min_width_factor')\n",
        "                    if (origin_point.distance(origin_node_loc) < st.max_dist) and (dest_point.distance(dest_node_loc) < st.max_dist):\n",
        "                        centerline_df['route_weight'][j] = route_weight\n",
        "                    else:\n",
        "                        print('origin and/or destination node too far from line start/end for line (j)', j, 'in sidewalk (i)', i) \n",
        "                        centerline_df['route_weight'][j] = np.nan\n",
        "                except nx.NetworkXNoPath:\n",
        "                    print('no route found for line (j)', j, 'in sidewalk (i)', i)\n",
        "                    centerline_df['route_weight'][j] = 100000000000000\n",
        "        else:\n",
        "            print('network has zero nodes')\n",
        "\n",
        "    # Append data to final dataframe\n",
        "    final_df = pd.concat([final_df, centerline_df])\n",
        "final_df = final_df.reset_index()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "82a25585",
      "metadata": {
        "gather": {
          "logged": 1705496302836
        }
      },
      "outputs": [],
      "source": [
        "# Get final width of the routes\n",
        "final_df['obstacle_free_width_float'] = final_df.progress_apply(    \n",
        "    lambda row: poly_utils.get_route_width(row.route_weight), axis=1)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "31919f60",
      "metadata": {},
      "source": [
        "## Post-process "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "a13648a3",
      "metadata": {
        "gather": {
          "logged": 1705496313320
        }
      },
      "outputs": [],
      "source": [
        "final_df = final_df.set_geometry('geometry')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "bdb19792-4290-4792-aaa1-88739faf2683",
      "metadata": {
        "gather": {
          "logged": 1705496318113
        },
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "outputs": [],
      "source": [
        "final_df['obstacle_free_width_float'].value_counts(dropna=False)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "73b01e52-f6cc-4a93-87b1-a5a71c2b3c14",
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "source": [
        "### Fix incorrect labeling of obstacle-free width (> full width)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "cdcb0e6c",
      "metadata": {
        "gather": {
          "logged": 1705496337894
        }
      },
      "outputs": [],
      "source": [
        "# Start a column to track any adjustments we make to the obstacle-free width\n",
        "final_df['width_fill'] = np.where(final_df['obstacle_free_width_float'] > final_df['full_width_float'], 1, 0)\n",
        "\n",
        "# If obstacle free width float is bigger than full width, set obstacle free width float to full width\n",
        "final_df['obstacle_free_width_float'] = np.where(final_df['obstacle_free_width_float'] > final_df['full_width_float'], final_df['full_width_float'], final_df['obstacle_free_width_float'])"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "48d50179",
      "metadata": {},
      "source": [
        "### Fix widths of 'inritten' \n",
        "These are not properly accounted for, as they were not included in the previous steps of the widths pipeline. \n",
        "Here, we assume that there are no obstacles on 'inritten'. Therefore, we can set the obstacle-free widths of these to the full widths.  \n",
        "This doesn't resolve the issue for 'voetgangersgebied' & 'woonerf', but here the above assumption would be too much of a stretch. (luckily there are only 2 'voetgangersgebieden' and 0 'woonerven' in our pilot area."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "c9d228ce",
      "metadata": {},
      "outputs": [],
      "source": [
        "# Get geometries of 'inritten'\n",
        "df_bgt_inrit_full = bgt_utils.get_bgt_data_for_bbox(st.bbox, ['BGT_WGL_inrit'])\n",
        "df_areas = gpd.read_file(cf.output_pilot_area)\n",
        "df_bgt_inrit = df_bgt_inrit_full.sjoin(df_areas, how='inner', predicate='within')[['geometry']]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e05411f8",
      "metadata": {},
      "outputs": [],
      "source": [
        "# Set width to full width if edge is (partly) within 'inrit' polygon\n",
        "final_df['width_fill'] = np.where(final_df['geometry'].intersects(df_bgt_inrit.unary_union), 9, final_df['width_fill'])\n",
        "final_df['obstacle_free_width_float'] = np.where(final_df['geometry'].intersects(df_bgt_inrit.unary_union), final_df['full_width_float'], final_df['obstacle_free_width_float'])\n",
        "final_df['obstacle_free_width_float'].value_counts(dropna=False)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "d4291543-bae7-4bd7-8bec-c3adadef297c",
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "source": [
        "### Fix unknown widths"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "3fa6b03a-0e33-4723-9ab3-f15676eae8e7",
      "metadata": {
        "gather": {
          "logged": 1705497263833
        },
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "outputs": [],
      "source": [
        "# Fill unknown widths with minimum width of neighbors\n",
        "for i, row in final_df.iterrows():\n",
        "    if math.isnan(row['obstacle_free_width_float']):\n",
        "        my_edge = row['geometry']\n",
        "        my_dist = final_df['geometry'].distance(my_edge)\n",
        "        my_nb_ids = my_dist.loc[my_dist == 0].index.tolist()\n",
        "        new_width = min(final_df['obstacle_free_width_float'].iloc[my_nb_ids])\n",
        "        if math.isnan(new_width):\n",
        "            # If no neighbors with known width are found, fill with lowest width category\n",
        "            final_df.loc[i, 'obstacle_free_width_float'] = st.min_path_width\n",
        "            final_df.loc[i, 'width_fill'] = 3\n",
        "        else:\n",
        "            final_df.loc[i, 'obstacle_free_width_float'] = new_width\n",
        "            final_df.loc[i, 'width_fill'] = 2\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "c365a5dd-d850-4e7b-b55c-11a452c3529f",
      "metadata": {
        "gather": {
          "logged": 1705498421755
        },
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "outputs": [],
      "source": [
        "final_df['obstacle_free_width_float'].value_counts(dropna=False)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "a1ca621e-a8f9-45fc-ad7e-44968af8d969",
      "metadata": {
        "gather": {
          "logged": 1705497264220
        },
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "outputs": [],
      "source": [
        "final_df['width_fill'].value_counts(dropna=False)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ffd88a06",
      "metadata": {},
      "source": [
        "### Set final indication"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "907bb619",
      "metadata": {
        "gather": {
          "logged": 1705497322190
        }
      },
      "outputs": [],
      "source": [
        "# Get dataframe with only valid lines\n",
        "final_df_select = final_df[final_df['obstacle_free_width_float'] != 0]\n",
        "final_df_select = final_df_select.reset_index(drop=True)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e24e0623",
      "metadata": {
        "gather": {
          "logged": 1705497364058
        }
      },
      "outputs": [],
      "source": [
        "# Add meter indication\n",
        "conditions = [\n",
        "    (final_df_select['obstacle_free_width_float'] == st.min_path_width),\n",
        "    (final_df_select['obstacle_free_width_float'] == st.width_1),   \n",
        "    (final_df_select['obstacle_free_width_float'] == st.width_2),\n",
        "    (final_df_select['obstacle_free_width_float'] == st.width_3),\n",
        "    (final_df_select['obstacle_free_width_float'] == st.width_4),\n",
        "    (final_df_select['obstacle_free_width_float'] == st.width_5),  \n",
        "    (final_df_select['obstacle_free_width_float'] == st.width_6),  \n",
        "    (final_df_select['obstacle_free_width_float'] == np.nan)\n",
        "]\n",
        "values_indication = ['<' + str(st.width_1) + 'm', \n",
        "                     str(st.width_1) + '-' + str(st.width_2) + 'm', \n",
        "                     str(st.width_2) + '-' + str(st.width_3) + 'm', \n",
        "                     str(st.width_3) + '-' + str(st.width_4) + 'm', \n",
        "                     str(st.width_4) + '-' + str(st.width_5) + 'm', \n",
        "                     str(st.width_5) + '-' + str(st.width_6) + 'm', \n",
        "                     '>' + str(st.width_6) + 'm',\n",
        "                    'unknown']\n",
        "final_df_select['obstacle_free_width'] = np.select(conditions, values_indication)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "b5ba9b38",
      "metadata": {},
      "source": [
        "### Adjust crs"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "65af7db5",
      "metadata": {
        "gather": {
          "logged": 1699628657686
        }
      },
      "outputs": [],
      "source": [
        "final_df_select = final_df_select.set_crs(st.CRS)  # TODO might be removed?\n",
        "print('finished post-processing')"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "01e3fb84-6bff-4536-bf47-433864a3e2e8",
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "source": [
        "## Merge with basic network"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "32851d3f",
      "metadata": {
        "gather": {
          "logged": 1705497404920
        }
      },
      "outputs": [],
      "source": [
        "# Select relevant columns for merging\n",
        "final_df_select = final_df_select[['geometry', 'obstacle_free_width', 'obstacle_free_width_float', 'width_fill', \n",
        "                                   'full_width', 'full_width_float']]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "fb654d39-336e-420e-86aa-5be255d2353d",
      "metadata": {
        "gather": {
          "logged": 1705497481900
        },
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "outputs": [],
      "source": [
        "# Do inner join with original network\n",
        "df_combined = pd.merge(df_bgt_nw, final_df_select, how='inner', left_on='centerlines', right_on='geometry')"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "10991d1e",
      "metadata": {},
      "source": [
        "## Store"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "37b29819-5145-4915-85c9-b50eaf9daaba",
      "metadata": {
        "gather": {
          "logged": 1705497519407
        },
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "outputs": [],
      "source": [
        "df_store = df_combined[['cl_id', 'centerlines', 'length', 'sidewalk_id', 'obstacle_free_width', 'obstacle_free_width_float', 'width_fill']]\n",
        "df_store = df_store.set_geometry('centerlines').set_crs(st.CRS)\n",
        "df_store.head()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "cf49eb75-7a2e-478f-9e1a-0dc7f2dc688c",
      "metadata": {
        "gather": {
          "logged": 1705497548799
        },
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "outputs": [],
      "source": [
        "df_store.to_file(cf.output_file_widths, driver='GPKG') \n",
        "print('stored final data')"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "5fdb9076-36f4-4c8d-8e5d-0109bb80d185",
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "source": [
        "## Visualize network including widths"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "6c784b8e-25d6-4faf-9e15-371494935575",
      "metadata": {
        "gather": {
          "logged": 1705498505068
        },
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "outputs": [],
      "source": [
        "# set True for satelite background, False for standard background\n",
        "satellite = False\n",
        "\n",
        "# Create Folium map\n",
        "map = folium.Map(\n",
        "    location=[52.350547922223434, 4.794019242371844], tiles=plot_utils.generate_map_params(satellite=satellite),\n",
        "    min_zoom=10, max_zoom=25, zoom_start=17,\n",
        "    zoom_control=True, control_scale=True, control=False\n",
        "    )\n",
        "\n",
        "# Add network with widths\n",
        "folium.GeoJson(data=df_store[df_store['obstacle_free_width_float'] == st.min_path_width], style_function=lambda x: {\"color\": \"darkred\"}).add_to(map)\n",
        "folium.GeoJson(data=df_store[df_store['obstacle_free_width_float'] == st.width_1], style_function=lambda x: {\"color\": \"red\"}).add_to(map)\n",
        "folium.GeoJson(data=df_store[df_store['obstacle_free_width_float'] == st.width_2], style_function=lambda x: {\"color\": \"orange\"}).add_to(map)\n",
        "folium.GeoJson(data=df_store[df_store['obstacle_free_width_float'] == st.width_3], style_function=lambda x: {\"color\": \"yellow\"}).add_to(map)\n",
        "folium.GeoJson(data=df_store[df_store['obstacle_free_width_float'] == st.width_4], style_function=lambda x: {\"color\": \"greenyellow\"}).add_to(map)\n",
        "folium.GeoJson(data=df_store[df_store['obstacle_free_width_float'] == st.width_5], style_function=lambda x: {\"color\": \"limegreen\"}).add_to(map)\n",
        "folium.GeoJson(data=df_store[df_store['obstacle_free_width_float'] == st.width_6], style_function=lambda x: {\"color\": \"green\"}).add_to(map)\n",
        "\n",
        "map "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "3d2b3107-3f3a-46c7-942e-6938a350f109",
      "metadata": {
        "gather": {
          "logged": 1705498628168
        },
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "outputs": [],
      "source": [
        "# Store map\n",
        "map.save(cf.network_map_widths)"
      ]
    }
  ],
  "metadata": {
    "kernel_info": {
      "name": "venv_rp2"
    },
    "kernelspec": {
      "display_name": "social_mobility_network_new",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.8.0"
    },
    "microsoft": {
      "host": {
        "AzureML": {
          "notebookHasBeenCompleted": true
        }
      },
      "ms_spell_check": {
        "ms_spell_check_language": "en"
      }
    },
    "nteract": {
      "version": "nteract-front-end@1.0.0"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}