Reference mapper

Référence des cartes statiques et interactives.

Fonctions

  • read_image
  • plot_choropleth
  • Choroplèthe bivariée : plot_bivariate_choropleth, plot_bivariate_legend, assign_bivariate_classes, classify_variable, get_bivariate_palette, generate_bivariate_palette, list_bivariate_palettes, preview_bivariate_palette, BIVARIATE_PALETTES
  • Grille hexagonale : make_hex_grid, aggregate_to_hex, plot_hexgrid_choropleth

Classes

  • Map
  • Map2D
  • WebMap
  • SituationMap

Organisation

cartograpy.mapper est un sous-package, un fichier par classe :

Fichier Contenu
helpers.py read_image, plot_choropleth
map.py Map : la classe principale, cartes statiques matplotlib/cartopy
map2d.py Map2D (hérite de Map) : cartes sans projection cartographique
webmap.py WebMap : cartes interactives Folium/Leaflet
situation.py SituationMap : carte + mini-carte de localisation
bivariate.py choroplèthes bivariées (croisement de deux variables)
hexgrid.py grilles hexagonales et cartes hexbin (via geohexgrid)

Tout reste importable depuis cartograpy.mapper directement (from cartograpy.mapper import Map).

Map concentre encore la majorité de la logique (création, couches, légende, échelle, flèche du nord, export…) dans une seule classe volumineuse : un découpage interne en mixins thématiques n’a pas encore été fait.

Constructeur de Map

Map(figsize=(12, 8), title="", projection=ccrs.PlateCarree(),
    data_crs="EPSG:4326", dpi=300, verbose=True, basemap=True)
  • figsize (tuple, str ou dict, défaut (12, 8)) : taille en pouces, format papier ("A4", "A3"…) ou {"paper": ..., "orientation": ...}.
  • title (str, défaut "") : titre de la carte : vide par défaut, aucun titre n’est affiché.
  • projection (cartopy.crs, défaut ccrs.PlateCarree()) : projection cartographique de l’axe.
  • data_crs (str, défaut "EPSG:4326") : CRS supposé des données ajoutées.
  • dpi (int, défaut 300) : résolution de la figure.
  • verbose (bool, défaut True) : afficher les messages d’information.
  • basemap (bool, défaut True) : ajouter automatiquement côtes et frontières (cfeature.BORDERS, coastlines). Mettre False pour une carte vierge : garde la projection cartopy (donc add_north_arrow/add_scale_bar/add_inset_map restent utilisables), contrairement à Map2D qui abandonne la projection cartopy entièrement.
# Carte sans côtes ni frontières automatiques, mais avec projection cartopy
m = Map(title="Carte vierge", basemap=False)
m.add_polygons(mon_gdf, facecolor="lightyellow")
m.add_north_arrow()
m.show()

Méthodes de Map

69 méthodes publiques, groupées par thème. Signature complète (avec valeurs par défaut) et description en une ligne : pour les paramètres en détail, se référer au docstring de la méthode dans cartograpy/mapper/map.py.

set_paper(paper_format, orientation='landscape')

Définit le format de papier et l’orientation de la carte.

list_paper_formats()

Affiche tous les formats de papier disponibles avec leurs dimensions.

set_background_color(color='white')

Définit la couleur de fond de la carte.

set_extent(bounds, crs=None)

Définit les limites de la carte. bounds au format cartopy [x0, x1, y0, y1] (ouest, est, sud, nord). self.bounds reste mémorisé en [minx, miny, maxx, maxy] pour le reste de l’API (add_background_image, centrage…).

set_projection(projection)

Change la projection de la carte (nécessite de recréer l’axe).

center_on_bounds(bounds, margin='auto')

Centre la carte sur des limites spécifiques avec marges adaptées.

get_optimal_margins()

Retourne les marges optimales pour le format de papier actuel.

zoom_to_layer(index=None, label=None, margin=0.05)

Zoome sur l’étendue d’une couche spécifique.

hide_gridline()

Masque toutes les bordures, ticks et labels de l’axe.

