Évaluer l’égalité verte urbaine en utilisant le portail de données ouvertes de Vienne

Évaluer l'égalité verte urbaine à Vienne grâce aux données ouvertes.

Malgré leurs nombreux avantages, l’accès à la nature et aux espaces verts devient de plus en plus difficile dans les zones fortement urbanisées. Certains craignent que les communautés défavorisées soient plus exposées à ces problèmes. Ici, je propose une approche basée sur les données pour explorer cette question.

Plus précisément, je pose une question de développement urbain qui suscite de plus en plus d’intérêt dans les cercles professionnels et les gouvernements locaux, maintenant appelée égalité verte. Ce concept fait référence aux disparités dans l’accès des personnes aux espaces verts dans différentes parties d’une ville donnée. Ici, j’explore sa dimension financière et je cherche à déterminer s’il existe des relations claires entre la surface verte disponible par habitant et le niveau économique de cette même unité urbaine.

Je vais explorer deux résolutions spatiales différentes de la ville – les quartiers et les districts de recensement – en utilisant les fichiers de formes Esri fournis par le portail de données ouvert du gouvernement autrichien. Je vais également intégrer des données statistiques tabulaires (population et revenu) dans les zones administratives géoréférencées. Ensuite, je superpose les zones administratives avec un ensemble de données sur les espaces verts officiels, en enregistrant l’emplacement de chaque espace vert dans un format géospatial. Ensuite, je combine ces informations et quantifie la taille de chaque district urbain en termes d’espace vert total par habitant. Enfin, je relie le statut financier de chaque zone, mesuré par le revenu net annuel, au ratio de la surface verte par habitant pour voir si des tendances se dégagent.

1. Source de données

Jetons un coup d’œil au portail de données ouvert du gouvernement autrichien ici.

Lorsque j’ai rédigé cet article, la traduction anglaise du site web ne fonctionnait pas vraiment, alors au lieu de m’appuyer sur mes 12 années de cours d’allemand oubliés depuis longtemps, j’ai utilisé DeepL pour naviguer à travers les sous-pages et les milliers d’ensembles de données.

• L’IA renforce considérablement les capacités des caméras de sécurité
• L’IA générative dans l’industrie de la santé a besoin d’une dose d’explicabilité.
• AnomalyGPT Détection d’anomalies industrielles à l’aide de LVLM

Ensuite, j’ai collecté quelques fichiers de données, à la fois géoréférencés (fichiers de formes Esri) et des données tabulaires simples, que j’utiliserai pour l’analyse ultérieure. Les données que j’ai collectées :

Limites – les limites administratives des unités spatiales suivantes à Vienne :

• Les limites administratives de Vienne
• Les limites administratives des 23 districts de Vienne
• Les limites administratives des 250 districts de recensement de Vienne

Utilisation des terres – informations sur l’emplacement des espaces verts et des zones construites :

• Green Belt Vienna City of Vienna visualisant les espaces verts existants et dédiés, composés de 1539 fichiers de polygones géospatiaux entourant les espaces verts

Statistiques – données sur la population et le revenu correspondant au niveau socio-économique d’une zone :

• Population par district, enregistrée annuellement depuis 2002, et stockée en fonction des groupes d’âge de 5 ans, du sexe et de la nationalité d’origine
• Population par district de recensement, enregistrée annuellement depuis 2008 et stockée en fonction de trois groupes d’âge irréguliers, du sexe et de l’origine
• Revenu net moyen depuis 2002 dans les districts de Vienne, exprimé en euros par employé et par an

De plus, j’ai stocké les fichiers de données téléchargés dans un dossier local appelé “data”.

2. Exploration de base des données

2.1 Limites administratives

Tout d’abord, lisez et visualisez les différents fichiers de formes contenant chaque niveau de limite administrative pour avoir une meilleure compréhension de la ville en question :

folder = 'data'admin_city = gpd.read_file(folder + '/LANDESGRENZEOGD')admin_district = gpd.read_file(folder + '/BEZIRKSGRENZEOGD')admin_census = gpd.read_file(folder + '/ZAEHLBEZIRKOGD')display(admin_city.head(1))display(admin_district.head(1))display(admin_census.head(1))

