Perimetres_BV_REU_Etalab_2022.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tracer les périmètres des bureaux de vote à partir des adresses des électeurs \n",
    "- Traitement de l'extrait anonymisé du Répertoire électoral unique, publié par l'Insee (version 27/06/2023)\n",
    "https://www.data.gouv.fr/fr/datasets/bureaux-de-vote-et-adresses-de-leurs-electeurs/ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "pd.set_option(\"display.max_columns\", None)\n",
    "pd.set_option('display.max_rows', 300)\n",
    "pd.set_option('display.float_format', lambda x: '%.9f' % x)\n",
    "from pathlib import Path\n",
    "import numpy as np\n",
    "import geopandas as gpd\n",
    "from shapely.ops import unary_union\n",
    "from geovoronoi.plotting import subplot_for_map, plot_voronoi_polys_with_points_in_area\n",
    "from geovoronoi import voronoi_regions_from_coords, points_to_coords"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Préparation des données"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/denisvannier/opt/anaconda3/envs/DATAXPLORE/lib/python3.9/site-packages/IPython/core/interactiveshell.py:3553: DtypeWarning: Columns (0) have mixed types.Specify dtype option on import or set low_memory=False.\n",
      "  exec(code_obj, self.user_global_ns, self.user_ns)\n"
     ]
    }
   ],
   "source": [
    "# Chargement de l'extrait anonymisé du REU : \n",
    "adresses=pd.read_csv(\"Data_REU_Etalab/table-adresses-reu.csv\")\n",
    "\n",
    "adresses[\"id_brut_bv_reu\"]=adresses[\"id_brut_bv_reu\"].astype(\"str\")\n",
    "adresses[\"BV\"]=adresses[\"id_brut_bv_reu\"].str.split(\"_\").str[-1]\n",
    "adresses[\"code_commune_ref\"]=adresses[\"code_commune_ref\"].astype(\"str\")\n",
    "adresses.loc[adresses[\"code_commune_ref\"].str.len()==4, \"INSEE_COM\"]=\"0\"+adresses[\"code_commune_ref\"]\n",
    "adresses.loc[adresses[\"code_commune_ref\"].str.len()==5, \"INSEE_COM\"]=adresses[\"code_commune_ref\"]\n",
    "\n",
    "adresses.rename(columns={\"id_brut_bv_reu\":\"CODE_BV\"}, inplace=True)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nettoyage des adresses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/denisvannier/opt/anaconda3/envs/DATAXPLORE/lib/python3.9/site-packages/pandas/util/_decorators.py:311: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  return func(*args, **kwargs)\n",
      "/var/folders/zf/sc5qjn6x54b02sbxg3k9jbkr0000gn/T/ipykernel_55066/1833319764.py:22: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  Conflits[\"LatLong\"]=Conflits[\"latitude\"].astype(\"str\")+\"_\"+Conflits[\"longitude\"].astype(\"str\")\n"
     ]
    }
   ],
   "source": [
    "# Sélection des communes constituées d'un seul bureau de vote :\n",
    "Mono_BV=adresses[adresses[\"nb_bv_commune\"]==1]\n",
    "Com_MonoBV=Mono_BV[\"INSEE_COM\"].unique().tolist()\n",
    "# Les contours de ces bureaux de vote uniques seront tout simplement les limites de la commune.\n",
    "\n",
    "# Sélection des communes qui comprennent plusieurs bureaux de vote :\n",
    "Multi_BV=adresses[adresses[\"nb_bv_commune\"]!=1]\n",
    "Com_MultiBV=Multi_BV[\"INSEE_COM\"].unique().tolist()\n",
    "\n",
    "# Si plusieurs points d'adresses partagent à la fois les mêmes coordonnées géographiques et le même bureau de vote, \n",
    "# on les fusionne en additionnant leur nombre d'adresse, \n",
    "Doublons=Multi_BV[Multi_BV.duplicated(subset=[\"longitude\",\"latitude\",\"CODE_BV\"], keep=False)]\n",
    "Doublons=Doublons.groupby([\"CODE_BV\",\"longitude\",\"latitude\"]).agg({\"nb_adresses\": \"sum\",\"INSEE_COM\":\"first\"}).reset_index(drop=False)\n",
    "Multi_BV.drop_duplicates(subset=[\"longitude\",\"latitude\",\"CODE_BV\"], keep=False, inplace=True)\n",
    "Multi_BV=pd.concat([Multi_BV,Doublons])\n",
    "\n",
    "# Si plusieurs points d'adresses partagent les mêmes coordonnées géographiques mais sont rattachés à des bureaux de vote différents,\n",
    "# ça crée une ambiguité lors de la création des diagrammes de voronoï. \n",
    "# On choisit donc de supprimer les lignes correspondantes qui rassemblent le moins d'adresse (variable \"nb_adresse\") \n",
    "# Ce qui supprime 521 308 lignes d'adresses, soit 4,6% du fichier des communes à plusieurs bureaux de vote\n",
    "Conflits=Multi_BV[Multi_BV.duplicated(subset=[\"longitude\",\"latitude\"], keep=False)]\n",
    "Conflits[\"LatLong\"]=Conflits[\"latitude\"].astype(\"str\")+\"_\"+Conflits[\"longitude\"].astype(\"str\")\n",
    "ConflitsGroup=Conflits.groupby([\"LatLong\"]).agg({\"nb_adresses\": \"sum\"}).reset_index(drop=False)\n",
    "ConflitsGroup.rename(columns={\"nb_adresses\":\"nb_total_adresses\"}, inplace=True)\n",
    "\n",
    "Multi_BV[\"LatLong\"]=Multi_BV[\"latitude\"].astype(\"str\")+\"_\"+Multi_BV[\"longitude\"].astype(\"str\")\n",
    "Multi_BV=Multi_BV.merge(ConflitsGroup, on=\"LatLong\", how=\"left\")\n",
    "\n",
    "Multi_BV.loc[Multi_BV[\"nb_total_adresses\"].isna(), \"nb_total_adresses\"]=Multi_BV[\"nb_adresses\"]\n",
    "Multi_BV=Multi_BV[Multi_BV[\"nb_adresses\"]>(Multi_BV[\"nb_total_adresses\"]/2)]\n",
    "\n",
    "Multi_BV=Multi_BV[['CODE_BV','INSEE_COM','nb_adresses','nb_bv_commune','longitude','latitude']]\n",
    "\n",
    "# Cette opération peut créer des erreurs à la marge, en supprimant des points d'adresses de bureaux de vote entier, ce qui bloque l'étape voronoï\n",
    "# On identifie ces communes à problèmes :\n",
    "BV_Communes=Multi_BV.groupby(\"INSEE_COM\").agg({\"nb_bv_commune\": \"first\", \"CODE_BV\": \"nunique\"}).reset_index(drop=False)\n",
    "BV_Communes.rename(columns={\"nb_bv_commune\":\"Nb_BV_theorique\", \"CODE_BV\":\"Nb_BV_disponible\"}, inplace=True)\n",
    "BV_Communes[\"Diff\"]=BV_Communes[\"Nb_BV_theorique\"]-BV_Communes[\"Nb_BV_disponible\"]\n",
    "\n",
    "# Ce qui permet de lister les 9 communes comprenant plusieurs bureaux de vote en théorie, mais avec un seul bureau dans les données,\n",
    "Erreurs=BV_Communes[(BV_Communes[\"Nb_BV_disponible\"]==1)]\n",
    "Com_Erreurs=Erreurs[\"INSEE_COM\"].unique().tolist()\n",
    "# Les autres communes ayant généré des erreurs lors des premiers traitements sont ajoutées ici : \n",
    "Com_Bug=['13002','97502','30045','2A141','13118','13051', '13052', '13119', '97356']\n",
    "Com_marbre=Com_Erreurs+Com_Bug\n",
    "# On exporte les points d'adresses qui correspondent à ces communes, afin de les découper ultérieurement dans Qgis\n",
    "Multi_BV_Erreurs=Multi_BV[Multi_BV[\"INSEE_COM\"].isin(Com_marbre)]\n",
    "Multi_BV_Erreurs.to_csv(\"adresses_communes_erreurs_BV.csv\")\n",
    "# Et enfin on retire les points d'adresse de ces communes du dataframe à traiter :\n",
    "Multi_BV=Multi_BV[~Multi_BV[\"INSEE_COM\"].isin(Com_marbre)]\n",
    "\n",
    "# On identifie également les 16 communes dont le nombre de bureau de vote présents dans les données est inférieur au nombre théorique \n",
    "# (il s'agit parfois de bureaux \"complémentaires\", réunissant des électeurs qui n'ont pas de domicile dans la commune)\n",
    "Alerte=BV_Communes[(BV_Communes[\"Diff\"]>=1) & (BV_Communes[\"Nb_BV_disponible\"]>=2)]\n",
    "Com_Alerte=Alerte[\"INSEE_COM\"].unique().tolist()\n",
    "# ['06151', '13005', '13209', '13211', '13214', '33165', '34123', '51612', '52140', '75110', '79196', '89086', '97120', '97228', '97353', '97415']\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Préparation du découpage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convertir la liste des adresses géocodées en fichier géographique :\n",
    "Points_Adresses=gpd.GeoDataFrame(Multi_BV, geometry=gpd.points_from_xy(Multi_BV.longitude, Multi_BV.latitude), crs=\"EPSG:4326\")\n",
    "Points_Adresses = Points_Adresses[[\"INSEE_COM\",\"CODE_BV\",\"nb_bv_commune\",\"nb_adresses\",\"geometry\"]]\n",
    "\n",
    "# importer les délimitations des communes :\n",
    "# Source : IGN - Admin Express édition Juin 2022 https://geoservices.ign.fr/adminexpress \n",
    "communes=\"Communes_Admin_Express_2022/COMMUNE.shp\"\n",
    "com=gpd.read_file(communes)[[\"INSEE_COM\",\"geometry\",\"NOM\"]]\n",
    "# Ajouter les arrondissements de Paris, Lyon et Marseille :\n",
    "Paris_Lyon_Marseille=[\"75056\",\"69123\",\"13055\"]\n",
    "com.drop(com[com[\"INSEE_COM\"].isin(Paris_Lyon_Marseille)].index, inplace=True)\n",
    "arrond=gpd.read_file(\"Communes_Admin_Express_2022/ARRONDISSEMENT_MUNICIPAL.shp\")[[\"INSEE_ARM\",\"geometry\",\"NOM\"]]\n",
    "arrond.rename(columns={\"INSEE_ARM\":\"INSEE_COM\"}, inplace=True)\n",
    "com_all=pd.concat([com, arrond])\n",
    "com_all.rename(columns={\"NOM\":\"COMMUNE\"}, inplace=True)\n",
    "\n",
    "# Adapter le système de projection pour permettre un traitement par Geovoronoi (reprojection en World Mercator EPSG:3395) :\n",
    "com_all = com_all.to_crs(\"EPSG:3395\")\n",
    "Points_Adresses = Points_Adresses.to_crs(com_all.crs)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Boucle de découpage des départements en bureaux de votes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/denisvannier/opt/anaconda3/envs/DATAXPLORE/lib/python3.9/site-packages/geopandas/geodataframe.py:1351: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  super().__setitem__(key, value)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mapshaper -i Export_MultiBV/Bvote_Voronoi_Dep_97.geojson \\\n",
      "\t-dissolve2 fields=CODE_BV copy-fields=COMMUNE,INSEE_COM,DEP,nb_bv_commune \\\n",
      "\t-o Export_Propre/Bvote_Propre_Dep_97.geojson\n",
      "[dissolve2] Removed 1,649 / 1,705 slivers using 220+ sqm variable threshold\n",
      "[dissolve2] Dissolved 259,215 features into 1,987 features\n",
      "[o] Wrote Export_Propre/Bvote_Propre_Dep_97.geojson\n",
      "mapshaper -i Export_Propre/Bvote_Propre_Dep_97.geojson -simplify 15% -filter-slivers min-area=\"0.005km2\" -o force Export_Propre/Bvote_Propre_Dep_97.geojson\n",
      "[simplify] Repaired 54 intersections\n",
      "[filter-slivers] Removed 9,844 slivers using 5000+ sqm variable threshold\n",
      "[o] Wrote Export_Propre/Bvote_Propre_Dep_97.geojson\n",
      "rm Export_Voronoi/*.geojson\n",
      "mapshaper -i Export_MultiBV/Bvote_Voronoi_Dep_75.geojson \\\n",
      "\t-dissolve2 fields=CODE_BV copy-fields=COMMUNE,INSEE_COM,DEP,nb_bv_commune \\\n",
      "\t-o Export_Propre/Bvote_Propre_Dep_75.geojson\n",
      "[dissolve2] Removed 1,268 / 1,268 slivers using 39+ sqm variable threshold\n",
      "[dissolve2] Dissolved 71,127 features into 897 features\n",
      "[o] Wrote Export_Propre/Bvote_Propre_Dep_75.geojson\n",
      "mapshaper -i Export_Propre/Bvote_Propre_Dep_75.geojson -simplify 15% -filter-slivers min-area=\"0.005km2\" -o force Export_Propre/Bvote_Propre_Dep_75.geojson\n",
      "[simplify] Repaired 1 intersection\n",
      "[filter-slivers] Removed 264 slivers using 5000+ sqm variable threshold\n",
      "[o] Wrote Export_Propre/Bvote_Propre_Dep_75.geojson\n",
      "rm Export_Voronoi/*.geojson\n"
     ]
    }
   ],
   "source": [
    "# Liste de tous les départements :\n",
    "Depart=com_all[\"INSEE_COM\"].str[:2].unique().tolist()\n",
    "#### Si la boucle est interrompue, nettoyer le dossier \"Export_Voronoi\" et mettre à jour la liste \"Depart avec\" les codes départements déjà traités : \n",
    "    # ! make clean\n",
    "    # Depart_done=['XX', 'XX', 'XX']\n",
    "    # Depart = [e for e in Depart if e not in (Depart_done)]\n",
    "\n",
    "for departement in Depart: \n",
    "    # Filtrer les adresses des communes de plusieurs bureaux de votes, inclues dans le département :\n",
    "    Dep=Points_Adresses[Points_Adresses[\"INSEE_COM\"].str.startswith(departement)]\n",
    "    # Lister les code Insee de ces communes : \n",
    "    communes_multiBV=Dep[\"INSEE_COM\"].unique().tolist()\n",
    "\n",
    "    # Lister les code Insee des communes de ce département qui ne comprennent qu'un seul bureau de vote : \n",
    "    monoBV=adresses[adresses[\"INSEE_COM\"].str.startswith(departement)]\n",
    "    monoBV=monoBV[monoBV[\"nb_bv_commune\"]==1]\n",
    "    monoBV[\"code_commune_ref\"]=monoBV[\"code_commune_ref\"].astype(\"str\")\n",
    "    monoBV.loc[monoBV[\"code_commune_ref\"].str.len()==4, \"INSEE_COM\"]=\"0\"+monoBV[\"code_commune_ref\"]\n",
    "    monoBV.loc[monoBV[\"code_commune_ref\"].str.len()==5, \"INSEE_COM\"]=monoBV[\"code_commune_ref\"]\n",
    "    communes_monoBV=monoBV[\"INSEE_COM\"].unique().tolist()\n",
    "\n",
    "    # Dans le périmètre de chaque commune, tracer les diagrammes de voronoi autour de chaque électeur, \n",
    "    # puis les fusionner par bureau de vote et les exporter dans un fichier geojson :\n",
    "    for insee in communes_multiBV:\n",
    "        # sélection du contour communal et des adresses géolocalisées de la commune traitée :\n",
    "        com=com_all[com_all[\"INSEE_COM\"]==insee]\n",
    "        elect=Dep[Dep[\"INSEE_COM\"]==insee]\n",
    "        # Préparation des données du périmètre de la commune: \n",
    "        boundary_shape = unary_union(com.geometry)\n",
    "        # Un filtre qui exclut les adresses se trouvant en dehors du périmètre de la commune (sinon cause d'erreur qui stoppe la boucle)\n",
    "        elect=elect[elect.geometry.within(boundary_shape)]\n",
    "        # Préparation des données des adresses :\n",
    "        coords = points_to_coords(elect.geometry)\n",
    "        # création des diagrammes de Voronoï\n",
    "        poly_shapes,poly_to_pt_assignments = voronoi_regions_from_coords(coords, boundary_shape)\n",
    "        # on transforme les données obtenues en geodataframe :\n",
    "        vor = gpd.GeoSeries(poly_shapes, crs=\"EPSG:3395\")\n",
    "        voronoi = gpd.GeoDataFrame(vor, columns=[\"geometry\"],crs=\"EPSG:3395\")\n",
    "        # On reprojette les polygones voronoï et les points d'adresses en WGS84 :\n",
    "        voronoi_ok=voronoi.to_crs(\"EPSG:4326\")\n",
    "        elect_ok=elect.to_crs(\"EPSG:4326\")\n",
    "        # On fait une jointure spatiale pour attribuer le code de bureau de vote et le code insee à chaque polygone Voronoï :\n",
    "        result=voronoi_ok.sjoin(elect_ok)\n",
    "        # Idéalement, à ce stade, on fusionne les polygones de Voronoi partageant le même CODE_BV\n",
    "        # mais trop d'erreurs liées à des \"géométries invalides\". On passera donc par Mapshaper, plus fiable pour cette opération.\n",
    "        # bvote=result.dissolve(by=\"CODE_BV\")\n",
    "        result.to_file(\"Export_Voronoi/\"+insee+\"_voronoi_bvote.geojson\")\n",
    "\n",
    "    # Rassembler tous les fichiers Voronoï du département :\n",
    "    from pathlib import Path\n",
    "    folder = Path(\"Export_Voronoi/\")\n",
    "    voronoi = folder.glob(\"*_voronoi_bvote.geojson\")\n",
    "    bvote_all = pd.concat([\n",
    "        gpd.read_file(shp)\n",
    "        for shp in voronoi\n",
    "    ]).pipe(gpd.GeoDataFrame)\n",
    "    bvote_all=bvote_all.to_crs(\"EPSG:4326\")\n",
    "    # Ajouter les contours des communes comprenant un seul bureau de vote : \n",
    "    com_monoBV = com_all.to_crs(\"EPSG:4326\")\n",
    "    com_monoBV_Dep=com_monoBV[com_monoBV[\"INSEE_COM\"].isin(communes_monoBV)]\n",
    "    com_monoBV_Dep[\"CODE_BV\"]=com_monoBV_Dep[\"INSEE_COM\"]+\"_1\"\n",
    "\n",
    "    Bvote_Dep=pd.concat([bvote_all, com_monoBV_Dep])\n",
    "    Bvote_Dep.drop(columns={\"index_right\"}, inplace=True)\n",
    "    Bvote_Dep[\"INSEE_COM\"]=Bvote_Dep[\"INSEE_COM\"].str[:5]\n",
    "    Bvote_Dep[\"DEP\"]=Bvote_Dep[\"INSEE_COM\"].str[:2]\n",
    "    Noms_com=com_all[[\"INSEE_COM\",\"COMMUNE\"]]\n",
    "    Bvote_Dep=Bvote_Dep.merge(Noms_com, on=\"INSEE_COM\", how=\"left\")\n",
    "    Bvote_Dep.drop(columns={\"COMMUNE_x\"}, inplace=True)\n",
    "    Bvote_Dep.rename(columns={\"COMMUNE_y\":\"COMMUNE\"}, inplace=True)\n",
    "    Bvote_Dep=Bvote_Dep[[\"COMMUNE\",\"DEP\",\"INSEE_COM\",\"CODE_BV\",\"nb_bv_commune\",\"geometry\"]]\n",
    "    Bvote_Dep.to_file(\"Export_MultiBV/Bvote_Voronoi_Dep_\"+departement+\".geojson\")\n",
    "\n",
    "    # Exécuter les commandes Mapshaper dans le makefile pour fusionner les diagrammes de voronoï\n",
    "    # supprimer les ilôts de moins de 0,005km2, simplifier les contours à 15%,\n",
    "    # puis exporter un fichier geojson des bureaux de vote du département :\n",
    "    ! make BVote NOM=$departement\n",
    "    ! make simplifier NOM=$departement\n",
    "    # Vider le dossier Export-Voronoi :\n",
    "    ! make clean\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "DATAXPLORE",
   "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.9.9"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}