add_layer(data=None, layer_type='auto', label=None, name=None, style=None, **style_kwargs)

Ajoute une couche générique à la carte (vecteur ou raster).

add_points(gdf, label=None, color='red', size=50, marker='o', alpha=1.0, edge_color='black', linewidth=0.5, column=None, scheme=None, cmap='viridis', **kwargs)

Ajoute des points à partir d’un GeoDataFrame.

add_lines(gdf, label=None, color='blue', linewidth=2, linestyle='-', alpha=1.0, column=None, scheme=None, cmap='viridis', **kwargs)

Ajoute des lignes à partir d’un GeoDataFrame.

add_polygons(gdf, label=None, facecolor='green', alpha=0.5, edge_color='black', linewidth=1, column=None, scheme=None, cmap='viridis', **kwargs)

Ajoute des polygones à partir d’un GeoDataFrame.

add_point(coordinates, label=None, color='red', size=50, marker='o', alpha=1.0, edge_color='black', linewidth=0.5, transform=None)

Ajoute un ou plusieurs points à la carte (coordonnées brutes, pas de GeoDataFrame).

add_line(coordinates, label=None, color='blue', linewidth=2, linestyle='-', alpha=1.0, transform=None)

Ajoute une ou plusieurs lignes à la carte (coordonnées brutes).

add_polygon(coordinates, label=None, color='green', alpha=0.5, edge_color='black', linewidth=1, fill=True, transform=None)

Ajoute un ou plusieurs polygones à la carte (coordonnées brutes).

add_raster(raster_path=None, raster_array=None, extent=None, cmap='viridis', alpha=0.7, vmin=None, vmax=None, transform=None, title=None, show_colorbar=True)

Ajoute une couche raster à la carte.

add_natural_features(features=['coastline', 'borders'], coastline_color='black', coastline_width=0.5, border_color='gray', border_width=0.5, land_color=None, ocean_color=None, lakes=False, rivers=False)

Ajoute des caractéristiques naturelles (côtes, frontières, lacs, rivières) via cartopy.

add_basemap(source=None, zoom='auto', alpha=1.0, attribution=True, attribution_size=8, crs=None)

Ajoute un fond de carte (tuiles web) via contextily.

add_polygons_choropleth(gdf, column_to_plot, label_column=None, cmap='viridis', alpha=1, edge_color='black', linewidth=0.5, show_labels=True, label_size=10, text_outline_color='white', text_outline_width=2, show_colorbar=True, title=None, default_crs='EPSG:4326')

Ajoute une couche vectorielle choroplèthe (polygones colorés selon une colonne).

add_points_choropleth(gdf, column_to_plot, label_column=None, point_size_column=None, cmap='viridis', alpha=0.7, min_point_size=40, max_point_size=200, edge_color='black', linewidth=0.5, show_labels=True, label_size=10, text_outline_color='white', text_outline_width=2, show_colorbar=True, show_size_legend=True, title=None, default_crs='EPSG:4326')

Ajoute une couche de points vectoriels, taille et/ou couleur proportionnelles à une colonne.

add_polygons_cloropleth(*args, **kwargs)
add_points_cloropleth(*args, **kwargs)

Alias dépréciés (faute de frappe historique) : utiliser add_polygons_choropleth / add_points_choropleth.

add_colorbar(cmap='viridis', vmin=0, vmax=1, label=None, orientation='vertical', shrink=0.6, pad=0.05, aspect=20, ticks=None, tick_labels=None)

Ajoute une barre de couleurs autonome à la carte (indépendante d’une couche choroplèthe).

add_gridlines(draw_labels=True, top_right=True, dms=False, x_inline=False, y_inline=False, xlocs=None, ylocs=None, color='gray', linestyle='--', linewidth=0.5, alpha=0.7, fontsize=10)

Ajoute une grille de coordonnées avec cartopy.

add_labels(gdf, label_column=None, custom_label=None, filter_column=None, filter_values=None, fontsize=10, color='#0f172a', outline_width=2, outline_color='white', format_str=None, **text_kwargs)