Remarquons ici que les noms de colonnes BEZNR et ZBEZ correspondent à l’ID du district et à l’ID du district de recensement, respectivement. De manière inattendue, ils sont stockés/interprétés sous des formats différents, numpy.float64 et str :

print(type(admin_district.BEZNR.iloc[0]))print(type(admin_census.ZBEZ.iloc[0]))pyth

Vérifions si nous avons effectivement 23 districts et 250 districts de recensement comme l’indiquait la documentation des fichiers de données :

print(len(set(admin_district.BEZNR)))print(len(set(admin_census.ZBEZ)))

Visualisons maintenant les limites – d’abord la ville, puis ses districts, puis les districts de recensement encore plus petits.

f, ax = plt.subplots(1,3,figsize=(15,5))admin_city.plot(ax=ax[0],       edgecolor = 'k',   linewidth = 0.5,   alpha = 0.9,   cmap = 'Reds')admin_district.plot(ax=ax[1],   edgecolor = 'k',   linewidth = 0.5,   alpha = 0.9,   cmap = 'Blues')admin_census.plot(ax=ax[2],     edgecolor = 'k',   linewidth = 0.5,   alpha = 0.9,   cmap = 'Purples')ax[0].set_title('Limites de la ville')ax[1].set_title('Limites des districts')ax[2].set_title('Limites des districts de recensement')

Ce code génère les visualisations suivantes de Vienne :

2.2 Espaces verts

Jetons également un coup d’œil à la répartition des espaces verts :

gdf_green  = gpd.read_file(folder + '/GRUENFREIFLOGD_GRUENGEWOGD')display(gdf_green.head(3))

Ici, on peut remarquer qu’il n’y a pas de moyen direct de relier les espaces verts (par exemple, aucun identifiant de district ajouté) aux quartiers – nous le ferons donc plus tard en manipulant les géométries pour trouver des chevauchements.

Visualisons maintenant cela :

f, ax = plt.subplots(1,1,figsize=(7,5))gdf_green.plot(ax=ax,    edgecolor = 'k',   linewidth = 0.5,   alpha = 0.9,   cmap = 'Greens')ax.set_title('Espaces verts à Vienne')

Ce code montre où se trouvent les espaces verts à Vienne :

Nous pouvons noter que les segments forestiers se trouvent toujours à l’intérieur de la limite administrative, ce qui implique que toutes les parties de la ville ne sont pas urbanisées et densément peuplées. Nous y reviendrons plus tard lors de l’évaluation de la superficie verte par habitant.

2.3 Données statistiques – population, revenu

Enfin, jetons un coup d’œil aux fichiers de données statistiques. La première différence majeure est que ceux-ci ne sont pas géoréférencés mais des tables csv simples :

df_pop_distr = pd.read_csv('vie-bez-pop-sex-age5-stk-ori-geo4-2002f.csv',   sep = ';',  encoding='unicode_escape',   skiprows = 1)df_pop_cens  = pd.read_csv('vie-zbz-pop-sex-agr3-stk-ori-geo2-2008f.csv',   sep = ';',  encoding='unicode_escape',   skiprows = 1)df_inc_distr = pd.read_csv('vie-bez-biz-ecn-inc-sex-2002f.csv',   sep = ';',  encoding='unicode_escape',   skiprows = 1)display(df_pop_distr.head(1))display(df_pop_cens.head(1))display(df_inc_distr.head(1))

3. Prétraitement des données

3.1. Préparation des fichiers de données statistiques

La sous-section précédente montre que les tables de données statistiques utilisent des conventions de dénomination différentes – elles utilisent des identifiants DISTRICT_CODE et SUB_DISTRICT_CODE au lieu de BEZNR et ZBEZ. Cependant, après avoir lu la documentation de chaque ensemble de données, il devient clair qu’il est facile de passer de l’un à l’autre, pour lesquels je présente deux petites fonctions dans la cellule suivante. Je traiterai simultanément les données au niveau des districts et des districts de recensement.

De plus, je m’intéresserai uniquement aux valeurs agrégées et aux points de données des informations statistiques (les plus récentes), tels que la population totale au dernier instantané. Ainsi, nettoyons ces fichiers de données et conservons les colonnes que j’utiliserai ultérieurement.

