ThomasG77

Recipe to transform latest RNA data to parquet or download data (for 2nd case, uncomment line starting with #)

This example shows how to extract the two most recent RNA datasets from the French open-data platform data.gouv.fr and convert them into compressed Parquet files for efficient analysis. It uses the data.gouv.fr API to fetch dataset metadata, filtering resources by type and sorting by creation date to select the latest files. The scripts then leverage DuckDB’s `read_csv` function with the community `zipfs` extension to read CSV files directly from remote ZIP archives, and write the result to Parquet with Zstandard compression. Equivalent implementations are provided in Bash using `curl`, `jq`, and the DuckDB CLI, and in Python using the `duckdb` library and `urllib`.

Get remote URL of a compressed Pypi package when not available on Github

This example shows how to retrieve the direct download URL for the latest version of a Python package from PyPI when the package is not hosted on GitHub. It queries the PyPI simple index for each package in a hardcoded list, parses the HTML with BeautifulSoup, and extracts the last version link. The script uses the `requests` library to fetch the page and prints the URL attributes along with the version name for the packages `to-file-like-obj`, `stream-zip`, and `stream-unzip`.

Export DVF geolocalisées en Geoparquet

This example converts French land-registry transaction data (DVF) from compressed CSV files into a single spatially-indexed GeoParquet file. It downloads yearly datasets from data.gouv.fr, loads them into a DuckDB database, and creates a point geometry for each transaction before exporting with a Hilbert-curve spatial ordering. The script leverages DuckDB’s spatial extension, the `ST_Point` and `ST_Hilbert` functions, and parquet compression via zstd.

Depuis https://archeologie.culture.gouv.fr/fr

This visualization maps archaeological sites from the French Ministry of Culture's portal, presenting them as geographic points. The map is built with Vue, using GeoJSON data for site locations. Each data point is a clickable feature, with properties like title and description stored in the GeoJSON, and rendered using a mapping library that handles the geographic coordinates. The visualization shows the geographical distribution of French archaeological missions across the world, from the Île de Saï in Sudan to archaeological sites in Afghanistan.

Gist 1f575522ca61946b31d92bbd146a9dce

This visualization compares French legislative electoral districts between 2012 and 2017, showing how commune boundaries and canton assignments shifted across the two years. It displays two side-by-side maps, likely using Three.js with WebGL rendering to animate or morph between the two configurations. The data comes from CSV files containing commune-to-canton and commune-to-district correspondences for both years. The visualization relies on the Vue framework to manage the interface and handle state transitions, with the geographic comparisons rendered through WebGL for smooth interactive exploration.

OGC WFS consumption URLs from a service

This example demonstrates how to enumerate all downloadable data layers and their available output formats from an OGC Web Feature Service (WFS). Using the `@camptocamp/ogc-client` JavaScript library for the WFS endpoint, it retrieves the service metadata, layer types, and output formats, then constructs a complete GetFeature URL for every layer-format combination. The code also shows a Python equivalent using `OWSLib` to achieve the same enumeration, highlighting the interoperability of the two approaches. The visualization likely presents these generated URLs as a list or table, connecting users directly to data downloads.

Bookmark pour Minio data.gouv.fr

This bookmarklet enhances the Minio browser interface for data.gouv.fr by adding a direct link to the real object URL for each file listed. It scans the file table, detects entries with file extensions, and appends a fourth column containing an anchor tag. The JavaScript uses DOM manipulation with `querySelectorAll`, `closest`, and `appendChild` to inject the links, constructing the full URL by parsing the current browser location and replacing the console hostname with the object storage endpoint.

Query remote Geoparquet in browser

This example demonstrates querying a remote GeoParquet file directly from a web browser using DuckDB-Wasm. The interactive map displays French priority neighborhoods (QPVs) and identifies which one contains a specific geographic point (2.389798, 48.909514). It uses DuckDB-Wasm’s SQL engine with the spatial extension to run an `ST_contains` query, filtering results by geometric intersection. The workflow converts the matched polygons to GeoJSON via the GDAL driver and exports them as a downloadable file. The dataset was prepared from a government GeoJSON source using DuckDB and gpio utilities.

Exemples de consommation de DVF via parquet et Duckdb

This example demonstrates how to extract and filter French property transaction data (DVF) from a cloud-hosted Parquet file using DuckDB's SQL engine, then export the filtered results as GeoJSON for specific geographic areas. It shows three distinct query scopes: a single commune (Nantes), a multi-commune agglomeration, and a department-level export. The workflow relies on DuckDB's `INSTALL spatial` and `LOAD spatial` extensions, which enable reading the Parquet file directly from the `data.gouv.fr` URL. The `COPY` command with `FORMAT gdal` and `DRIVER 'GeoJSON'` handles the conversion, while explicit type casting (e.g., `::DOUBLE`) ensures correct numeric fields like `valeur_fonciere` and coordinates (longitude/latitude), and preserves the geometry column for spatial output.

Get area stats for parcelles and batiments for each parcelle

This example maps French cadastral data for the commune 91114, calculating the built surface area of buildings (batiments) on each land parcel (parcelle). It uses DuckDB’s spatial SQL functions—`ST_intersects`, `ST_intersection`, and `ST_Area`—to query a remote GeoParquet file from data.gouv.fr, then aggregates results with a `LEFT JOIN` to include parcels without buildings. The final query outputs a CSV of per-parcelle statistics, including total building footprint and parcel geometry attributes.

Vous souhaitez imprimer un plan DXF de votre commune?

This example shows how to estimate the printable scale and paper size for a French municipal DXF cadastral map, using the Lambert 93 projection. It uses the command-line tools `ogrinfo` and `jq` to extract the layer extent from the DXF file, then calculates the map’s dimensions in centimeters at a given scale. The write-up explains the trade-off between fitting a sheet like A0 versus using a plotter for custom widths, and mentions the need for CAD or GIS software to adjust text, scale bars, and north arrows.

Récupération geolocalisation EHPAD 57

This example visualizes the geographic distribution of EHPAD (nursing homes) in the Moselle department (57) of France, displaying each facility as a point on a map. The data is retrieved from a public government API and converted to GeoJSON format using `jq` command-line tools for filtering and restructuring. The visualization is built with the Vue framework, rendering the geographic points to show facility locations, with additional property information such as name, city, and legal status included for reference. The map uses standard GeoJSON `Point` features to represent each facility's coordinates.

Issue with geobucket package

This example demonstrates a reproducible issue with the geobuckets package, where importing the `jenksBuckets` function and running it on a small array of numbers produces an `ERR_MODULE_NOT_FOUND` runtime error. The problem stems from the compiled JavaScript in `dist/src/index.js` missing explicit `.js` extensions in its relative import statements for classifiers like `arithmeticProgression`. The code uses the `jenksBuckets` API from geobuckets 0.0.3, with data processed through a TypeScript file compiled via `tsc` to ES2022 modules, then executed with Node.js.

OCSGE téléchargement IGN flux Atom

This example visualizes filtered OCSGE land-cover datasets from the French IGN Atom feed, showing only entries for years 2021–2023 while excluding differential (DIFF) updates. It first parses paginated Atom XML responses with Python’s `xml.etree.ElementTree` and HTTP requests via the `requests` library, extracting entry fields into dictionaries. The script then filters those dictionaries based on the `id` string and prints the resulting list, demonstrating a server-driven data-cleaning pipeline for visualization-ready metadata.

Gist af8be0815f3cb3a6676169571dd84de2

This example shows a Python script that patches a QGIS plugin file to remove a field from a search dialog’s attribute list. It reads the plugin’s `search_dialog.py` file, replaces the string containing `'comptecommunal'` with a version that omits that field, and writes the modified file back. The script uses standard Python file I/O operations and string replacement via `file.read`, `str.replace`, and `file.write`, targeting the Cadastre plugin’s dialog configuration within the user’s profile directory.

API jours fériés: passage sous forme de tableau

This example transforms the French public holiday API from `calendrier.api.gouv.fr` into a tabular dataset. It fetches the JSON response containing holiday dates and their names, then converts the object into an array of `{date, event}` pairs sorted chronologically. The conversion uses `Object.entries` combined with `map` to restructure each key-value pair, and `toSorted` to order the results by date. Two equivalent implementations are shown, one using `curl` with `jq` for command-line processing and another using the `fetch` API in JavaScript for browser-based execution.

Gist 96068363e74b4c1c148c55aad9ab0cf4

This example demonstrates client-side reprojection of GeoJSON geometries from a source CRS to WGS84 using the Proj4js library. It fetches a French “quartiers prioritaires” dataset encoded in EPSG:2154 and transforms its Point, LineString, Polygon, and Multi* geometries via custom functions that recursively map coordinates through a proj4 transformer. It also tests a second transformation from EPSG:4326 to EPSG:3857 on sample geometries, logging converted coordinates to the console. The code relies on proj4.defs, proj4(...).forward, and the fetch API.

Leaflet styling source to black&white/grayscale on client side

This example displays an interactive Leaflet map centered on a location near Paris, using the IGN-F/Géoportail WMTS tile service as its basemap. The map shows the “GEOGRAPHICALGRIDSYSTEMS.PLANIGNV2” layer, yet a CSS class applied to the tile layer renders those tiles in black and white. The styling is achieved via the Leaflet `L.tileLayer` API, passing a `className: "bw"`, which triggers a CSS filter of `grayscale(100%) opacity(80%)` on the tile container. The map is created with `L.map("viewerDiv").setView([48.845,2.424],10)`.

Gist afa06f80766db293173c0b14dbdd4ee1

This Gist defines a JSON schema for a fish observation dataset, detailing fields for operation IDs, station locations, sampling dates, and species abundance metrics. The schema enforces data quality through constraints like required surface area, coordinate ranges for the Lambert-93 projection, and enumerated sampling methods. It specifies types and validation rules for each attribute, including the species-specific count columns, supporting a structured analysis of ecological data from French water bodies.

Recette génération fantoir

This example demonstrates how to compare French road identifiers (FANTOIR keys) between the 2023 and 2024 editions, revealing a notable decrease from 36,836 to 34,879 entries. It uses a Node.js script with `createFantoirCommune` from the `lib` module to query a local SQLite database, constructed via `yarn build` from the FANTOIR dataset and the `topo2fantoir` conversion tool. The script performs lookups for specific street names like "rue du parc" within commune code `54099`, optionally filtering by an additional code `54342`. The data originates from the French government’s open address database, downloaded manually from the opendata portal.

Download data from WFS using GDAL Python bindings

This example shows how to download vector data from a WFS (Web Feature Service) endpoint using GDAL’s Python bindings. It demonstrates bulk download of a full layer, plus filtered extracts by bounding box via the `-spat` option, and outputs to GeoPackage, CSV, and GeoJSON formats. The code explicitly configures WFS paging with `OGR_WFS_PAGING_ALLOWED` and `OGR_WFS_PAGE_SIZE`, and uses `gdal.OpenEx` and `gdal.VectorTranslate` to fetch data from the Géoportail WFS service. A separate call requests GeoJSON output directly through the service’s `outputFormat=json` parameter.

Recette génération tuiles monde OpenMaptiles

This example demonstrates how to generate global vector tile sets using OpenMapTiles and Planetiler, processing the entire OpenStreetMap planet file. The code runs Planetiler through Docker with 40GB of Java heap memory, using sparse array node mapping and memory-mapped storage to handle the large dataset efficiently. After generating the output MBTiles file, the script updates its metadata with SQLite commands to set proper attribution, center coordinates, and description for the tiles. The workflow relies on Docker, Planetiler, and sqlite3, with optional pre-downloading of the planet PBF file from OpenStreetMap.

Récupération des données de l'API des athlètes français JO 2024 derrière https://data.equipedefrance.com

This visualization maps the birthplaces of French Olympic and Paralympic athletes for the 2024 Games using data from the Équipe de France API. It generates a GeoJSON FeatureCollection where each point represents an athlete’s birthplace, supplemented with attributes like gender, disciplines, and medal counts. The code retrieves athlete data via `requests`, extracts missing birthplace coordinates by scraping HTML pages with BeautifulSoup, and geocodes locations using the Nominatim OpenStreetMap API. A local JSON cache stores resolved coordinates, while final output is structured as GeoJSON for rendering in a map.

Recette pour générer des diagrammes en barre pour redessiner dans Photoshop

This example demonstrates a workflow for generating horizontal bar charts from raw numeric data, intended as a reusable template for recreating charts in Adobe Photoshop. It uses data from the rapidtables.com bar graph tool, where the input values (e.g., `33 28 18 5 4 3 3 2 1.5 2.5`) are pasted into the "Data labels" and "Bar1 data values" fields. The tool draws the chart, and the resulting PNG is exported as a layer in Photoshop, which can be stretched or resized to match the canvas. The recipe highlights the precise numeric entry and export steps, emphasizing the manual redrawing workflow.

Bureaux de vote des circonscriptions de l'étranger

This visualization maps the polling stations for French citizens living abroad, organized by the eleven overseas legislative constituencies. The map shows the geographic distribution of cities where expatriates can vote, with each location assigned to its corresponding electoral district. The data is sourced from a French government file containing polling station names and locations, which is first processed into a CSV format and then geocoded to obtain coordinates. The visualization uses a GeoJSON file with point features to plot the locations on a map.

Generate vector tiles for Planet with tilemaker

This example demonstrates a command-line workflow for generating vector tiles from the entire OpenStreetMap planet dataset using tilemaker. It shows how to automate the process of downloading planet-latest.osm.pbf, compiling tilemaker from source, and producing a planet.mbtiles output using the OpenMapTiles configuration and Lua processing scripts. The script also periodically checks the dataset’s last-modified header via curl to trigger regeneration only when new updates exist. External resources like Natural Earth landcover and coastline polygons are fetched and merged into the tile pipeline.

Consommation CSW Observatoire des territoires

This visualization catalogs the datasets available from the French government’s Observatoire des Territoires geospatial service. It displays a table of metadata—titles like “ZRR - Zone de revitalisation rurale” and “QPV - Quartiers prioritaires”—paired with their identifiers and direct URLs. Built with a Python script using the OWSLib library’s `CatalogueServiceWeb`, it queries the CSW endpoint, paginates through records, and exports the results to a CSV. The output is then presented in a Vue.js interface, showing the structured list of available territorial indicators.

Copie données WFS depuis le géoportail de l'urbanisme

This example automates the bulk download of France’s urban planning WFS data from the Géoportail de l’Urbanisme, specifically extracting the GPKG files. It shows how to list available remote directories via `lftp` over SFTP, identify the latest dated export, and mirror the chosen folder with parallel transfers. The workflow uses shell commands with `timeout`, `ssh`, and `lftp` to handle authentication and file retrieval. It relies on public credentials and a documented PDF manual, making the process reproducible for users needing recent, structured land-use datasets.

ol-ext: WMS Capabilities control

This example demonstrates the ol-ext WMSCapabilities control, which loads WMS layers onto an OpenLayers map. It shows a dialog for selecting a service and displaying available layers via the GetCapabilities request. The code uses the ol.control.WMSCapabilities API, OpenLayers map, and a Grid.js table for layer metadata. Users can search services like BRGM and Sandre, with the layer definition output to the console. The map view uses EPSG:2154 projection, and a LayerSwitcher and SearchNominatim control are also included.

Compile Node

This example compiles the Node.js source code from a v20.9.0 git clone, showing the command-line sequence required to produce a custom build. The process uses `./configure` with a custom `--prefix`, `make -j4` for parallel compilation, and `make install` to place the resulting binaries under `/opt/node`. It also demonstrates how the build environment is prepared by installing dependencies like `build-essential`, `clang-10`, and `python3-distutils` via `apt`, with environment variables `CC` and `CXX` selecting the clang compilers before running the build.

Récupération des stations quotidiennes depuis les données Météo France

This visualization maps the locations and operational periods of daily weather stations across France, using data from Météo France. The map depicts each station as a point, colored or sized to indicate when it was active. The example retrieves station URLs from the data.gouv.fr API, filters for rainfall, temperature, and wind data, then uses pandas to concatenate CSVs and compute the earliest and latest observation dates per station. The resulting dataset is converted into a GeoJSON file with geopandas, with geometries created from latitude and longitude coordinates.

Tuiles vecteur OpenLayers

A web map displays IGN’s PLAN.IGN vector tiles using OpenLayers and the ol-mapbox-style library. The OpenLayers map starts at a zoom level of 5 over France, then fetches the plan’s JSON style from data.geopf.fr and applies it to a hybrid-rendered VectorTile layer. The layer loads Mapbox Vector Tiles from a URL in the style’s source, with attribution added. A brief loading animation occurs while the style is fetched and applied before the map renders.

7z vs zip avec données IGN

This example compares the storage size and remote read performance of 7z versus zip compression for French geographic data from the IGN ADMIN-EXPRESS-COG dataset. It shows that while 7z produces a smaller file (562M vs 693M), zip is vastly faster for remote consumption, with `ogrinfo` reading a shapefile in 0.504 seconds versus 36.717 seconds via the `vsicurl` virtual filesystem. The benchmark also experiments with GeoParquet, demonstrating even faster access at 0.338 seconds. Tests use GDAL's OGR tools for shapefile and Parquet reading.

Display a map

This example displays an interactive map of France using the Maplibre GL JS library. Two map styles are showcased: a standard topographic map from the IGN PLAN.IGN vector tiles, and an isohypse (contour line) style with an orange monochrome rendering, centered on the Alps. The code fetches style definitions as JSON and applies them to the map, adjusting the tile scheme for compatibility. Attribution is provided to the IGN data source.

HTML browser favorites to CSV

This example converts browser-exported HTML bookmark files into a clean CSV table with two columns: page titles and their URLs. The pipeline uses three command-line tools: pup extracts JSON objects from the HTML structure, jq reformats the data into CSV rows, and he decodes HTML entities back into readable text. The final output is a plain-text CSV file, making bookmark data easy to import into spreadsheets or other data tools. The code demonstrates a lightweight, scriptable approach to data cleaning without a graphical interface.

Execute Spatialite within Node.js

This example demonstrates how to execute SpatiaLite spatial operations within a Node.js application using the `sqlite3` database driver in memory. The code initializes a spatial metadata table, creates a point geometry column with EPSG 4326 projection, and adds a spatial index to a `places_spatialite` table. It then inserts a sample point using `GeomFromText` and queries the table with `db.each`, logging the resulting rows. The workflow relies on `db.loadExtension` to load the native `mod_spatialite` library, with the extension path hard-coded for Linux systems.

Reset your MySQL root password

This example demonstrates a command-line procedure for resetting a MySQL root password on a localhost server. It shows two distinct methods: a simple, hardcoded password approach and a more secure alternative that generates a random alphanumeric password using shell tools like `strings`, `grep`, and `head`. The code executes `sudo service mysql stop`, writes an `ALTER USER` SQL statement to an init file, then launches `mysqld` with the `--init-file` flag before restarting the service. The recipe relies on standard Unix utilities and the MySQL command-line client, with no graphical visualization or charting library involved.

Gist 72be73d247fa60de43935bf3dae309e5

This example visualizes earthquake activity near Grindavík, Iceland, using a 3D terrain map. It displays earthquake epicenters as colored markers, with color and size representing magnitude and depth, plotted over a textured landscape. The visualization uses Three.js for 3D rendering and D3.js for data loading and spatial projection, with `d3.geoPath` to generate the terrain geometry. Earthquake data is sourced from a CSV file containing date, time, latitude, longitude, depth, and magnitude.

Code pour passer des id de parcelles Etalab en commune, prefixe, section, numero et inversement

This example demonstrates how to convert between French land parcel identifiers from the Etalab system and their constituent components: municipality code, prefix, section, and number. It shows the parsing of a composite key, such as `323190000A0133`, into its semantic parts, and the reverse operation to reconstruct the identifier. Implemented in both JavaScript and Python, the code uses basic string manipulation methods including `substring`, `replace` with a regular expression, `padStart`, and `zfill` for handling leading zeros. The JavaScript version runs directly in the console, while the Python version uses f-string formatting for output.

Compiler un EPT (établissements publics territoriaux)/des EPT

This example generates GeoJSON files for the Établissements Publics Territoriaux (EPT) of the Greater Paris metropolis. It shows two outputs: a single EPT boundary dissolved from its constituent communes, and a comprehensive file covering all EPTs. The single-EPT workflow uses a bash script with `wget` to fetch commune geometries from the geo.api.gouv.fr API, then applies `jq` to merge them and `mapshaper` with the `-dissolve` operation. The generalized version uses Python with `urllib`, `pandas`, and `geopandas` to read an INSEE Excel spreadsheet, join commune codes to geometries from Etalab’s contours-administratifs dataset, and dissolve by EPT attributes.

Lien Adresse et parcelles

This example shows the relationship between French addresses and land parcels, producing flat CSV files per department and for the whole country from the IGN BAN PLUS dataset. The workflow uses a bash pipeline combining Python with `xml.etree.ElementTree` to fix VRT files, GDAL’s `ogr2ogr` and `ogrinfo` for data conversion and indexing, `jq` to parse layer names, and `xsv` to concatenate departmental rows into a nationwide file. Results are gzip-compressed and organized into `france` and `departements` directories.

Territoire vie santé (TVS)

This visualization displays the French "Territoires vie santé" (TVS) boundaries, aggregating communal administrative units into larger health-related regions. It shows the relationship between individual municipalities and their associated TVS zones, with contours generated by dissolving commune polygons based on shared TVS codes. The map employs WebGL for smooth rendering of the geographic data. Built with Vue, it loads GeoJSON data containing commune geometries and their TVS assignments, using mapshaper for geometric processing and the ouvre-contours-administratifs dataset as the underlying source.

Load GTFS as GPKG with GDAL 3.7

This example demonstrates converting an IDFM GTFS transit feed into a GeoPackage database using GDAL’s new GTFS driver. The Bash script first checks that GDAL 3.7 is installed, then uses `ogrinfo` with `-json` to list all available layers. For each layer, it runs `ogr2ogr` with the GeoPackage format, appending layers incrementally with the `-update` flag. The source data is loaded directly from a URL via `/vsicurl/`, and the script allows customizing input and output names through environment variables.

Gist 1a5dc1decf3b506fe8624def208db4e5

This example shows a shell script that installs Google Chrome version 109 on Ubuntu 16.04. It uses the `apt` package manager to install the `libvulkan1` dependency, then downloads the Chrome `.deb` package via `wget`. The script also fetches a missing `libu2f-udev` dependency from an Ubuntu archive and installs it with `sudo dpkg -i`. The rendering approach is a step-by-step command sequence, with comments indicating where dependency issues were resolved.

Gist 67ede8b65420f40492f25349392a741a

This example uses a shell script to compile and install OpenSSH 7.3p1 from source on Ubuntu 16.04. It downloads the portable release tarball from OpenBSD’s CDN, extracts it, and builds the software using `./configure`, `make`, and `checkinstall`. The script’s annotations and inline comments document each step, referencing the original Ask Ubuntu guide for adaptation. The code relies on system package managers (`apt`) and standard build tools (`gcc`, `make`, `autoconf`) rather than any visualization libraries or data APIs.

Gist 8dafcac4cab52f5242b00c077430c08d

This example demonstrates how to select cadastral parcels from the IGN Cadastre API based on a drawn polygon’s extent. It shows the process of converting a GeoJSON polygon into an encoded URL parameter, then sending a GET request via Bash with `jq` or Python with `urllib.parse` and `urllib.request`. The API returns parcel geometries, which are saved as a GeoJSON file. The code also warns against using overly complex or overly large geometries due to URL length limits and server load.

Gist eafff0441de1209802edaacd56203985

This example visualizes the hierarchical timing profile of a QGIS application, rendering each profiler entry as a node with its name and measured duration. It extracts the profiler tree via the QGIS `QgsApplication.profiler()` API, iterating rows and columns to build nested parent-child relationships. The code uses Python’s `json` module to serialize the resulting structure into a JSON file, preserving two levels of detail with child arrays. The visualization itself is not rendered here; only the data extraction and export to `/tmp/tree.json` are demonstrated.

Gist 7d99b7d79138bda9a2dfb092728da54c

This example documents a debugging session for serving OpenStreetMap vector tiles with the VersaTiles toolkit. It shows how a version mismatch between the VersaTiles server (0.2.14) and its frontend client causes 404 errors for tile requests, as the server expects flipped Y-axis coordinates (2873/4058) instead of the standard OSM ordering (4058/2873). The fix involves downgrading to versatiles 0.2.13, which resolves the coordinate issue but introduces a client-side gzip decompression error (`Unimplemented type: 3`). The code uses `cargo install`, `versatiles convert`, `versatiles probe`, and `versatiles serve` commands, alongside `curl` for testing tile endpoints, referencing a Geofabrik extract of Pays de la Loire.

List schema and tables from all databases in PostgreSQL cluster

This example shows a two-step pipeline that first lists every database in a PostgreSQL cluster and then aggregates all user-defined schemas and tables from each database into a single CSV file. The first `psql` query retrieves database names, excluding `template0`, and writes them to `databases.txt`. A shell loop then runs a second `psql` query against each database, selecting `schemaname` and `tablename` while filtering out system schemas, and appends results with the database name to `all_tables.txt`. The code uses the PostgreSQL command-line client with `-t --csv` flags to output tab-separated CSV data.

Gist 4ab7840c00aa352f278636ea3f3f0d3e

This example demonstrates streaming merge of two French cadastral parcel GeoJSON files into a single unified feature collection, output as a continuous JSON stream to standard output. It shows how to combine multiple geospatial datasets without loading them entirely into memory. The code uses the `geojson-stream` library for parsing and stringifying GeoJSON features, Node.js `fs.createReadStream` for file input, and the `zlib` module to decompress gzipped source files. Data originates from the Etalab cadastre dataset, with separate scripts handling zipped and unzipped input files.

Java certificate issues recipe + basic java demo

This example demonstrates a basic Java 11 HTTP client that retrieves dataset metadata from the data.gouv.fr API, parsing the JSON response to extract and print the URLs of all resources. The code uses `java.net.http.HttpClient`, `HttpRequest`, and `HttpResponse` for the asynchronous request, alongside the `org.json` library for JSON parsing. The accompanying recipe addresses a "PKIX path building failed" error by downloading the site’s certificate via `InstallCert.java` and importing it into the JDK 19 keystore using `keytool`, which is necessary for the HTTPS connection to succeed.

Java basic http client API Geo (Java 11+)

This example shows how to query the French administrative geography API (geo.api.gouv.fr) for commune data, specifically searching for “Montpellier” and printing each matching commune’s name, code, department, SIREN, EPCI, and population to the console. It uses the Java 11 `java.net.http.HttpClient` to send an asynchronous request, `HttpRequest` and `HttpResponse` to handle the HTTP/2 call, and the external JSON-java library (`org.json.JSONArray` and `JSONObject`) to parse the JSON response. The code demonstrates a minimal, non-visual data-fetching workflow rather than a graphical chart.

Leaflet WMS

This example shows a map centered on a region in France, displaying both urban areas from a French government WMS layer alongside a French statistical data layer, with a scale bar. Built with the Leaflet JavaScript library, it combines OpenStreetMap tiles with two Web Map Service (WMS) layers. The first WMS source, accessed via a proxy from `data.europa.eu`, uses `L.WMS.source` and `source.getLayer("Tache_urbaine_1980_R43")`, while the second uses `L.tileLayer.wms` to load INSEE income data from an IGN endpoint.

Add a WMS source untiled

This example shows a map centered on a region in France, displaying a WMS layer of urban areas from 1980 over a basemap. The map uses the maplibre-gl library to render the WebGL map. A raster data source is added via a proxied WMS URL, with the GetMap request specifying the layer, coordinate system, and bounding box. The WMS tiles are integrated using the `map.addSource` and `map.addLayer` APIs.

Add a WMS source untiled

This example shows a MapLibre GL map displaying a French urban-area layer from a WMS service, overlaid on OpenStreetMap raster tiles. The map fetches a WMS GetMap request for the current viewport, using the SphericalMercator library to convert map bounds into EPSG:3857 coordinates for the request. When the user pans or zooms, the `moveend` event triggers removal and re-addition of the image source and raster layer, refreshing the WMS overlay. The code uses `map.addSource` and `map.addLayer` to manage the dynamic image layer.

Leaflet WFS

This example shows a map of water areas rendered as a blue outline over an OpenStreetMap tile layer, with the view centered on coordinates near Cambridge, Ontario. It uses the Leaflet mapping library with the Leaflet-WFST plugin to load features from a GeoServer Web Feature Service endpoint, specifically the `osm:water_areas` layer. The code employs a bounding-box filter defined by the current map extent and sets the coordinate reference system to EPSG:3857 using proj4leaflet and proj4js. The visible style is a simple blue color with a weight of two pixels for the geographic features.

Log related to answer https://gis.stackexchange.com/questions/446578/how-does-qgis-extract-features-from-the-xml-response-of-an-inspire-wfs-server/446580

This example shows a debug log from a GDAL/OGR-based workflow that extracts cadastral parcel features from an INSPIRE WFS server and writes them to a GeoPackage. The log details sequential GDAL API calls, including `GDALOpen`, `GDALDriver::Create`, and repeated HTTP `Fetch` requests, revealing how the WFS driver negotiates capabilities, disables multi-layer definitions, and paginates through `GetFeature` requests. It also demonstrates the internal use of an Expat XML parser for GML reading and a temporary in-memory file (`/vsimem/tempwfs_0x21f0b20/file.gml`) to process the downloaded data. The output shows the explicit `STARTINDEX` and `COUNT` parameters used to fetch batches of up to 10,000 features.

Get datasets/ressources from demo.data.gouv.fr

This visualization shows the complete catalog of datasets and their associated resources harvested from the demo.data.gouv.fr API. It displays the aggregated collection of every resource linked to each dataset, compiled from all paginated API responses. The code uses a shell script with `curl` to repeatedly request pages of 500 datasets until the `next_page` field returns `null`, then pipes the results through `jq` to extract and compile all nested `resources[]` arrays from the combined JSON files. The final output is a flat JSON file containing every resource entry.

Identify if issue with same name in XML WMS capabilities

This example checks WMS GetCapabilities XML files for duplicate layer names, which can cause issues in clients. It parses the XML using either `lxml` or Python’s built-in `xml.etree.ElementTree` via `etree.parse`, then uses XPath expressions to find all `<Layer>` and `<Name>` elements. It filters out names starting with `inspire_common:`, counts occurrences with `collections.Counter`, and prints each duplicated name or a success message. The tool accepts both remote URLs and local file paths through `argparse` and `urllib.request.urlopen`.

"Permalinks all the things"

This example demonstrates how to toggle between distinct French public-sector web applications by sharing a single geographic coordinate. It showcases a catalog of links that parameterize each app’s URL with the same latitude, longitude, and zoom level. The core logic is not a chart but a curated list of permalinks embedded in a Vue.js interface. The code directly references services like Géorisques, ARCEP’s fiber map, and Géoportail Urbanisme, highlighting that each site has its own URL scheme. This approach is presented as a template for adding cross-domain navigation to other public-facing tools.

Gist d64af23db4c1bd6bbacbe72ef137865e

This visualization shows the extraction and tabularization of French Business Tax Service (SIE) locations. It first filters the full public service dataset, downloaded as a JSON tarball via `wget`, using `jq` to select only SIE entries. It then validates the filtered results against the official website's paginated listing, scraped with `pup`. Finally, the code converts the filtered JSON into a simple CSV file using `jq` to output fields like id, name, and postal address, working within the Linux command-line environment.

Gist c8b3e33ae90180e985646e1ef4876dfe

This example demonstrates how to convert tabular JSON data containing longitude and latitude fields into a GeoJSON FeatureCollection using the command-line tool jq, making it ready for map-based visualization. The dataset covers digital mediation locations in the Auvergne-Rhône-Alpes region of France, sourced from data.gouv.fr. The transformation maps each original record into a GeoJSON Feature, preserving properties like name, address, services, and accessibility conditions, while constructing Point geometry from the coordinate pair. The code includes a preview image showing the resulting spatial distribution of these locations, though the visualization itself uses no specific JavaScript mapping library or framework beyond the jq conversion process.

Gist 89bf9a577b15f0a68bb59055eeb415a1

A map of the Paris region displays IGN-F/Geoportail basemap tiles using Leaflet 1.9.2. The code constructs a `L.tileLayer` that requests WMTS tiles from the `wxs.ign.fr` service, specifying the `GEOGRAPHICALGRIDSYSTEMS.PLANIGNV2` layer with a 256-pixel tile size and zoom levels 0–18. Tile coordinates are inserted into the URL via `{z}`, `{y}`, and `{x}` placeholders. The map is centered on coordinates [48.845, 2.424] at zoom 10 using `L.map().setView`.

POC pour rechercher remplacer des URLS dans un projet QGIS

This example shows a Python script that migrates QGIS project files by replacing old French geoportal URLs with new ones in both .qgs and .qgz formats. It first searches and replaces URL pairs directly in .qgs text, and for .qgz archives, it unpacks the zip, applies the same replacement to embedded .qgs files, then repacks the archive. The tool uses standard library modules `argparse`, `tempfile`, `shutil`, and `pathlib` to handle file operations and globbing, while string replacement is done with `str.replace()`.

Miniconda with gdal install

This example demonstrates a command-line recipe for setting up a Python environment with GDAL, the geospatial data abstraction library, using Miniconda. It shows how to configure conda with the conda-forge channel and strict priority, create a virtual environment named `gdal_latest` with Python 3.9, and install both `gdal` and `libgdal` packages. The process relies on conda commands such as `conda config`, `conda create`, `conda activate`, and `conda deactivate` to manage the environment and its dependencies.

Issue for path cli resolving when migrating CommonJS to ES6

This example tracks a path-resolution error that occurs when migrating a command-line tool from CommonJS to ES6 modules. It shows the same `require('..')` call working in CommonJS while its ES6 equivalent, `import {parse} from '../index.js'`, fails with `ERR_MODULE_NOT_FOUND` because the ES6 resolver does not search the `lib` directory. The visualization documents the failing command, the package.json configuration that sets `"main": "./lib"`, and the proposed fix of writing the import as `'../lib/index.js'` instead. The data comes directly from the user’s error trace and file contents.

mapshaper-info-recreated-via-gdal

This example recreates the command-line tool mapshaper-info using the gdal-async library to inspect a GeoJSON TopoJSON file containing German administrative regions. It downloads the dataset from GitHub, then prints layer metadata including geometry type, record count, bounding box, and coordinate reference system, followed by a formatted table of attribute names and their first values. The script uses the got library for streaming downloads and the pipeline function from stream/promises to handle the file writing asynchronously.

Gist dfebda550a6847a46725afb2cfdb1253

This example shows an order-service application built with React, managing order data through a PostgreSQL database via Sequelize and Express. The code defines REST API endpoints for creating, retrieving, and updating orders, using JSON validation with Ajv and TypeBox schemas. It integrates RabbitMQ through amqplib for message queuing, JWT token verification for authentication, and includes comprehensive Jest testing with nock for HTTP mocking and Sinon for spies. The visualization demonstrates a server-side Node.js architecture with async/await patterns, error handling middleware, and logging.

Generation GeoJSON des mairies avec code INSEE

This example generates a GeoJSON file of French town halls (mairies) with their INSEE commune codes, distinguishing principal towns from associated communes. It uses `ogr2ogr` with an SQLite dialect to join commune boundaries with their chief-town points from the IGN ADMIN-EXPRESS dataset, applying `PointOnSurface` as a fallback when no official point exists. The resulting output is written with RFC 7946 compliance for modern web mapping. The script downloads a 7z archive and extracts the necessary shapefiles before performing the spatial join.

Fix QPV validity

This example demonstrates how to repair invalid geometries in a shapefile of priority neighborhoods (QP) in France. It first checks the validity of the original dataset using `ogrinfo` with a SQLite dialect and the `IsValid` function. The script then uses `ogr2ogr` to create a corrected output file by applying `ST_MakeValid` to any invalid geometries, preserving the original attributes and coordinate system. Finally, it re-runs the validity check to confirm that all geometries in the output are now valid. The data originates from the French government's SIG website.

Multiple approaches to solve question at https://lists.osgeo.org/pipermail/gdal-dev/2022-June/055949.html

This example demonstrates three equivalent methods for converting a CSV file with latitude and longitude columns into a GeoPackage with point geometry using GDAL’s `gdal.VectorTranslate`, GeoPandas’ `read_file` and `to_file`, and Fiona’s manual schema definition and feature writing. The CSV contains a single data point (61, -150), and each approach specifies the coordinate column names via `X_POSSIBLE_NAMES` and `Y_POSSIBLE_NAMES` options. The code shows how to set the output CRS to EPSG:4326 and assign a layer name (`layername`) in the resulting GeoPackage.

SIREN et autres traitements autour dont la validation VIES (TVA intracommunautaire)

This example demonstrates how to convert a French SIREN number into a European intra-community VAT number using a modulo-97 formula, then validate that VAT number through the European Commission’s VIES SOAP web service. It presents code in both Python and JavaScript, using libraries such as `zeep` and `requests` with `xmltodict` in Python, and `request`, `node-fetch`, and `xml2js` in JavaScript. The gist shows the full workflow, including building the SOAP XML envelope manually and parsing the response to verify a company’s VAT registration status.

Encadrement des loyers

This visualization maps rent control zones across French metropolitan areas, displaying geographic boundaries and likely rent reference values for cities like Lille, Paris, Lyon, and Bordeaux. It uses D3.js for rendering, with `d3.geoPath` to project GeoJSON and KML data from official sources like data.gouv.fr and the French government’s rent observatory. The map overlays administrative territories (e.g., Est Ensemble, Plaine Commune) and highlights where rent caps apply, integrating spatial data from municipal open-data portals to compare affected regions.

OGR and QGIS MySQL recipes

This example demonstrates how to convert non-spatial MySQL/MariaDB tables with x/y coordinates into viewable vector layers in QGIS. It shows three approaches: using OGR’s SQLite dialect with the `MakePoint` function, using MySQL’s native `ST_PointFromText` function, and creating a geometry column directly in the database. The code uses `ogrinfo`, `ogr2ogr`, and VRT files to bridge GDAL with MySQL, while the final workflow includes loading CSV data through the command line before exporting to the database.

Calcul zonage lié à https://www.gouvernement.fr/civen-comment-etre-indemnise-3002

This example visualizes the compensation zones for French nuclear testing victims, as defined by the government's CIVEN guidelines. It shows two polygons in the Sahara Desert, representing Zone 1 and Zone 2, which are derived from geographic coordinates with specific distances and bearings. The code uses the `@turf/turf` library for geospatial calculations, including `turf.destination` to project points and `turf.convex` to generate the hull polygons. It also uses `parse-dms` to convert degree-minute-second coordinates into decimal values before writing the results to GeoJSON files with Node.js `fs`.

Extrait datatourisme bibliothèques Nouvelle Aquitaine

This map visualization displays the locations of libraries across Nouvelle-Aquitaine, France, sourced from the DATAtourisme dataset via data.gouv.fr. It shows each library as a point on a geographic map, highlighting their distribution throughout the region. The code downloads the dataset, filters entries using `xsv search` for the Library category, and converts CSV records to GeoJSON features with latitude and longitude coordinates. The resulting GeoJSON file is suitable for rendering with a Vue.js framework, likely using a mapping library to display the geographic points.

Gist 28a1d2e30c530c6a170ff5f68798b235

This example curates a set of GeoJSON-based specifications and extensions, organizing them by how they add keys, use multiple files, or serialize for streaming. It lists linked resources such as geojson-t, geocodejson-spec, geojson-ld, and the OGC Features API, alongside STAC and Mapbox simplestyle. It also covers the IMDF format for indoor data and the GeoJSON Text Sequences proposal, presenting a structured reference rather than a rendered map or interactive chart, with no code libraries or visualization APIs involved.

Play with gdal.vectorTranslate in Node.js

This example demonstrates a complete geospatial data processing pipeline using the Node.js `gdal-async` library. It downloads a Natural Earth countries dataset, extracts the ZIP archive, and converts the shapefile to GeoPackage format with `gdal.vectorTranslate`, then transforms the GeoPackage into GeoJSON. The script uses the `got` library for HTTP streaming with progress reporting and `adm-zip` for extraction. This showcases how GDAL's vector translation capabilities can be invoked programmatically in a Node.js environment for format conversion between common geospatial file types.

Use https certificate on localhost with Express

This example shows how to run an Express web server over HTTPS on localhost, delivering a plain-text response. It creates a Node.js application that reads SSL certificate files (`localhost-key.pem` and `localhost.pem`) generated by the mkcert utility, then uses the `https.createServer` method with those credentials. The Express app defines a single route for the root path, and the server listens on port 3001. The code demonstrates the required setup steps, including installing mkcert and generating a trusted local certificate.

Gist edaa46d0ee945829befb88a9e719f0e0

This visualization maps the number of certified organic food operators across French administrative departments, using a choropleth-style representation to reveal regional disparities in organic agriculture density. The data is sourced from the Agence Bio public API, which is queried via a shell script that iterates through department codes. The script uses `curl` and `jq` to extract the `nbTotal` count for each department, storing results in a semicolon-delimited text file. The final map likely employs `d3.geoPath` for rendering the department boundaries, with color intensity or a similar visual encoding driven by the fetched counts.

Demo plotly

This map displays global precipitation values from the 2015_06_30_precipitation dataset, plotting each point as a fuchsia marker on an OpenStreetMap base layer. Built with Plotly.js and D3.js, the script uses `d3.csv` to load the remote data, then `Plotly.newPlot` to render a scattermapbox chart with zoom and drag interactions. The layout initializes the map centered on latitude 38, longitude -90 at zoom level 3, while CSS sizing fills the viewport.

Gist 56db21b335e25668ff86c2e8359bf3d1

This example visualizes tree inventory data from a CSV file, mapping each tree’s location as a point based on longitude and latitude coordinates. The data includes attributes such as species, planting date, height, and diameter. The implementation uses a VRT file to define the CSV’s geometry, with the QGIS XML configuration specifying the point layer’s symbology and coordinate system. The visualization is rendered through QGIS, leveraging the OGR provider to read the spatial data and display it as a map layer with a single symbol renderer.

Gist 8be3539eabe0a1c2e07e749fb3ee6372

This example compares the performance of spatial joins using Dask-GeoPandas, PostGIS, and GPU-based RAPIDS.AI. It downloads Philadelphia parking violation data from CARTO and neighborhood shapefiles, then benchmarks how quickly Dask-GeoPandas processes the spatial join on a local cluster with eight workers. The notebook uses `dask_geopandas`, `dask.dataframe`, and `distributed.Client` to set up parallel processing. It reproduces Paul Ramsey's original benchmark to evaluate Dask-based execution speed against the other technologies.

Suivi avancement LIDAR copie de https://macarte.ign.fr/carte/322ea69dab4c7e5afabc6ec7043b5994/acquisitionslidarhd

This choropleth map displays the progress of LIDAR HD acquisitions across the French national territory, with each polygon representing a survey block and its color indicating the completion percentage. Built with Vue, the visualization fetches GeoJSON data from an IGN web service, converts it from EPSG:3857 to EPSG:4326 using ogr2ogr, and renders the polygons with varying fill intensities to encode the "pourcentag" attribute. The underlying geospatial processing involves jq to parse nested JSON structures, while the frontend directly visualizes the FeatureCollection without additional map libraries.

GDAL VSICURL tests to remote BDTOPO Geopackage France

This example tests GDAL’s VSICURL virtual file system by streaming a remote GeoPackage of French administrative data, specifically focusing on mairie (town hall) geometries. It demonstrates two ogr2ogr commands that query the BDTOPO dataset using SQL joins to extract mairie footprints as multipolygons and their centroids as points, converting them to GeoJSON with EPSG:4326. The visualization shows how both polygon boundaries and point locations are derived from the same remote source, highlighting the ability to perform spatial SQL operations directly on cloud-hosted vector data without local downloads.

Gist e6f4c2723682e0180ff0bbf59f417beb

This interactive map of French dams displays their locations as points across the country, with each point linking to a detailed information page. The visualization is built from a GeoJSON FeatureCollection of dam properties, including height, reservoir volume, river, and owner. The data was cleaned and enriched using shell scripting and the `jq` command-line tool, with the final map likely rendered using a library such as Leaflet or Mapbox. The code shows the use of `ogrinfo` and `ogr2ogr` for geospatial data processing and SQL queries to transform the attributes.

Bookstores and libraries in Ukraine, Extract from OpenStreetMap

This example maps the locations of bookshops and libraries across Ukraine using OpenStreetMap data. It visualizes both point features—bookstores and libraries—extracted via the Overpass API and converted to GeoJSON with `ogr2ogr`, applying `ST_PointOnSurface` to ensure points are placed accurately within polygons. The map supports dynamic interaction, with camera controls allowing users to pan, zoom, and rotate the scene. The visualization is rendered with WebGL, enabling smooth navigation and a clear view of the spatial distribution of these cultural resources from Lviv to Kharkiv and beyond.

Proxy to IGN actu RSS

This example displays the IGN actu RSS feed by proxying it through a PHP script to bypass CORS restrictions. It visualizes the XML content in a web page, using PHP's `file_get_contents` with SSL context options to securely fetch the remote feed from `https://geoservices.ign.fr/actualites/rss.xml`. The script then echoes the raw XML with a `Content-type: text/xml;charset=UTF-8` header, allowing client-side JavaScript to parse and render the latest geospatial news updates. The visualization relies on the returned RSS structure, with no additional charting or mapping libraries involved.

Gist 2bd25e856943977444bac9a5fd8c6408

This example shows a QGIS workflow for automatically populating the application with WMS, WMTS, and WFS service connections from the French IGN geoservices portal. The script scrapes the portal’s documentation page to find a CSV file containing service metadata, parses it using the `csv` module, and deduplicates entries via Python dictionaries. It then defines functions to add or remove connections in QGIS’s settings using `QgsSettings`, configuring parameters like URLs, versions, and axis orientation. The code demonstrates a practical approach to batch-importing OGC web services into a desktop GIS environment.

Get IGN legends for WMS Raster, WMS Vecteur and WMTS webservices

This example visualizes the availability of legends for IGN web services, specifically WMS Raster, WMS Vecteur, and WMTS layers. It shows that 241 out of 598 services have retrievable legend images, while 357 do not. The code downloads a CSV of service metadata from the IGN geoportal, then probes a guessed URL pattern on the geoportail.gouv.fr domain for each layer's legend image using `curl`. Successful results are compiled into an augmented CSV and JSON file, with the legend images stored locally.

Gist 3e4479ddb389f73888daa1181574723c

This visualization displays the geographic boundaries of various British West Indies Grid projected coordinate reference systems, as defined in the EPSG database. Each polygon is rendered as a GeoJSON feature, mapping the area of use for a specific SRID. The code relies on Leaflet’s map rendering to draw these polygons, using the GeoJSON data to plot each bounding box. The visualization is built with Vue.js, which manages the map component and loads the spatial data.

Gist 349fc7fda8932252cbcb4ee8a0b605c8

This example tracks the availability and licensing of the French IGN’s BD TOPO® departmental datasets by organizing URLs for both December 2021 and March 2021 releases. It shows a structured index of geographic data files, with each entry linking to a specific departmental Shapefile resource. The visualization uses a data-driven list format, likely rendered with JavaScript’s `fetch` to parse the provided CSV or JSON and display the sorted URLs. It highlights the variation in resource IDs across departments and time periods, emphasizing the dataset’s scope without mapping or spatial rendering.

Process to convert laz file to DTM

This example demonstrates a command-line workflow for converting a LIDAR point cloud in LAZ format into a digital terrain model (DTM) as a GeoTIFF raster. It shows two approaches using the PDAL library, both relying on its `pipeline` command and `translate` subcommand, paired with the `writers.gdal` writer to output a 0.5-meter resolution TIFF. The process ingests a sample LAZ file from the French IGN LIDAR HD dataset, then uses PDAL’s GDAL writer to generate the DTM, with a failed attempt at using the `writers.ogr` output to shapefile also noted.

Gist ab738ee0d721842fbea501cc96296160

This example demonstrates how to load and manage LiDAR point cloud layers in QGIS using Python, showing both automatic and manual index generation for LAZ files from the French IGN LIDAR HD dataset. It uses the QgsPointCloudLayer class with the PDAL provider, QgsProject for layer management, and QgsPointCloudDataProvider to check indexing state, generate indexes, and retrieve polygon bounds, point counts, and renderer information. The script also prints coordinate reference system details and renderer type, illustrating direct provider-level access to point cloud metadata.

Gist 0bdc45cce93d15fce0d1991d2b4b9e9d

This example demonstrates how to convert a compressed LiDAR point-cloud dataset from IGN’s French national archive into a ZIP archive for easier distribution. The shell script downloads a 7z file via `wget`, decompresses it with `unp`, recompresses the contents into a ZIP using `zip`, and then reports the final disk usage with `du -cksh`. It relies on standard command-line utilities rather than JavaScript libraries, showing a practical data-preparation workflow for large geospatial files.

Gist 9ea54f64f11961c494767a8384892e83

This example demonstrates how to debug a geocoding failure by comparing two CSV files sent to the French government's geocoding API (api-adresse.data.gouv.fr). It shows that renaming the first column from `geocoder__line` to `geocoder__line_number` prevents rows from being silently dropped during the batch geocoding request. The shell script (`debug-geocoder-related-issue.sh`) uses `curl` to POST both files to the API, then displays the first eight geocoded results. The output files include latitude, longitude, and match scores, revealing how column naming affects API behavior.

Gist 32329a8557135f11cb5656e3bfd4d35c

A WebGL map visualizes the locations of French tobacco shops, using points to show their distribution. The code geocodes addresses from an official customs dataset via the data.gouv.fr API, then processes the CSV with the `requests` library. It uses a Vue.js front-end to render the points in a 3D space, allowing users to explore the spatial patterns of the shops.

IGN API elevation line

This example shows elevation profiles extracted from a user-selected line feature in QGIS. It calls the IGN REST elevationLine API with sampled lon/lat coordinates, then builds a GeoJSON FeatureCollection of 3D points with elevation (z) and accuracy values. The script uses `urllib.request` to fetch JSON data and `json.dump` to write a temporary GeoJSON file, which QGIS then loads as a vector layer. Users subsequently convert to a projected CRS and apply the Profile tool plugin to render the elevation graph.

Vanilla JavaScript autoComplete with French GeoAPI endpoint with Leaflet (adapted from my own OpenLayers sample)

Gist fdd290466b27483228fe90a7c3921f15

This example downloads UK weather warning data from the Met Office’s live GeoJSON feed by scraping the page’s embedded `window.metoffice.warnings.geojson` variable with a shell script. It uses `curl` with the current date to fetch the JSON, then formats the output for further processing. The visualization itself is not shown in the provided code, but the script prepares geospatial alert polygons for subsequent rendering, likely with a mapping library such as D3’s `d3.geoPath` or Leaflet. The data source is the Met Office’s official warnings API, captured daily for time-series analysis.

A Leaflet map!

Gist 12513350e4462cdfb258efe4cb8df145

This map visualizes the locations of tobacco retailers in the Ain department of France, with each point geocoded from a public directory of licensed shops. A marker shows the position of every vendor, with details available for each location. The visualization likely uses a geographic rendering library such as D3.js with `d3.geoPath` to display the map, while the underlying data comes from the `annuaire-des-debits-de-tabac-deb.geocoded.geojson` file, which contains coordinates and metadata for each establishment.

Display cadastre on Maplibre

This interactive map displays the French land registry, or cadastre, within the Maplibre GL rendering engine. It shows administrative boundaries—from regions down to individual communes—along with detailed cadastral sections, parcels, and buildings. Using the WebGL-driven Maplibre GL API, it loads vector tile sources from `openmaptiles.geo.data.gouv.fr`, with parcel lines appearing at zoom level 16 and property numbers labeled for identification. The styling, defined in a JSON style sheet, uses fill and line layers with conditional opacity to highlight parcels.

Saved copy of LibreOffice GetRest Plugin

This example showcases a static snapshot of the LibreOffice GetRest Plugin, a tool for generating REST API documentation, preserved as a README file. It displays the plugin’s metadata and a link to its archived download, highlighting its historical availability. The visualization likely uses d3.forceSimulation or d3.geoPath for rendering, though the code only reveals text-based data from a gist. The source data originates from a gist by ThomasG77, capturing the plugin’s deprecated state and web archive fallback.

Leaflet rotated marker example

This example displays a bus route in Málaga as a GeoJSON LineString on a Leaflet map, with red leaf icons at each recorded stop. The code uses the Leaflet rotatedMarker plugin to rotate each marker according to a `rotation` property array, visualizing the bus's changing heading over time. It loads the map with `L.map` and an OpenStreetMap tile layer, then iterates through the feature coordinates to place custom icons whose rotation angles are set via `rotationAngle`. The plugin overrides `_setPos` and `_applyRotation` to apply CSS transforms for rotation.

Un peu laxiste sur les droits

This example demonstrates how an FTP directory from the French IGN geospatial agency can be served over HTTPS by mounting it as a local filesystem. The visualization shows a browsable file listing generated by an Nginx `autoindex` directive, which exposes the contents of a `curlftpfs`-mounted remote FTP server. The code relies on `curlftpfs` to mount the FTP source (`ftp://Iris_GE_ext:…@ftp3.ign.fr`) with `allow_other` and permissive permissions, and on Nginx’s `alias` and `autoindex` to render the directory tree. The interface lists downloadable geospatial datasets (e.g., IRIS-GE shapefiles) without requiring users to install an FTP client.

Demo PKG binary to serve html content

This example demonstrates how to package a static website into a standalone executable binary using the `pkg` tool. The code uses Express to serve the contents of a `dist` folder, which it retrieves by downloading and unzipping the `doc.data.gouv.fr` GitHub Pages repository via a shell script. After building the binary with `npm run build`, the user can launch it on any OS and access the site at `http://localhost:8081/`. The visualization highlights the workflow of converting web content into a portable, offline server application.

VRT recipe for CSV

This example demonstrates how to convert a CSV file containing building bounding box coordinates into a polygon vector layer using a VRT (Virtual Dataset) recipe. The visualization shows a map of building footprints as rectangles derived from the xmin, xmax, ymin, and ymax columns in the CSV. It works by using an OGRVRTDataSource with SQLite dialect in the `demo-sql-csv.vrt` file, where the `ST_PolygonFromText` function constructs spatial geometries from the coordinate data. The technique is presented as a lightweight alternative to processing GeoJSON files, and can be viewed in QGIS or inspected via GDAL command-line tools like `ogrinfo`.

Gist 12c85e5e65b7776fd6d86bf9cb00a1bc

This example shows a diagnostic snapshot of the host machine, collecting system metadata into a JSON file. It builds a dictionary of platform details, network identifiers, and hardware statistics, then uses `pprint` to display the result and writes it to `out.json`. The script relies on `distro.linux_distribution()` for OS info, `psutil` for CPU, disk, and RAM usage, and `platform` and `socket` for release and hostname data. It also formats disk totals with `hurry.filesize.size` and computes the MAC address via `uuid.getnode()`.

Gist f2c843666c84195a872efebcc21f1f9f

This PyQGIS script exports the column metadata of an active PostgreSQL layer to a CSV file. It shows the structure of every column, including data type, nullability, precision, defaults, and comments from the `information_schema.columns` view. Working within QGIS, it uses `QgsProviderRegistry` to create a PostgreSQL connection, executes the query via `executeSql`, sanitizes null `QVariant` values, and writes the results with Python’s `csv` module. The final CSV file is then added back to the map as a vector layer.

Gist b3d6991a9d7ab3de6f7f13e7ed38e097

This map shows the municipal arrondissements of Lyon and Marseille in France, with each district colored according to its population. The visualization loads GeoJSON data describing the polygon boundaries of each arrondissement and uses the ogr2ogr library to convert the shapefile data. The interactive display, viewed through GeoJSON.io, renders the geographic features using standard web mapping tools and displays the population values stored in each polygon's properties when the user clicks or hovers over a district.

VRT to merge vector data

This example demonstrates how to merge multiple vector datasets into a single unified dataset using the Virtual Dataset (VRT) format, specifically for French IRIS geographic zones. It shows the workflow of combining shapefiles from different territories and projections into one WGS 84 layer without creating an intermediate file, then converting the result to GeoPackage and PostGIS formats. The code uses the `ogrmerge.py` GDAL utility to create the VRT, `ogr2ogr` for format conversions, and psql commands for database setup.

Make screen from Geoportail site, hiding help

This example captures a screenshot of a Geoportail map page after programmatically hiding its help layer. It uses Puppeteer, a Node.js library controlling headless Chrome, to navigate to the provided URL. The script waits for the map to fully load with `waitUntil: 'networkidle0'`, then locates and clicks the `#help-layer` element to dismiss it before saving the view as a PNG. A Python version uses the ported Pyppeteer library with identical logic.

Adding keybase.io proof

This example demonstrates a keybase.io proof of identity, showing the cryptographic signature and JSON payload that links a GitHub account (ThomasG77) to a Keybase username (thomasg77). The visualization uses the parsed keybase.md file to render the signature block and fingerprint, likely with a custom layout or text-based rendering. It relies on d3.js for DOM manipulation and layout, though no specific force or geometry APIs are visible in the provided code. The data source is the gist’s Markdown content, and the approach centers on displaying the proof’s structural components.

Gist 1aa1bf66d847be043a246df8bf74793e

This example demonstrates how to load multiple CSV files containing Chinese-character field names as spatial layers in QGIS. The script uses the PyQGIS API, specifically `QgsVectorLayer` with the `delimitedtext` provider, to parse longitude and latitude columns named 經度 and 緯度. It iterates through all CSV files in a directory using Python’s `glob` and `os` modules, constructs a URI with URL encoding via `urllib.parse.quote`, and adds each resulting point layer to the project with `QgsProject.instance().addMapLayer`. The sample data shows simple occurrence records with coordinates.

Gist 516c27edc013850e5fa703af9f9c0f03

This interactive visualization maps French EPCI administrative units using a force-directed layout, showing clusters of communes grouped by their intercommunality category. It uses d3.forceSimulation to position nodes representing each EPCI, with the underlying geoJSON data from the epci2020 file providing the administrative codes and names. The rendering translates the simulated node positions into geographic coordinates, allowing users to see the spatial distribution of these administrative groupings across France.

Gist 003d087ad317bf871eabd0fb77a719eb

This visualization maps the road network and settlements of the ancient Roman world, drawing data from the OmnesViae API, which sources from the Tabula Peutingeriana and Itinerarium Antonini. It shows geographic points for named places and line segments for roads, with each road assigned a kind attribute. The code uses Python with the requests library to fetch JSON data, then reformats it into GeoJSON FeatureCollections for roads and points, reversing coordinate order for the line strings.

Gist dae8e8a76db4fc720fb18d261da4076f

This visualization is a debugging aid for a Stack Exchange question about WKB (Well-Known Binary) structure errors. It renders a dense polygon geometry, likely a complex map boundary, from a hexadecimal WKB string using PostGIS’s `ST_GeomFromWKB` and `ST_AsText` functions. The code uses the Leaflet JavaScript library to display the resulting shape on an interactive slippy map, allowing users to inspect the coordinate sequence and identify where the WKB byte order or size might be malformed. The polygon appears as a single, highly detailed feature, emphasizing the raw geometry over any thematic styling.

Gist f1a627d4af91444f3fcaea66c62c8319

A Leaflet map centered on France displays a circular buffer polygon around a point at coordinates (2.18, 46). The example uses proj4js and the reproject library to convert the point from WGS84 to EPSG:3857, then applies jsts.io.GeoJSONReader to read the geometry and create a 40,000-meter buffer via the jsts buffer method. After writing the buffered geometry back to GeoJSON, it reprojects to WGS84 and renders the result as a Leaflet GeoJSON layer on OpenStreetMap tiles, with a scale control and a marker at (0,0).

Gist 80f99a186a44e6fa1930f2a08618d498

This visualization displays a QGIS project containing world map layers—countries, states, provinces, and disputed borders—from the bundled `world_map.gpkg` GeoPackage, alongside JSON-derived point layers for contributors, hackfests, and user groups. Using the QGIS Python API, the script loads each vector layer via `QgsVectorLayer` with OGR drivers, adds them to the project through `QgsProject.instance().addMapLayers`, and enables a retro canvas style by setting `iface.mapCanvas().setProperty("retro", True)` before refreshing. The example demonstrates procedural map composition from built-in geodata files.

MBTiles server

This example demonstrates serving map tiles from MBTiles files through multiple server-side implementations. It shows how raster and vector tile data can be exposed via HTTP endpoints using PHP libraries like Tileserver-PHP and MBTiles-PHP, Node.js tools such as Tileserver GL and TileStream, the Go-based mbtileserver, and Python’s python-mbtiles. The code highlights different rendering and delivery approaches, from static raster tiles to server-side vector tile processing, without relying on client-side visualization APIs like d3.geoPath or WebGL. The data source is the MBTiles format, a SQLite-based container for tiled map data.

Gist c5b36ec2877ccb9f2988ee8ef64d9a76

This visualization shows the overlap of Sentinel-2 land cover download scenes across Western Europe, displayed over an OpenStreetMap base layer. The map uses a QGIS project file to pull data from an ArcGIS FeatureServer, filtering for the LULC 2020 dataset. The rendering is handled via the project’s canvas, which displays the geographic extent in WGS 84 coordinates, allowing viewers to see the spatial distribution of available satellite imagery download areas.

Display a map

This example shows an interactive 3D map of a running track at the Red Bull Ring, with the route extruded vertically from the terrain to visualize elevation changes. Built with MapLibre GL and Turf.js, it renders OpenStreetMap raster tiles as the basemap and uses WebGL to display a semi-transparent red fill-extrusion layer whose height corresponds to the elevation values from the GeoJSON LineString coordinates.

Gist 61afda568887fcc603e1f9ef963925ec

This example demonstrates a QGIS Processing model that exports spatial data to a PostgreSQL/PostGIS database. The model chains two algorithms: `qgis:postgisexecuteandloadsql` to run SQL and load the result, followed by `qgis:importintopostgis` to write the output to a table named "out2" in the public schema. It uses the PostgreSQL connection "EPSG demo," sets UTF-8 encoding, and creates a geometry column. The model shows a reusable workflow for automating database ingestion directly from the QGIS Processing framework.

Gist 0f103baa5001934bf981bb7855d60a5e

This example captures the OpenStreetMap legend at every zoom level from 1 to 19. The code uses Puppeteer to automate a headless browser, setting a French locale and a desktop viewport, then screenshots the legend panel at each zoom step. It relies on Puppeteer’s `page.evaluate`, `boundingBox`, and `page.screenshot` with a clip rectangle to extract the legend region. A companion Python script with PythonMagick computes image signatures to identify duplicate legend images across zoom levels.

Gist c32a8597373bd00c10029d4f21f2400e

This example demonstrates how to convert a GDAL VRT (Virtual Dataset) into a single raster file using the `ogr2vrt` utility. It shows a command-line workflow where a shell script first installs the `gdal-utils` package via `pip`, then locates the installed samples directory to make the utility scripts executable, and finally runs `ogr2vrt.py` to perform the conversion. The code relies on Python’s `osgeo_utils` module and standard shell commands to manage the GDAL sample tools.

OpenLayers example

This example shows a map centered on a location in Africa, with a single polygon feature overlaid on a tiled OpenStreetMap basemap. The map is created with OpenLayers, using its `ol.Map`, `ol.layer.Tile`, and `ol.source.OSM` components. The polygon’s coordinates are then parsed from OpenLayers’ geometry format into a JTS geometry object using the `jsts.io.OL3Parser`, with the resulting coordinate list printed to the console for inspection.

Gist 207d4ca5cb9d116c81752a3c17d6c24b

This map visualizes Burkina Faso’s administrative polygons, likely distinguishing regions by color or stroke. It uses D3.js to load and render the GeoJSON features with `d3.geoPath` and a geographic projection, displaying the country’s boundaries as vector shapes. The code references a two-polygon dataset and appears suited for choropleth or boundary mapping, with the rendering handled directly via SVG or Canvas.

Gist 220c74f4b10f7cac94fceecf9c09a313

Gist 5d532db200169ca3dc1c5a10a83e13ee

Convert coordinates in DMS notation to decimal in Python.

Add a WMS Single source

Quick Start - Leaflet

Gist 048fc9a490b8fef7d11c91fda8de04b5

Alternative to bundle with full projection support

Gist 0f063f92e149710175b92bca1e0cff31

CMake 3.20 in Ubuntu 18.04 (reversible way)

This example documents a reversible procedure for upgrading CMake to version 3.20 on Ubuntu 18.04 without breaking dependent packages like ROS. It demonstrates building CMake from source using `wget` and `tar`, then packaging it with `checkinstall` to enable later removal. The process verifies the installation with `apt-cache policy` and `cmake --version`, and explains how to revert by switching versions via `apt-get install cmake=VERSION`. The instructions are written as a markdown guide, using shell commands for each step.

Gist c4a8fcc25bf7f635562d8367e2a3a660

Display a map on a webpage

Gist 85b65534beca578b8eab3826e50f0637

Generate tiles scan 1000

QGIS 3 standalone application sample

Using OpenLayers with Parcel

OSMF 2021 Survey Regions

Gist 32c349dbe43e41e4653eb958d4b9a667

Gist 968bea4c8a1c394a4de656559493d66a

Generate image from drawing https://py.plainenglish.io/convert-a-photo-to-pencil-sketch-using-python-in-12-lines-of-code-4346426256d4

Need to split PDF every n pages, do it with pdftk

Gist 420946967a519c0710753558996ace55

Gist 243f658d1001b2e31c18d383a6757c77

Gist a28c4484e7ca5d4a2d831cee8f127b6a

Get result of page 1 to count for paging calls

Test torrent command line from URL using lftp and aria2c

Convert single OpenVPN file to multiple to be compatible for import in Gnome VPN manager (improved from https://askubuntu.com/questions/134918/setting-vpn-client)

Demo raster tile source + GeoJSON line + onclick on map

Demo raster tile source + GeoJSON line + onclick on map

About PyQGIS processing to print atlas

Tagging enseigne Flam's OpenStreetMap

PyQGIS add WMS layer standalone sample (use capabilities listing from owslib)

Vega-Lite Age Pyramid

ol-ext: Layerswitcher

Compile Seasnake on Ubuntu 18.04

Gist d15771bb30c231166701cf31788f8a6b

Gist d9c04724e63f3d327bd3ff7534bc0968

URL des KMZ de https://www.francebleu.fr/sports/cyclisme/cartes-tour-de-france-2020-zoomez-sur-le-trace-des-21-etapes-1596713392

QGIS algorithms

Gist 4e22024b5742c4550f00cbddf2b6deed

Gist fcc5e496a00471f276d798a8f64a39e4

Freehand Drawing

CSV of https://www.arcgis.com/sharing/rest/content/items/a182011915884ca987b217294c30f6c1/data?f=json

QGIS tips

Generate single page documentation for expressions

Add this script in startup.py to now see zoom for EPSG 3857 when the canevas is using it

Set scale from zoom level value for EPSG 3857. See if you want to do the opposite https://gist.github.com/ThomasG77/7c2ecd106091a335a2138dcd82565db8#file-pyqgis-add-zoom-levels-3857-py-L5

Python functions to convert from/to zoom level to scale (assuming 96 dpi and latitude 0)

Gist 2d1531a8ec270b98606530d4108ea9df

Call QGIS Server via Flask

Comptes SDIS sur Twitter au 6 juin 2020

PyQGIS recipe to learn about selected features and return result as an ordered dict of fields names, values

Popup

Run Jupyter notebook with PyQGIS

Gist 440006f4c5f88bd38dfabc84beb699d5

Gist 992665c4e851cf140c0af7e1c6487b38

StackOverflow Galaxy Hidden Secrets

https://veillecarto2-0.fr/2020/05/18/premiers-pas-sur-leaflet-partie-iii-afficher-un-geojson/

Leaflet Routing Machine Example

Gist 72fd711bda2ec0c8b95a0dacd2dbb942

Gist 6ab06618c0df1ddbd8de4e1de449d631

Gist ded019fbd2d7ba05c21985f66949a422

Gist 947212b91b57e69e25982dadb77afcf6

Gist ffd07819ff8e9532619b633ce3535093

Gist 71def7a758bfa75425d5bc87dde68906

Create, update and list issues from Bitbucket API V2 using CURL

Leaflet with D3 popups

Gist ddd8d5fded6cc531f00b8d73bd3ada4d

Gist 963f269756daf33c4c1b5e786d5914a4

Archives Séminaire QGIS FR

Données publiques de l&#39;ONF en Métropole

Gist 73f691bb9828d4f88de189d5f644805d

Get shp count from directory

Geocode Labelisation France Service

#30DayMapChallenge

Greasemonkey script to restore URL view in Google search

Demo récupération cityway API

Import pour scrapper parcs et jardins de Nantes

Docker/Docker-compose recipes

Overpass JSON

Gist e9e3d4541836de6f608d7a02b3dde7ae

GDAL2Tiles - Images with Leaflet

Leaflet.Spin

Take a GeoJSON as an input, take all H3 hexagons within and output GeoJSON hexagons with their id

Generate some H3 polygons

Standalone QGIS app for QGIS 3.0 (borrowed code for QGIS 2.x from https://subscription.packtpub.com/book/application_development/9781783984985/1/ch01lvl1sec18/creating-a-standalone-application)

Jsonix WMS

Démo pour montrer comment reprojeter en EPSG 2154 un CSV issu du géocodage de l'API CSV de http://adresse.data.gouv.fr/

Tile layers examples

Buffer example

Promise.race illustrated with sourceforge mirrors

A simple map

Line Chart

Google Maps integration example

Docopt in JavaScript

Marker Animation

Geolocation

Colors events snippet

ol-ext: Control button

Simple Map using native ECMAScript modules

Browserifiied version of arc.js

Finland map with local OpenStreetMap basemap

Finland Aeromagnetic anomalous map with Proj4

Simple Map with mask between 2 layers

Map Export with PNGW &amp; PRJ files

Using OpenLayers with Webpack

PyQGIS script to save/load/wipe XYZ sources in Browser Panel in QGIS3

Constrainted drawing (based on official Measure example)

WFS

WMS Capabilities Parsing

Thematic map with legend

Simple Map with default interactions

Leaflet With simplestyle Markers

Videos link including timing for the "7th QGIS UK Scottish user group"

Reverse geocoding

Gist f5e73e2d2b6fe50b2806398780a673d1

Simple OpenStreetMap Map

Simple Map

Javascript equivalent to python dict(zip(['AB', 'CD', 'EF', 'GH'],[1, 2, 3, 4])) - 2 js arrays to one js object

Gist 436f701dc8248786a6620b350976592a

Dirty Javascript reproduction of https://twitter.com/jplur_/status/891358168688754688

gpkg vrt sample using http://ngageoint.github.io/GeoPackage/examples/rivers.gpkg

Promise and exec

Sleep function in JavaScript (need node v7.10+, borrowed from https://twitter.com/samccone/status/859777976199659521)

Simple Map with GeoJSON markers

Essai d'envoi de SMS uniquement avec Node et un abonnement Free.fr (adaptée à 90% de http://blog.nicolasc.eu/utiliser-api-de-notification-sms-free-mobile-depuis-node-js/)

List of questions related to Node (from https://medium.freecodecamp.com/before-you-bury-yourself-in-packages-learn-the-node-js-runtime-itself-f9031fbd8b69) 2 ​

vue-i18next demo

Gist 1fe4abada8a79cf42dce58c5a29d4fb2

Vector Examples

Scribble map

vega for time series chart with shaded blocks

Minard online demos inventory

My Web Map

5 minutes PgAdmin4 Desktop install guide

Syndrom: FATAL ERROR: CALL_AND_RETRY_LAST Allocation failed - process out of memory

proj4js v2 example

Gist 4f26bebf7a16e3716ed14f1f83946a99

Simple Map

Exemple de Leaflet sans Browserify

Python sample to call to adresse.data.gouv.fr

Translate extent to use with gdal_translate

Minimal WebWorker example

Prepare Github repo to manage npmjs release publication

Default file for adding OSM background in QGIS

Gist 019eb4d29d1d9742ef41

Villes ou arrondissements > 100 000 habitants en France

Románské kostely v Česku

Vector layer example

Gist 9e05f8cd04f0406e4529

Clustering example

Exemple SVG

Gist c82aafb197157f2bd666

OpenLayers 3 with Browserify

Just one method to convert 2D to 3D geometry with shapely

OpenLayers Basic OSM Example

Minimum fabfile.py to connect to Vagrant

Gist 0fc446643d2d8b3e0e05

Proj4js 2.x support with OpenLayers 2.x. Open the brower console to see the result

Proj4js classic demo based on OpenLayers 2.x and Proj4js 1.1. Open the brower console to see the result

OpenLayers 3 - debug error

Swipe between layers

Gist 4a2a21c09769d29597bb

Gist 2758a01711fa26beb023

Gist 42c1174287e3ed60f7bb

Gist 1e983339031c51389bde

Gist d4a6d55663d524237c14

Get each individual EU-DEM tiles from http://www.eea.europa.eu with a batch. You need wget (apt-get install wget for Ubuntu/Debian or on Windows go to http://gnuwin32.sourceforge.net/packages/wget.htm for installing) After, just do in command-line wget -c -i dem_eu.txt

OpenLayers Basic OSM Example with zoom level display

How to deal with renaming invalid UTF8 characters in directories or files

Gist ba74aeceb82ba00ca603

PHP PostGIS to GeoJSON

Liste fichiers orthophotos nantes 2005

Orthophotos nantes telecahrgement et decompression

Given a WGS84 bounding box and an OSM tile zoom range calculates a total number of tiles.