Ajoute des étiquettes de texte au centroïde des polygones ou à la position des points d’un GeoDataFrame.

add_title(title, fontsize=16, pad=20)
set_title(title, fontsize=14, fontweight='bold', color='black', pad=20)

Ajoute / définit le titre de la carte (set_title expose plus d’options de mise en forme).

add_annotation(text, xy, xytext=None, arrow=True, arrow_kwargs=None, text_kwargs=None)

Ajoute une annotation avec ou sans flèche sur un axe matplotlib.

add_text(text, xy, fontsize=12, color='black', outline_width=0, outline_color='white', **kwargs)

Ajoute du texte personnalisé à la carte.

add_highlight_text(text, xy, fontsize=12, color='black', highlight_textprops=None, **kwargs)

Ajoute du texte avec des segments <mis en évidence> (police/couleur différente) via highlight_text, en coordonnées géographiques.

add_highlight_fig_text(text, x, y, fontsize=12, color='black', highlight_textprops=None, **kwargs)

Équivalent de add_highlight_text mais hors-carte, en coordonnées figure (0-1) : pour titre/sous-titre.

add_custom_text(text, xy, to='ax', **kwargs)

Dispatch vers add_highlight_text (to="ax") ou add_highlight_fig_text (to="fig") selon le système de coordonnées voulu.

add_custom_labels(gdf, template, dx=0.0, dy=0.0, except_=None, highlight_textprops=None, **kwargs)

Version « par entité » de add_custom_text : étiquette chaque ligne de gdf avec template.format(**row) (les {...} sont des noms de colonnes, ex. "<{NAME_1}>\n{densite:.0f} hab/km²"), segments <...> mis en évidence via highlight_textprops. Ancre = point de l’entité (Point/MultiPoint) ou representative_point() pour un Polygon/MultiPolygon (un seul point par entité, multipolygones compris). dx/dy décalent l’ancre (unité de l’axe). except_=(colonne, [valeurs]) exclut les entités dont row[colonne] figure dans valeurs. Reprojette en EPSG:4326 si besoin.

add_fig_arrow(tail_position, head_position, radius=0, color='black', width=1, head_width=4, head_length=8, **kwargs)

Ajoute une flèche hors-carte en coordonnées figure (0-1) via drawarrow, pour pointer une entité trop petite pour être annotée directement dessus.

add_image(image, xy, to='fig', zoom=1, alpha=1.0, zorder=100, frameon=False, color=None, **kwargs)

Ajoute une image (logo, photo, illustration) à un endroit précis de la carte, via OffsetImage+AnnotationBbox. to="fig" (défaut) pour des coordonnées figure (0-1), to="ax" pour des coordonnées géographiques.

add_background_image(image, extent=None, zoom=1, aspect='equal', alpha=1.0, zorder=-100, color=None, **kwargs)
set_background_image(**kwargs)

Ajoute une image de fond derrière toutes les couches, sur l’étendue de la carte (self.bounds par défaut) / modifie celle déjà ajoutée. L’image garde ses proportions (recadrée au besoin plutôt que déformée) ; zoom (> 0) est un facteur d’échelle autour du centre : > 1 agrandit l’image, < 1 la réduit. Une seule image de fond à la fois (la précédente est retirée), et elle est re-dessinée automatiquement après set_paper/set_projection (comme la grille et la flèche du Nord). set_background_image fusionne les paramètres passés avec ceux du dernier appel : ex. set_background_image(alpha=0.25) : et lève RuntimeError si aucune image n’a encore été ajoutée.

get_north_arrows(arrows_subdir='arrows')

Liste les fichiers SVG de flèches du Nord disponibles dans le package.

add_north_arrow(arrow=1, position=(0.95, 0.95), zoom=1, color='black', style='auto', location='upper right', scale=None, rotation='auto', label='N', fancy=True, shadow=False, size=None, base=None, pack=None, aob=None, zorder=99, to='ax', **kwargs)
set_north_arrow(**kwargs)