# ces fonctions convertissent les identifiants de district et de district de recensement pour être compatibles avec ceux trouvés dans les fichiers de formesdef transform_district_id(x):   return int(str(x)[1:3])def transform_census_district_id(x):   return int(str(x)[1:5])# sélectionner la dernière année de l'ensemble de donnéesdf_pop_distr_2 = df_pop_distr[df_pop_distr.REF_YEAR \  ==max(df_pop_distr.REF_YEAR)]df_pop_cens_2  = df_pop_cens[df_pop_cens.REF_YEAR \  ==max(df_pop_cens.REF_YEAR)]df_inc_distr_2 = df_inc_distr[df_inc_distr.REF_YEAR \  ==max(df_inc_distr.REF_YEAR)]# convertir les identifiants de districtdf_pop_distr_2['district_id'] = \  df_pop_distr_2.DISTRICT_CODE.apply(transform_district_id)df_pop_cens_2['census_district_id'] = \  df_pop_cens_2.SUB_DISTRICT_CODE.apply(transform_census_district_id)df_inc_distr_2['district_id'] = \  df_inc_distr_2.DISTRICT_CODE.apply(transform_district_id)# agréger les valeurs de populationdf_pop_distr_2 = df_pop_distr_2.groupby(by = 'district_id').sum()df_pop_distr_2['district_population'] = df_pop_distr_2.AUT + \  df_pop_distr_2.EEA  + df_pop_distr_2.REU  + df_pop_distr_2.TCNdf_pop_distr_2 = df_pop_distr_2[['district_population']]df_pop_cens_2 = df_pop_cens_2.groupby(by = 'census_district_id').sum()df_pop_cens_2['census_district_population'] = df_pop_cens_2.AUT \  + df_pop_cens_2.FORdf_pop_cens_2 = df_pop_cens_2[['census_district_population']]df_inc_distr_2['district_average_income'] = \  1000*df_inc_distr_2[['INC_TOT_VALUE']]df_inc_distr_2 = \  df_inc_distr_2.set_index('district_id')[['district_average_income']]# afficher les tables finaliséesdisplay(df_pop_distr_2.head(3))display(df_pop_cens_2.head(3))display(df_inc_distr_2.head(3))# et unifier les conventions de dénominationadmin_district['district_id'] = admin_district.BEZNR.astype(int)admin_census['census_district_id'] = admin_census.ZBEZ.astype(int)print(len(set(admin_census.ZBEZ)))

Vérifiez les valeurs totales de population calculées aux deux niveaux d’agrégation:

print(sum(df_pop_distr_2.district_population))print(sum(df_pop_cens_2.census_district_population))

Ces deux devraient fournir le même résultat – 1931593 personnes.

3.1. Préparation des fichiers de données géospatiales

Maintenant que nous avons terminé la préparation des données essentielles des fichiers statistiques, il est temps de faire correspondre les polygones des zones vertes aux polygones des zones administratives. Ensuite, calculons la couverture totale des zones vertes de chaque zone administrative. De plus, j’ajouterai également la couverture relative des zones vertes de chaque zone administrative par curiosité.

Pour obtenir des surfaces exprimées en unités SI, nous devons passer à un système de référence de coordonnées local appelé CRS (Coordinate Reference System), qui, dans le cas de Vienne, est EPSG:31282. Vous pouvez en savoir plus sur ce sujet, la projection cartographique et les systèmes de référence de coordonnées ici et ici.

# conversion de tous les GeoDataFrames en CRS localadmin_district_2 = \  admin_district[['district_id', 'geometry']].to_crs(31282)admin_census_2 = \   admin_census[['census_district_id', 'geometry']].to_crs(31282)gdf_green_2      = gdf_green.to_crs(31282)

Calculer la zone de l’unité administrative mesurée en unités SI:

admin_district_2['admin_area'] = \  admin_district_2.geometry.apply(lambda g: g.area)admin_census_2['admin_area'] = \   admin_census_2.geometry.apply(lambda g: g.area)display(admin_district_2.head(1))display(admin_census_2.head(1))

4. Calculer le ratio de la surface verte par habitant

4.1 Calculer la couverture de la surface verte dans chaque unité administrative

