Skip to main content
100%

Stratified random sampling of GPKG files for use in MapAccuracy, with optional grouping division and bias

✓ Published0🌍 Public
Aalpha-beta-soup
Last edited May 19, 2025
Created on Apr 2, 2023

This example demonstrates a stratified random sampling workflow for preparing GeoPackage (GPKG) vector data for MapAccuracy validation, using `geopandas` to read and explode geometries, then applying per-class sample sizing with finite population correction, optional area-based weighting with fractional power transforms, and optional grouping into numbered sample groups. It uses `pandas` for data manipulation and NumPy for statistical calculations, with the final output written as a GPKG containing mapped, truth, checked, and comment fields.

AI-generated description

Similar vizzes

Loading thumbnail…

Geometry simplification script (GPKG, Snakemake, geopandas, pygeos)

This example shows a geometry simplification workflow for geospatial vector data, reducing coordinate precision while preserving topology and repairing invalid geometries. It processes an input GeoPackage file, simplifies geometries using a quantisation tolerance, and writes the result back as a GPKG. The script uses geopandas for reading and writing, pygeos for `make_valid` and `simplify` operations, and Snakemake to manage input/output parameters and logging. It also filters out empty or missing geometries before saving the final dataset.

Aalpha-beta-soup
70% match
Loading thumbnail…

Geospatial libraries for Python

This example presents a curated overview of geospatial libraries for Python, organized by their primary function, such as data analysis, API clients, visualization, and map-based toolkits. The list is presented in plain Markdown, linking to projects like GeoPandas, Shapely, Folium, and Mapnik, with each category clearly labeled. The visualization is a simple textual reference guide, showing the ecosystem of available tools, rather than a graphical chart or map.

EEleonore9
53% match
Loading thumbnail…

just a bookmark of random psql queries.

This example visualizes spatial relationships between neighborhoods, city blocks, and demographic data in Portland and Laurelhurst through a series of SQL queries. The code shows how geographic joins and intersections are performed using PostGIS functions like `ST_Intersects`, combining building footprints, block polygons, and census block-group data. The queries calculate race-based percentages, such as percent white and percent black, from census fields like `h7x002` and `h7x003`, while filtering for specific places and positive population counts. The gist demonstrates iterative query building for choropleth-style analysis, revealing how raw geographic and tabular data are merged to support subsequent mapping or charting in a visualization tool.

CCaged
52% match
Loading thumbnail…

Generating random raster landscapes for generating performance benchmarking cases

This example generates 500 discrete and 500 continuous random raster landscapes as ASCII grid files for performance benchmarking. It uses the `nlmpy.mpd` function to create midpoint displacement neutral landscape models, then classifies the discrete layers with `nlmpy.classifyArray` and random integer thresholds. Each raster is exported with `nlmpy.exportASCIIGrid`, including randomized georeferencing metadata via a lambda function that jitters the corner coordinates. The code relies on NumPy’s seeded random number generator and Python’s `random` module to ensure reproducible but varied outputs across the 100×100 cell grids.

Aalpha-beta-soup
51% match
Loading thumbnail…

Gist 1353003

This example demonstrates a spatial SQL query that computes raster statistics for a custom polygon region. It uses PostGIS functions to sum pixel values, count pixels, and calculate the average value across a 10x10 grid of sub-pixels within each raster tile. The query filters raster tiles intersecting the target polygon and then intersects translated grid cells against the same polygon. The code relies on `ST_Value`, `ST_Intersects`, `ST_Translate`, `ST_MakeEnvelope`, and `generate_series` to perform the analysis, extracting data from the `carbon_query_test_s` table.

Aandrewxhill
51% match
Loading thumbnail…

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

This example visualizes river geometry from a GeoPackage file by wrapping it in an OGR Virtual Format (VRT) layer. The VRT defines a SQL query that selects all rows from the `rivers` table, allowing the data to be accessed through GDAL’s OGR API without modifying the original GeoPackage. The visualization uses the VRT as a data source, enabling standard geospatial rendering libraries to draw the river paths. It demonstrates how a lightweight VRT file can bridge a binary GeoPackage to a web or desktop mapping context, making the underlying vector features accessible for display and analysis.

TThomasG77
51% match
Loading thumbnail…

Gist 05f4cffac50217bd0c33a538cb013563

This example visualizes geographic routing and geocoding workflows in R, showing how spatial data can be processed and mapped. It installs and loads packages for text mining, word clouds, and interactive map viewing, including `ggplot2`, `tm`, `wordcloud`, and `RColorBrewer` for static and corpus-based visualizations. The code also integrates the `photon` and `osrm` packages via `devtools` to access geocoding and routing APIs, enabling point-and-route calculations. The visualization pipeline combines spatial operations with text analytics, demonstrating a multi-step data enrichment and mapping process.

RRCura
50% match
Loading thumbnail…

Gist 9bd5ca69fc039cff50383b3a3459858b

This example shows how to render a spatial distribution of data points on a map using D3.js. It uses `d3.geoPath` to draw geographic boundaries and `d3.forceSimulation` to position overlapping points, while Canvas `getImageData` is used to read pixel data for collision detection. The visualization reads from a PGP-encrypted text file, suggesting the underlying dataset is not directly accessible. The code relies on D3’s selection and transition APIs to animate point movements, and it appears to use a projection to convert latitude and longitude coordinates into screen positions. The result is an interactive scatterplot overlaid on a map, with points dynamically adjusting to avoid overlap.

CCliffordAnderson
50% match