Ajoute une flèche du Nord sur la carte / modifie celle déjà créée. to="ax" (défaut) l’ancre à l’axe carte, to="fig" à la figure entière (ex. position dans la marge, hors de l’axe).

Note

Mode style="svg" : les 17 icônes embarquées ont des résolutions natives très différentes une fois rastérisées (de 5x16 à 580x580 px selon l’icône). Elles sont automatiquement ramenées à une taille de référence commune avant d’appliquer zoom : zoom=1 donne donc une taille cohérente quelle que soit l’icône choisie, plutôt que de dépendre de la résolution brute du fichier SVG. Le fond des icônes est rendu transparent (pas de carré blanc opaque derrière la flèche).

add_scale_bar(length=None, location='lower left', linewidth=2, units='km', color='black', fontsize=11, pad=0.1, alpha=1, label=None, style='auto', box_color='white', box_alpha=0.8, scale_loc='bottom', label_loc='top', add_as_layer=True, bar_style='boxes', major_div=None, minor_div=None, size=None, bar=None, labels=None, text=None, to='ax', position=(0.05, 0.05), aob=None, font=None, **kwargs)
set_scale_bar(**kwargs)

Ajoute une barre d’échelle sur la carte / modifie celle déjà créée. major_div/minor_div : None par défaut (calcul automatique par matplotlib-map-utils) : ne les fixer qu’ensemble avec un major_mult (via le dict bar=...), sinon le calcul de la barre échoue. to (défaut "ax") : "fig" ancre la barre à la figure entière plutôt qu’à l’axe carte (modes map-utils/scalebar uniquement : avertissement et retour à l’axe en mode manual, intrinsèquement géographique), même convention que add_north_arrow(..., to=...). position : point d’ancrage exact en coordonnées figure (0-1), utilisé uniquement si to="fig" : location détermine toujours quel coin de la barre touche ce point.

Note

font (FontProperties, ex. via google_font()) : matplotlib-map-utils ne supporte qu’une famille CSS générique ("serif", "sans-serif", "cursive", "fantasy", "monospace"), pas une police précise. Si le style résolu est map-utils ("auto", "ticks", "boxes") et font est fourni, bascule automatiquement vers style="scalebar" (avec avertissement) pour l’appliquer réellement. Fonctionne nativement en modes "scalebar" et "manual".

add_inset_map(data=None, on=None, mode='bbox', zoom_to_on=False, position=(0.65, 0.02, 0.33, 0.33), to='ax', circular=False, facecolor='white', edgecolor='black', linewidth=1.5, alpha=0.9, box_color='red', box_linewidth=2, land_color='lightgray', ocean_color='lightblue', projection=None, style='auto', location='lower right', size=None, pad=None, coords=None, transform=None, global_view=True, extent=None, indicator='extent', indicator_facecolor='red', indicator_linecolor='red', indicator_alpha=0.5, indicator_linewidth=1, indicator_straighten=True, indicator_pad=0.05, connector_color='black', connector_width=1, inset_size=None, zorder=99, show_borders=True, show_coastlines=True, **kwargs)
set_inset(**kwargs)

Ajoute une mini-carte de situation (inset map) montrant la zone étudiée dans son contexte / modifie celle déjà créée.

  • data (list[float] | GeoDataFrame, optionnel) : zone à surligner sur l’inset : bbox [minx, miny, maxx, maxy] ou GeoDataFrame. None (défaut) : reprend self.bounds, indicateur calculé depuis l’étendue actuelle de la carte principale (comportement hérité).
  • on (GeoDataFrame | list, optionnel) : couche(s) de contexte dessinée(s) sur l’inset (ex. tous les pays d’un continent, pour situer data dedans). GeoDataFrame unique ou liste de {"data": gdf, "kwargs": {...}}.
  • mode (str, défaut "bbox") : comment dessiner data quand c’est un GeoDataFrame : "bbox" (rectangle de son étendue) ou "geometry" (sa géométrie réelle). Sans effet si data est déjà une bbox.
  • zoom_to_on (bool, défaut False) : si True, zoome l’inset sur l’étendue totale de on (au lieu de la vue globale) et l’encadre d’un rectangle (box_color/box_linewidth). Sans effet si on n’est pas fourni (avertissement). Prioritaire sur global_view/extent.
  • to (str, défaut "ax") : ancre du positionnement : "ax" : position (mode classique) ou location/coords (mode map-utils) relatifs à l’axe de la carte principale. "fig" : relatifs à la figure entière. Même convention que add_north_arrow(..., to=...).
  • circular (bool, défaut False) : si True, découpe l’inset en cercle plutôt qu’en rectangle (Axes.set_boundary), avec correction d’aspect pour un vrai cercle même si l’inset n’est pas physiquement carré (size ou position non carrés).