J’utiliserai la fonction de superposition de GeoPandas pour superposer ces deux GeoDataFrames de limites administratives avec le GeoDataFrame contenant les polygones de la zone verte. Ensuite, je calcule la surface de chaque section de la zone verte tombant dans différentes régions administratives. Ensuite, j’additionne ces surfaces au niveau de chaque zone administrative, à la fois les districts et les districts de recensement. À la dernière étape, pour chaque unité de résolution, j’ajoute les aires des unités administratives précédemment calculées et je calcule le ratio de la superficie totale à la surface verte pour chaque district et district de recensement.

gdf_green_mapped_distr = gpd.overlay(gdf_green_2, admin_district_2)
gdf_green_mapped_distr['green_area'] = \  gdf_green_mapped_distr.geometry.apply(lambda g: g.area) 
gdf_green_mapped_distr = \  gdf_green_mapped_distr.groupby(by = 'district_id').sum()[['green_area']]
gdf_green_mapped_distr = \  gpd.GeoDataFrame(admin_district_2.merge(gdf_green_mapped_distr, left_on = 'district_id', right_index = True))
gdf_green_mapped_distr['green_ratio'] = \  gdf_green_mapped_distr.green_area / gdf_green_mapped_distr.admin_area
gdf_green_mapped_distr.head(3)

gdf_green_mapped_cens = gpd.overlay(gdf_green_2, admin_census_2)
gdf_green_mapped_cens['green_area'] = \  gdf_green_mapped_cens.geometry.apply(lambda g: g.area)
gdf_green_mapped_cens = \  gdf_green_mapped_cens.groupby(by = 'census_district_id').sum()[['green_area']]
gdf_green_mapped_cens = \  gpd.GeoDataFrame(admin_census_2.merge(gdf_green_mapped_cens, left_on = 'census_district_id', right_index = True))
gdf_green_mapped_cens['green_ratio'] = gdf_green_mapped_cens.green_area / gdf_green_mapped_cens.admin_area
gdf_green_mapped_cens.head(3)

Enfin, visualisez le ratio de la zone verte par district et district de recensement ! Les résultats semblent très logiques, avec un niveau élevé de verdure dans les parties extérieures et beaucoup moins dans les zones centrales. De plus, les 250 districts de recensement montrent clairement une image plus détaillée et plus fine des caractéristiques des différents quartiers, offrant des informations plus approfondies et plus localisées aux urbanistes. En revanche, les informations au niveau des districts, avec dix fois moins d’unités spatiales, montrent plutôt des moyennes générales.

f, ax = plt.subplots(1,2,figsize=(17,5))
gdf_green_mapped_distr.plot(ax = ax[0],   column = 'green_ratio',   edgecolor = 'k',   linewidth = 0.5,   alpha = 0.9,    legend = True,  cmap = 'Greens')
gdf_green_mapped_cens.plot(ax = ax[1],   column = 'green_ratio',   edgecolor = 'k',   linewidth = 0.5,   alpha = 0.9,    legend = True,  cmap = 'Greens')

Ce bloc de code produit les cartes suivantes :

4.2 Ajouter les informations sur la population et le revenu pour chaque unité administrative

Dans la dernière étape de cette section, ajoutons les données statistiques aux zones administratives. Rappel : nous avons des données sur la population à la fois au niveau des districts et au niveau des districts de recensement. Cependant, je n’ai pu trouver des informations sur le revenu (indicateur de niveau socio-économique) qu’au niveau des districts. C’est un compromis habituel en science des données géospatiales. Alors qu’une dimension (la verdure) est beaucoup plus instructive à une résolution plus élevée (districts de recensement), les contraintes des données peuvent nous contraindre à utiliser une résolution plus basse de toute façon.

display(admin_census_2.head(2))
display(df_pop_cens_2.head(2))

