A7.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import pyproj\n",
    "import plotly.graph_objects as go\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load vehicle detections\n",
    "car_triangulations_df = pd.read_csv(\n",
    "    \"/home/sf_afn/Downloads/univrses_data/parked_car_triangulations_2023_04_24.csv\"\n",
    ")\n",
    "\n",
    "# Load the parking segments\n",
    "with open(\n",
    "    \"/home/sf_afn//Downloads/univrses_data/permitted_parking_linestrings.json\"\n",
    ") as user_file:\n",
    "    parking_json = json.load(user_file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "car_triangulations_df.head()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def convert_crs(triangulations_df):\n",
    "    \"\"\"\n",
    "    convert a point with epsg:4326 to epsg:3011\n",
    "\n",
    "    \"\"\"\n",
    "    transformer = pyproj.Transformer.from_crs(\"EPSG:4326\", \"EPSG:3011\")\n",
    "\n",
    "    x_3011 = []\n",
    "    y_3011 = []\n",
    "\n",
    "    for idx, row in triangulations_df.iterrows():\n",
    "        y, x = transformer.transform(row[\"latitude\"], row[\"longitude\"])\n",
    "        x_3011.append(x)\n",
    "        y_3011.append(y)\n",
    "\n",
    "    triangulations_df[\"x_3011\"] = x_3011\n",
    "    triangulations_df[\"y_3011\"] = y_3011\n",
    "    triangulations_df[\"xy_3011\"] = triangulations_df.apply(\n",
    "        lambda row: [row[\"x_3011\"], row[\"y_3011\"]], axis=1\n",
    "    )\n",
    "\n",
    "    return triangulations_df\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "car_triangulations_df = convert_crs(car_triangulations_df)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "car_triangulations_df.head()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "parking_json\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "parking_json.keys()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for p in parking_json[\"features\"]:\n",
    "    print(p[\"geometry\"][\"coordinates\"][0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = go.Figure()\n",
    "\n",
    "# plot permitted parking\n",
    "fig.add_trace(\n",
    "    go.Scatter(\n",
    "        x=[\n",
    "            p[0]\n",
    "            for f in parking_json[\"features\"]\n",
    "            for p in f[\"geometry\"][\"coordinates\"] + [[None, None]]\n",
    "        ],\n",
    "        y=[\n",
    "            p[1]\n",
    "            for f in parking_json[\"features\"]\n",
    "            for p in f[\"geometry\"][\"coordinates\"] + [[None, None]]\n",
    "        ],\n",
    "        name=\"permitted_parking\",\n",
    "    )\n",
    ")\n",
    "\n",
    "# plot triangulation point\n",
    "fig.add_trace(\n",
    "    go.Scatter(\n",
    "        x=car_triangulations_df[\"x_3011\"],\n",
    "        y=car_triangulations_df[\"y_3011\"],\n",
    "        name=\"car_detected\",\n",
    "        mode=\"markers\",\n",
    "    )\n",
    ")\n",
    "fig.update_yaxes(\n",
    "    scaleanchor=\"x\",\n",
    "    scaleratio=1,\n",
    ")\n",
    "\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# singular triangulation stuff\n",
    "\n",
    "car_triangulations_df.iloc[[2]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "car_triangulations_df[:2]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# def extract_triangulation_xy(triangulation_df):\n",
    "#     points = []\n",
    "#     for idx, row in triangulation_df.iterrows():\n",
    "#         # print(idx, row['x_3011'])\n",
    "#         point = [row[\"x_3011\"], row[\"y_3011\"]]\n",
    "#         points.append(point)\n",
    "#     return point"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# test_point = extract_triangulation_xy(car_triangulations_df.iloc[[42]])\n",
    "test_point = car_triangulations_df[\"xy_3011\"].iloc[42]\n",
    "test_point\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parking_proximity(tri_point, parking_json, radius):\n",
    "    \"\"\"\n",
    "    filter permitted parking within the distance of a particular point\n",
    "    \"\"\"\n",
    "    nearby_prkng_ids = []\n",
    "    for prkng_idx, p in enumerate(parking_json[\"features\"]):\n",
    "        for coords in p[\"geometry\"][\n",
    "            \"coordinates\"\n",
    "        ]:  # this is the node on the permitted  parking line?\n",
    "            distance = np.linalg.norm(np.array(tri_point) - np.array(coords))\n",
    "            if distance < radius:\n",
    "                nearby_prkng_ids.append(prkng_idx)\n",
    "                continue  # doing it for all the coords on pp line\n",
    "\n",
    "    return nearby_prkng_ids"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nb_p_ids = parking_proximity(test_point, parking_json, radius=20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nb_p_ids\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parking_line_at_index(parking_json, idx):\n",
    "    parking_line = parking_json[\"features\"][idx][\"geometry\"][\"coordinates\"]\n",
    "\n",
    "    return parking_line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_line = parking_line_at_index(parking_json, 2677)\n",
    "test_line\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig_1 = go.Figure()\n",
    "\n",
    "fig_1.add_trace(\n",
    "    go.Scatter(\n",
    "        x=[test_line[0][0], test_line[1][0]],\n",
    "        y=[test_line[0][1], test_line[1][1]],\n",
    "        name=\"line\",\n",
    "    )\n",
    ")\n",
    "\n",
    "fig_1.add_trace(\n",
    "    go.Scatter(\n",
    "        x=[test_point[0]],\n",
    "        y=[test_point[1]],\n",
    "        name=\"pointy\",\n",
    "        mode=\"markers\",\n",
    "    )\n",
    ")\n",
    "\n",
    "fig_1.update_yaxes(\n",
    "    scaleanchor=\"x\",\n",
    "    scaleratio=1,\n",
    ")\n",
    "\n",
    "fig_1.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ---> BK1\n",
    "\n",
    "fig = go.Figure()\n",
    "fig.add_trace(\n",
    "    go.Scatter(\n",
    "        x=[\n",
    "            p[0]\n",
    "            for idx in nb_p_ids\n",
    "            for p in parking_json[\"features\"][idx][\"geometry\"][\"coordinates\"]\n",
    "            + [[None, None]]\n",
    "        ],\n",
    "        y=[\n",
    "            p[1]\n",
    "            for idx in nb_p_ids\n",
    "            for p in parking_json[\"features\"][idx][\"geometry\"][\"coordinates\"]\n",
    "            + [[None, None]]\n",
    "        ],\n",
    "        name=\"parking_in_proximity\",\n",
    "    )\n",
    ")\n",
    "\n",
    "fig.add_trace(\n",
    "    go.Scatter(\n",
    "        x=[test_point[0]],\n",
    "        y=[test_point[0]],\n",
    "        name=\"car_triangulation\",\n",
    "        mode=\"markers\",\n",
    "    )\n",
    ")\n",
    "\n",
    "fig.update_yaxes(\n",
    "    scaleanchor=\"x\",\n",
    "    scaleratio=1,\n",
    ")\n",
    "\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# nearby_\n",
    "# for each in tri_points:\n",
    "# nearby_ids = praking_proximity(each,parking_json, radius = 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def project_point_on_line_segment(tri_point, parking_line):\n",
    "    \"\"\"Calculate the projection of a point on a line segment using numpy.\"\"\"\n",
    "    # Define the two points of the line segment\n",
    "    p1, p2 = np.array(parking_line)\n",
    "\n",
    "    # Calculate the vector between the two points\n",
    "    v = p2 - p1\n",
    "\n",
    "    # Normalize the vector\n",
    "    v_norm = v / np.linalg.norm(v)\n",
    "\n",
    "    # Calculate the vector between the first point of the line segment and the point we want to project\n",
    "    u = tri_point - p1\n",
    "\n",
    "    # Calculate the dot product of the normalized vector and the vector we just calculated\n",
    "    dot_product = np.dot(u, v_norm)\n",
    "\n",
    "    # Multiply the dot product by the normalized vector\n",
    "    projection = p1 + dot_product * v_norm\n",
    "\n",
    "    # Check if the projection is within the line segment\n",
    "    if np.dot(projection - p1, v) < 0:\n",
    "        projection = p1\n",
    "    elif np.dot(projection - p2, v) > 0:\n",
    "        projection = p2\n",
    "\n",
    "    return projection\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_point_projection = project_point_on_line_segment(test_point, test_line)\n",
    "test_point_projection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# find all the projections for a point so far\n",
    "\n",
    "car_triangulations_df\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "car_triangulations_df[\"xy_3011\"].unique\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "prkng_v2_env",
   "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.11.3"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}