m.add_inset_map(on=bound.get_continent("Africa"), zoom_to_on=True, circular=True)
from cartograpy.data import Bound

bound = Bound()
m.add_inset_map(
    data=bound.get_country("Côte d'Ivoire"), mode="geometry",
    on=bound.get_continent("Africa"), zoom_to_on=True,
)
Avertissement

data valide un GeoDataFrame/GeoSeries ou une bbox de 4 éléments : tout autre type (ex. passer par erreur un GeoDataFrame là où l’ancienne API attendait une bbox bounds=) lève un TypeError explicite plutôt que d’être ignoré silencieusement ou de planter plus loin avec une erreur confuse.

create_custom_palette(name, colors, save_palette=True)

Crée une palette de couleurs personnalisée.

get_available_palettes(include_custom=True, include_seaborn=True, include_matplotlib=True)
print_available_palettes(category='all', limit=None)

Récupère / affiche (formaté) les palettes de couleurs disponibles.

preview_palette(palette_name, n_colors=8)

Prévisualise une palette de couleurs sous forme de barre colorée.

generate_gradient_palette(name, start_color, end_color, n_colors=10, save_palette=True)

Génère une palette en dégradé entre deux couleurs.

get_available_fonts(pattern=None, sort=True)
print_available_fonts(pattern=None, limit=None)

Récupère / affiche (formaté) les polices disponibles sur le système.

set_font(family='sans-serif', size=10, weight='normal')

Définit les propriétés globales de la police.

custom_legend(elements=None, title=None, loc='best', bbox_to_anchor=None, ncol=1, fontsize=10, title_fontsize=12, frameon=True, fancybox=True, shadow=True, framealpha=0.9, facecolor='white', edgecolor='black', linewidth=1, columnspacing=2, handlelength=2, handletextpad=0.8, borderpad=1, markerscale=1, markerfirst=True, numpoints=1, scatterpoints=1, replace=True, **kwargs)

Crée une légende personnalisée avec contrôle total sur l’apparence.

add_legend_element(element_type, label, color='black', marker='o', linestyle='-', linewidth=2, markersize=8, alpha=1.0, **kwargs)

Ajoute un élément personnalisé à la légende.

create_legend_from_column(gdf, column, element_type='patch', cmap=None, color_scheme='viridis', title=None, max_items=25, sort_by='value', **legend_kwargs)

Crée automatiquement une légende basée sur une colonne d’un GeoDataFrame.

add_swatch_legend(items, xy, rect_width=2, rect_height=1.5, y_step=1.5, label_dx=2.5, label_dy=0.7, fontsize=12, color='black', edge_color='black', linewidth=0.6, font=None, ha='left', va='center')

Ajoute une légende “faite main” : rectangles de couleur (items = liste de (label, couleur)) empilés verticalement à une position géographique donnée, plutôt que dans un coin d’axe via custom_legend.

legend_presets(preset='default', **override_kwargs)

Applique des préréglages de légende.

remove_legend()
clear_legend_elements()

Supprime la légende actuelle / vide la liste des éléments de légende accumulés.

list_layers()

Liste toutes les couches ajoutées à la carte.

remove_layer(index=None, label=None)

Supprime une couche par son index ou son label.