gdf_pop_mapped_distr  = admin_district_2.merge(df_pop_distr_2, \  left_on = 'district_id', right_index = True)
gdf_pop_mapped_cens  = admin_census_2.merge(df_pop_cens_2, \  left_on = 'census_district_id', right_index = True)
gdf_inc_mapped_distr = admin_district_2.merge(df_inc_distr_2, \  left_on = 'district_id', right_index = True)
f, ax = plt.subplots(1,3,figsize=(15,5))
gdf_pop_mapped_distr.plot(column = 'district_population', ax=ax[0],     \  edgecolor = 'k', linewidth = 0.5, alpha = 0.9, cmap = 'Blues')
gdf_pop_mapped_cens.plot(column = 'census_district_population', ax=ax[1], \  edgecolor = 'k', linewidth = 0.5, alpha = 0.9, cmap = 'Blues')
gdf_inc_mapped_distr.plot(column = 'district_average_income', ax=ax[2],   \  edgecolor = 'k', linewidth = 0.5, alpha = 0.9, cmap = 'Purples')
ax[0].set_title('district_population')
ax[1].set_title('census_district_population')
ax[2].set_title('district_average_incomee')

Ce bloc de codes donne le résultat suivant :

4.3. Calcul de la surface verte par habitant

Récapitulons ce que nous avons maintenant, le tout intégré dans des shapefiles correspondant aux arrondissements et aux districts de recensement de Vienne :

Au niveau des arrondissements, nous avons le ratio de surface verte, la population et les données de revenu

Au niveau des districts de recensement, nous avons un ratio de surface verte et des données de population

Pour capturer simplement l’égalité verte, je fusionne les informations sur la taille absolue de la surface verte et la population dans les arrondissements et les districts de recensement, et je calcule la quantité totale de surface verte par habitant.

Jetons un coup d’œil à nos entrées – couverture verte et population :

# un tracé pour les arrondissementsf, ax = plt.subplots(1,2,figsize=(10,5))gdf_green_mapped_distr.plot(  ax = ax[0],   column = 'green_ratio',   edgecolor = 'k',   linewidth = 0.5,   alpha = 0.9,    cmap = 'Greens')gdf_pop_mapped_distr.plot(  ax = ax[1],   column = 'district_population',    edgecolor = 'k',   linewidth = 0.5,   alpha = 0.9,    cmap = 'Reds')ax[0].set_title('green_ratio')ax[1].set_title('district_population')# un tracé pour les districts de recensementf, ax = plt.subplots(1,2,figsize=(10,5))gdf_green_mapped_cens.plot(  ax = ax[0],   column = 'green_ratio',   edgecolor = 'k',   linewidth = 0.5,   alpha = 0.9,    cmap = 'Greens')gdf_pop_mapped_cens.plot(ax = ax[1],   column = 'census_district_population',  edgecolor = 'k',   linewidth = 0.5,   alpha = 0.9,    cmap = 'Reds')ax[0].set_title('green_ratio')ax[1].set_title('district_population')

Ce bloc de codes donne le résultat suivant :

Pour calculer la surface verte par habitant, je vais d’abord fusionner les dataframes de verdure et de population selon les étapes suivantes. Je le ferai via l’exemple des districts de recensement car leur résolution spatiale plus élevée nous permet d’observer de meilleurs motifs (s’il y en a). Assurons-nous de ne pas diviser par zéro et de suivre le bon sens ; supprimons donc les zones non peuplées.

gdf_green_pop_cens = \  gdf_green_mapped_cens.merge(gdf_pop_mapped_cens.drop( \    columns = ['geometry', 'admin_area']), left_on = 'census_district_id',\    right_on = 'census_district_id')[['census_district_id', \    'green_area', 'census_district_population',  'geometry']]gdf_green_pop_cens['green_area_per_capita'] = \  gdf_green_pop_cens['green_area'] / \  gdf_green_pop_cens['census_district_population']gdf_green_pop_cens = \  gdf_green_pop_cens[gdf_green_pop_cens['census_district_population']>0]f, ax = plt.subplots(1,1,figsize=(10,7))gdf_green_pop_cens.plot(  column = 'green_area_per_capita',   ax=ax,   cmap = 'RdYlGn',   edgecolor = 'k',   linewidth = 0.5)admin_district.to_crs(31282).plot(\  ax=ax, color = 'none', edgecolor = 'k', linewidth = 2.5)

Ce bloc de codes donne le résultat suivant :

Modifions un peu la visualisation :

