geospatial-visualization
/geospatial-visualization
Master geographic and mapping visualizations with GeoViews. Use this skill when creating interactive maps, visualizing point/polygon/line geographic data, building choropleth maps, performing spatial analysis (joins, buffers, proximity), working with coordinate reference systems, or integrating tile providers and basemaps.
- Author
- uw-ssec ↗
- Repository
- rse-plugins ↗
- Licence
- BSD-3-Clause
- Last repository change
- 14.10.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 5
No signals detected. Repository changed on 14.10.2026, without references to retired models or APIs.
BSD-3-Clause, otwarta.
What it does and when to use it
Master geographic and mapping visualizations with GeoViews. Use this skill when creating interactive maps, visualizing point/polygon/line geographic data, building choropleth maps, performing spatial analysis (joins, buffers, proximity), working with coordinate reference systems, or integrating tile providers and basemaps.
Original author description
Master geographic and mapping visualizations with GeoViews. Use this skill when creating interactive maps, visualizing point/polygon/line geographic data, building choropleth maps, performing spatial analysis (joins, buffers, proximity), working with coordinate reference systems, or integrating tile providers and basemaps.
How it works
- Overview
- Dependencies
- Core Capabilities
- Spatial Analysis Workflows
- Tile Providers and Basemaps
- Best Practices
- Common Patterns
- Integration with Other HoloViz Tools
- Common Use Cases
- Troubleshooting
SKILL.md preview
---
name: geospatial-visualization
description: Master geographic and mapping visualizations with GeoViews. Use this skill when creating interactive maps, visualizing point/polygon/line geographic data, building choropleth maps, performing spatial analysis (joins, buffers, proximity), working with coordinate reference systems, or integrating tile providers and basemaps.
---
# Geospatial Visualization Skill
## Overview
Master geographic and mapping visualizations with GeoViews and spatial data handling. This skill covers creating interactive maps, analyzing geographic data, and visualizing spatial relationships.
## Dependencies
- geoviews >= 1.11.0
- geopandas >= 0.10.0
- shapely >= 1.8.0
- cartopy >= 0.20.0 (optional)
- pyproj >= 3.0.0
## Core Capabilities
### 1. Basic Geographic Visualization
GeoViews extends HoloViews with geographic support:
```python
import geoviews as gv
import geopandas as gpd
from geoviews import tile_providers as gvts
# Load geographic data
world = gpd.read_file(gpd.datasets.get_path('naturalearth_lowres'))
# Basic map visualization
world_map = gv.Polygons(world, vdims=['name', 'pop_est']).opts(
title='World Population',
height=600,
width=800,
tools=['hover']
)
# Add tile layer background
tiled = gvts.ESRI.apply.opts(
alpha=0.4,
xaxis=None,
yaxis=None
) * world_map
```
### 2. Point Data on Maps
```python
# Create point features
cities_data = {
'city': ['New York', 'Los Angeles', 'Chicago'],
'latitude': [40.7128, 34.0522, 41.8781],
'longitude': [-74.0060, -118.2437, -87.6298],
'population': [8337000, 3990456, 2693976]
}
cities_gdf = gpd.GeoDataFrame(
cities_data,
geometry=gpd.points_from_xy(cities_data['longitude'], cities_data['latitude']),
crs='EPSG:4326'
)
# Visualize points
points = gv.Points(cities_gdf, kdims=['longitude', 'latitude'], vdims=['city', 'population'])
points = points.opts(
size=gv.dim('population').norm(min=5, max=50),
color='red',
tools=['hover', 'box_select']
)
# With tile background
map_with_points = gvts.CartoDEM.apply.opts(alpha=0.5) * points
```
### 3. Choropleth Maps
```python
# Color regions by data value
choropleth = gv.Polygons(world, vdims=['name', 'pop_est']).opts(
cmap='viridis',
color=gv.dim('pop_est').norm(),
colorbar=True,
height=600,
width=900,
tools=['hover']
)
# Add interactivity
choropleth = choropleth.opts(
hover_fill_color='red',
hover_fill_alpha=0.5
)
```
### 4. Interactive Feature Selection
```python
from holoviews import streams
# Create selectable map
selectable_map = gv.Polygons(world).opts(
tools=['box_select', 'tap'],
selection_fill_color='red',
nonselection_fill_alpha=0.2
)
# Stream for selection
selection_stream = streams.Selection1D()
def get_selected_data(index):
if index:
return world.iloc[index[0]]
return None
# Get info about selected region
selected_info = hv.DynamicMap(
lambda index: hv.Text(0, 0, str(get_selected_data(index))),
streams=[selection_stream]
)
```
### 5. Vector and Raster Layers
```python
# Multiple layers
terrain = gvts.Stamen.Terrain.apply.opts(alpha=0.3)
points = gv.Points(cities_gdf, kdims=['longitude', 'latitude'])
lines = gv.Lines(routes_gdf, kdims=['longitude', 'latitude'])
# Compose layers
map_composition = terrain * lines * points
# Faceted geographic display
faceted_maps = gv.Polygons(world, vdims=['name', 'continent']).facet('continent')
```
### 6. Hexbin and Rasterized Aggregation
```python
# Hexbin aggregation for point data
hexbin = gv.HexTiles(cities_gdf).opts(
cmap='viridis',
colorbar=True,
height=600,
width=800
)
# With tile background
map_hexbin = gvts.CartoDEM.apply.opts(alpha=0.4) * hexbin
```
## Spatial Analysis Workflows
### 1. Spatial Joins
```python
# Combine different geographic layers
points_gdf = gpd.GeoDataFrame(
cities_data,
geometry=gpd.points_from_xy(cities_data['longitude'], cities_data['latitude']),
crs='EPSG:4326'
)
regions_gdf = gpd.read_file('regions.geojson')
# Spatial join: which cities are in which regions
joined = gpd.sjoin(points_gdf, regions_gdf, how='left', predicate='within')
# Visualize result
joined_map = gv.Points(joined, kdims=['longitude', 'latitude']) * \
gv.Polygons(regions_gdf)
```
### 2. Buffer and Proximity Analysis
```python
from shapely.geometry import Point
# Create buffer zones
buffered = cities_gdf.copy()
buffered['geometry'] = buffered.geometry.buffer(1.0) # 1 degree
# Visualize buffered regions
buffers = gv.Polygons(buffered).opts(fill_alpha=0.3)
points = gv.Points(cities_gdf)
proximity_map = gvts.CartoDEM.apply.opts(alpha=0.3) * buffers * points
```
### 3. Distance and Route Analysis
```python
# Calculate distances between cities
from shapely.geometry import LineString
routes = []
for i in range(len(cities_gdf) - 1):
start = cities_gdf.geometry.iloc[i]
end = cities_gdf.geometry.iloc[i + 1]
route = LineString([start, end])
distance = start.distance(end)
routes.append({'geometry': route, 'distance': distance})
routes_gdf = gpd.GeoDataFrame(routes, crs='EPSG:4326')
# Visualize routes
route_lines = gv.Lines(routes_gdf, vdims=['distance']).opts(
color=gv.dim('distance').norm(),
cmap='plasma'
)
```
## Tile Providers and Basemaps
```python
# Available tile providers
from geoviews import tile_providers as gvts
# Different styles
openstreetmap = gvts.OpenStreetMap.Mapnik
satellite = gvts.ESRI.WorldImagery
terrain = gvts.Stamen.Terrain
toner = gvts.Stamen.Toner
# Use with visualization
map_with_osm = gvts.OpenStreetMap.Mapnik * gv.Points(cities_gdf)
# Custom styling
base_map = gvts.CartoDEM.apply.opts(
alpha=0.5,
xaxis=None,
yaxis=None
)
```
## Best Practices
### 1. Coordinate Reference Systems
```python
# Always specify and manage CRS
gdf = gpd.read_file('data.geojson')
print(gdf.crs)
# Reproject if necessary
gdf_projected = gdf.to_crs('EPSG:3857') # Web Mercator
# When creating GeoDataFrame
gdf = gpd.GeoDataFrame(
data,
geometry=gpd.points_from_xy(lon, lat),
crs='EPSG:4326' # WGS84
)
```
### 2. Large Dataset Optimization
```python
# Use rasterization for dense point clouds
from holoviews.operation.datashader import rasterize
points = gv.Points(large_gdf, kdims=['x', 'y'])
rasterized = rasterize(points)
# Use tile-based rendering for massive datasets
# Consider breaking into GeoJSON tiles
```
### 3. Interactive Map Design
```python
# Combine multiple interaction tools
map_viz = gv.Polygons(gdf).opts(
tools=['hover', 'box_select', 'tap'],
hover_fill_color='yellow',
hover_fill_alpha=0.2,
selection_fill_color='red'
)
# Add complementary visualizations
statistics = hv.Text(0, 0, '') # Update based on selection
map_and_stats = hv.Column(map_viz, statistics)
```
### 4. Color and Scale Management
```python
# Use perceptually uniform colormaps
from colorcet import cm
map_viz = gv.Polygons(gdf, vdims=['value']).opts(
color=gv.dim('value').norm(),
cmap=cm['viridis'],
colorbar=True,
clim=(vmin, vmax)
)
```
## Common Patterns
### Pattern 1: Multi-Layer Map Dashboard
```python
def create_map_dashboard(layers_dict):
base_map = gvts.CartoDEM.apply.opts(alpha=0.4)
layers = [gv.Polygons(layers_dict[name]) for name in layers_dict]
return base_map * hv.Overlay(layers)
```
### Pattern 2: Dynamic Filtering Map
```python
from holoviews import DynamicMap, streams
filter_stream = streams.Stream.define('filter', year=2020)
def update_map(year):
filtered_gdf = world[world['year'] == year]
return gv.Polygons(filtered_gdf, vdims=['name', 'value'])
dmap = DynamicMap(update_map, streams=[filter_stream])
```
### Pattern 3: Clustered Points Map
```python
def create_clustered_map(points_gdf, zoom_levels=[1, 5, 10, 20]):
# Use hexbin for aggregation at different scales
aggregated = gv.HexTiles(points_gdf, aggregation='count')
return aggregated.opts(responsive=True)
```
## Integration with Other HoloViz Tools
- **Panel**: Embed maps in web dashboards
- **hvPlot**: Quick geographic plotting with `.hvplot(geo=True)`
- **HoloViews**: Underlying visualization framework
- **Datashader**: Efficient rendering for massive geographic datasets
- **Param**: Parameter-driven map updates
## Common Use Cases
1. **Real Estate Analysis**: Property locations and market data
2. **Climate Analysis**: Temperature, precipitation spatial patterns
3. **Infrastructure Planning**: Network and facility location analysis
4. **Epidemiology**: Disease spread and hotspot visualization
5. **Transportation Analysis**: Route optimization and traffic patterns
6. **Environmental Monitoring**: Land use, vegetation, water quality
## Troubleshooting
### Issue: Map Not Displaying
- Verify CRS is correctly specified
- Check coordinates are in correct order (longitude, latitude)
- Ensure geometry objects are valid with `gdf.is_valid.all()`
### Issue: Performance Problems with Large Datasets
- Use rasterization for dense points
- Simplify geometries with `gdf.geometry.simplify(tolerance)`
- Use tile-based rendering or data pagination
- Consider reducing zoom levels
### Issue: Inaccurate Spatial Analysis
- Verify CRS consistency across all layers
- Use appropriate CRS for distance calculations
- Check topology validity before operations
- Test on sample data first
## Resources
- [GeoViews Documentation](https://geoviews.org)
- [GeoPandas Documentation](https://geopandas.org)
- [GeoJSON Specification](https://geojson.org)
- [EPSG Coordinate Reference Systems](https://epsg.io)
- [Cartopy for Advanced Cartography](https://scitools.org.uk/cartopy)
Versions
The database has no other skills named geospatial-visualization.
Database snapshot: 13.11.2026 · package version dfed063868fd (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100d3js-visualization
Create D3.js charts and interactive data visualizations. Use when building bar charts, line charts, scatter plots, pie charts, force-directed graphs, geographic maps, or any custom data visualization. - 100geopandas
Python library for working with geospatial vector data including shapefiles, GeoJSON, and GeoPackage files. Use when working with geographic data for spatial analysis, geometric operations, coordinate transformations, spatial joins, overlay operations, choropleth mapping, or any… - 95geopandas
Python library for working with geospatial vector data including shapefiles, GeoJSON, and GeoPackage files. Use when working with geographic data for spatial analysis, geometric operations, coordinate transformations, spatial joins, overlay operations, choropleth mapping, or any… - 90local-geospatial-and-cartographic-visualization-ee759543
Design geospatial and cartographic visualizations. Use when the user needs help deciding whether to use a map, choosing projections or basemaps, building choropleths or symbol maps, or implementing thematic maps, slippy maps, or geospatial interactions with D3 geo, Leaflet,… - 100geopandas-geospatial
Geospatial vector analysis extending pandas. Read/write spatial formats (Shapefile, GeoJSON, GeoPackage, Parquet, PostGIS), CRS handling, geometric ops (buffer, simplify, centroid, affine), spatial analysis (joins, overlays, dissolve, clipping, distance), visualization… - 90geospatial
Analyze spatial patterns, compute distances, detect geographic clusters, and assess accessibility. Use when data has coordinates or geographic dimensions.