clear_layers()

Supprime toutes les couches de la carte.

show(legend=True, auto_extent=True, tight_layout=True, smart_centering=True, title=None, **kwargs)

Affiche la carte avec tous les layers ajoutés.

save(filename, dpi=300, bbox_inches='tight', legend=True, auto_extent=True, tight_layout=True, smart_centering=True, title=None, **kwargs)

Sauvegarde la carte dans un fichier.

to_image(format='png', dpi=300, legend=True, auto_extent=True, tight_layout=True, smart_centering=True, title=None, **kwargs)

Exporte la carte en objet PIL.Image (en mémoire, sans fichier).

to_bytes(format='png', dpi=300, bbox_inches='tight', legend=True, auto_extent=True, tight_layout=True, smart_centering=True, title=None, **kwargs)

Exporte la carte en BytesIO (en mémoire, sans fichier).

Méthodes de Map2D

Map2D hérite de Map (toutes les méthodes ci-dessus restent disponibles) et ajoute/adapte 3 méthodes pour un rendu sans projection cartographique :

add_layer(gdf, column=None, cmap='viridis', label=None, edgecolor='black', linewidth=0.5, alpha=0.8, **kwargs)

Ajoute un GeoDataFrame comme couche (version simplifiée, sans axe cartopy).

add_labels(gdf, label_column, fontsize=9, color='black', outline_width=2, outline_color='white', **text_kwargs)

Ajoute des étiquettes au centroïde / à la position des géométries.

hide_axes()

Masque les axes matplotlib.

Méthodes de WebMap

6 méthodes publiques : carte interactive Folium/Leaflet, indépendante de Map.

add_layer(gdf, column=None, cmap='YlOrRd', style_function=None, tooltip_columns=None, popup_columns=None, name=None, **kwargs)

Ajoute un GeoDataFrame comme couche GeoJson ou Choropleth.

add_marker(location, popup=None, tooltip=None, icon=None)

Ajoute un marqueur.

add_layer_control()

Ajoute un contrôle de couches (folium.LayerControl).

fit_bounds(gdf)

Adapte le zoom aux limites d’un GeoDataFrame.

show()

Renvoie la carte Folium (affichage automatique dans un notebook).

save(filename='map.html')

Sauvegarde la carte en HTML.

Méthodes de SituationMap

9 méthodes publiques : carte principale + mini-carte de localisation, indépendante de Map.

add_main_layer(gdf, facecolor='green', edgecolor='black', linewidth=0.5, alpha=0.7, column=None, cmap='viridis', **kwargs)

Ajoute un GeoDataFrame à la carte principale.

set_inset_box(bounds, box_color='red', box_linewidth=2, indicator='extent', indicator_facecolor='red', indicator_linecolor='red', indicator_alpha=0.5, indicator_linewidth=1)
set_inset_box_from_gdf(gdf, **kwargs)

Dessine sur la mini-carte le rectangle délimitant la zone d’étude, à partir de limites brutes ou de l’étendue d’un GeoDataFrame.

add_north_arrow(style='auto', location='upper right', **kwargs)

Ajoute une flèche du Nord à la carte principale.

add_scale_bar(length=None, location='lower left', units='km', color='black', fontsize=11, linewidth=2, style='auto', bar_style='boxes', major_div=None, minor_div=None, box_color='white', box_alpha=0.8, scale_loc='bottom', label_loc='top', **kwargs)

Ajoute une barre d’échelle à la carte principale. Mêmes défauts major_div/minor_div=None que Map.add_scale_bar().

add_gridlines(**kwargs)

Ajoute des lignes de grille à la carte principale.

show()
save(filename, dpi=300, bbox_inches='tight')
to_bytes(format='png', dpi=300)

Affiche / sauvegarde dans un fichier / exporte en mémoire.

Méthodes de Map : bivarié et hexbin

En plus des fonctions autonomes ci-dessous, Map expose deux méthodes qui dessinent directement sur l’axe de la carte (avec flèche du nord, échelle, inset… déjà en place) au lieu de créer une figure :