f, ax = plt.subplots(1,1,figsize=(11,7))ax.set_title('Espace vert par habitant\n dans les districts de recensement de Vienne', fontsize = 18, pad = 30)gdf_green_pop_cens.plot(  column = 'green_area_per_capita',   ax=ax,   cmap = 'RdYlGn',   edgecolor = 'k',   linewidth = 0.5,   legend=True,   norm=matplotlib.colors.LogNorm(\    vmin=gdf_green_pop_cens.green_area_per_capita.min(), \    vmax=gdf_green_pop_cens.green_area_per_capita.max()), )admin_district.to_crs(31282).plot(  ax=ax, color = 'none', edgecolor = 'k', linewidth = 2.5)

Ce bloc de codes donne la figure suivante :

Et de même pour les districts :

# calculer les scores d'espace vert par habitantgdf_green_pop_distr = \  gdf_green_mapped_distr.merge(gdf_pop_mapped_distr.drop(columns = \  ['geometry', 'admin_area']), left_on = 'district_id', right_on = \   'district_id')[['district_id', 'green_area', 'district_population', \   'geometry']]gdf_green_pop_distr = \  gdf_green_pop_distr[gdf_green_pop_distr.district_population>0]gdf_green_pop_distr['green_area_per_capita'] = \  gdf_green_pop_distr['green_area'] / \  gdf_green_pop_distr['district_population']# visualiser la carte au niveau des districtsf, ax = plt.subplots(1,1,figsize=(10,8))ax.set_title('Espace vert par habitant dans les districts de Vienne', \   fontsize = 18, pad = 26)gdf_green_pop_distr.plot(column = 'green_area_per_capita', ax=ax, \  cmap = 'RdYlGn', edgecolor = 'k', linewidth = 0.5, legend=True, \  norm=matplotlib.colors.LogNorm(vmin=\  gdf_green_pop_cens.green_area_per_capita.min(), \  vmax=gdf_green_pop_cens.green_area_per_capita.max()), )admin_city.to_crs(31282).plot(ax=ax, \  color = 'none', edgecolor = 'k', linewidth = 2.5)

Ce bloc de codes donne la figure suivante :

Alors que les tendances significatives sont claires – la périphérie extérieure, plus d’espaces verts pour tout le monde, le centre-ville intégré, inversé. Cependant, ces deux graphiques, en particulier celui plus détaillé au niveau des districts de recensement, montrent clairement une variation dans la quantité d’espace vert dont les gens jouissent dans les différentes zones. Des recherches supplémentaires et l’intégration de sources de données supplémentaires, par exemple sur l’utilisation des terres, pourraient aider à expliquer pourquoi ces zones ont une plus grande superficie verte ou une plus grande population. Pour l’instant, profitons de cette carte et espérons que tout le monde trouve la bonne quantité de verdure chez soi !

# fusion des données sur l'espace vert, la population et les données financièresgdf_district_green_pip_inc = \  gdf_green_pop_distr.merge(gdf_inc_mapped_distr.drop(columns = \  ['geometry']))

Visualisez la relation entre les dimensions financières et les dimensions vertes :

f, ax = plt.subplots(1,1,figsize=(6,4))ax.plot(gdf_district_green_pip_inc.district_average_income, \  gdf_district_green_pip_inc.green_area_per_capita, 'o')ax.set_xscale('log')ax.set_yscale('log')ax.set_xlabel('district_average_income')ax.set_ylabel('green_area_per_capita')

Le résultat de ce bloc de code est le graphique de dispersion suivant :

À première vue, le graphique de dispersion ne montre pas particulièrement un lien fort entre les finances et l’accès des personnes aux espaces verts. Honnêtement, je suis un peu surpris par ces résultats – cependant, compte tenu des efforts conscients et de longue date de Vienne pour verdir leur ville, c’est peut-être pourquoi nous ne voyons pas de tendance majeure ici. Pour confirmer, j’ai également vérifié les corrélations entre ces deux variables :

print(spearmanr(gdf_district_green_pip_inc.district_average_income, gdf_district_green_pip_inc.green_area_per_capita))print(pearsonr(gdf_district_green_pip_inc.district_average_income, gdf_district_green_pip_inc.green_area_per_capita))

En raison de la distribution à queue lourde des données financières, je prendrais plus au sérieux la corrélation de Spearman (0,13) ici, mais même la corrélation de Pearson (0,30) implique une tendance relativement faible, ce qui confirme mes observations précédentes.

We will continue to update IPGirl; if you have any questions or suggestions, please contact us!