add_bivariate(gdf, var1, var2, **kwargs)

Surcouche de plot_bivariate_choropleth : tous ses paramètres nommés passent par **kwargs (var1_label, palette, n_classes, legend_position…). Le GeoDataFrame enrichi est aussi stocké dans Map.last_bivariate.

add_hexgrid(gdf, column, hex_size=None, hex_grid=None, value_cols=None,
            agg_funcs=None, predicate="within", count_col="n_points", **kwargs)

Enchaîne make_hex_grid → aggregate_to_hex → plot_hexgrid_choropleth. Si hex_size (ou hex_grid) est fourni, gdf est agrégé ; sinon gdf est supposé déjà agrégé et tracé tel quel. **kwargs va à plot_hexgrid_choropleth. Grille stockée dans Map.last_hexgrid.

from cartograpy.data import Bound
from cartograpy.mapper import Map

m = Map(title="Densité × revenu")
m.add_bivariate(regions, "densite", "revenu", var1_label="Densité", var2_label="Revenu")
m.add_north_arrow()
m.show()

m = Map(title="Richesse spécifique")
m.add_hexgrid(points_occurrence, "richesse", hex_size=25_000, cmap="YlGn", min_count=3)
m.show()

Les deux méthodes reprojettent automatiquement les données en EPSG:4326 pour l’axe cartopy de Map (sur Map2D, les données sont laissées dans leur CRS).

Grille hexagonale (hexgrid.py)

Trois fonctions pour produire une carte hexbin : générer une grille régulière sur la zone d’étude, y agréger des données ponctuelles ou polygonales, tracer le résultat. Nécessite le paquet geohexgrid (dépendance cœur). Le GeoDataFrame agrégé est standard et réutilisable tel quel avec plot_bivariate_choropleth (ou Map.add_bivariate) pour une carte hexagonale bivariée.

make_hex_grid(source, hex_size, crs=None, trim_mode="intersect")

Génère une grille d’hexagones réguliers (sommet plat) couvrant une zone. source : un GeoDataFrame (son étendue et son CRS sont repris ; les hexagones hors zone sont écartés selon trim_mode : "intersect" par défaut, ou "clip") ou un tuple de bornes (minx, miny, maxx, maxy) : dans ce cas crs est requis. hex_size : circumradius de l’hexagone dans l’unité du CRS (utiliser un CRS projeté en mètres). Retourne un GeoDataFrame cell_id, geometry.

aggregate_to_hex(source_gdf, hex_grid, value_cols, agg_funcs=None,
                 count_col="n_points", predicate="within")

Agrège source_gdf dans chaque hexagone de hex_grid (reprojeté au besoin). value_cols : colonnes numériques à agréger ; agg_funcs : fonction par colonne ("mean" partout par défaut). predicate : "within" (points) ou "intersects" (polygones à cheval). Retourne hex_grid enrichi des colonnes agrégées et de count_col (0 et NaN pour les hexagones sans donnée : à filtrer, ex. result[result.n_points >= 3]).

plot_hexgrid_choropleth(hex_gdf, column, cmap="viridis", min_count=None,
                        count_col="n_points", edgecolor="white", linewidth=0.3,
                        title=None, figsize=(10, 8), show_colorbar=True,
                        colorbar_label=None, ax_map=None, transform=None,
                        save_path=None, dpi=300, **plot_kwargs)

Trace une choroplèthe sur la grille hexagonale (une variable). min_count filtre les hexagones sous-échantillonnés. ax_map permet de dessiner sur un axe existant (ex. Map.ax), transform accompagne une GeoAxes cartopy. Retourne (figure, axe).

grid = make_hex_grid(regions, hex_size=25_000)          # 25 km, CRS projeté
hex_data = aggregate_to_hex(points, grid, value_cols=["richesse", "structure"])
hex_data = hex_data[hex_data["n_points"] >= 3]
fig, ax = plot_hexgrid_choropleth(hex_data, "richesse", cmap="YlGn", min_count=3)