RasterFlow Models - Wherobots

Public Preview

RasterFlow built-in models

RasterFlow includes curated, open-source models for common geospatial use cases.

Model	What it does	Input imagery
SAM3	Detects objects from a text prompt and returns georeferenced bounding boxes or polygons with confidence scores	High-resolution aerial imagery, such as 30 cm NAIP
Tile2Net	Detects sidewalks, crosswalks, and pedestrian pathways	30 cm NAIP
Meta CHM v1	Estimates tree canopy height in meters	60 cm NAIP
Meta CHM v2	Estimates tree canopy height in meters, with the DINOv3-based successor to Meta CHM v1	60 cm NAIP
Fields of the World (FTW)	Detects agricultural fields and field boundaries	Sentinel-2 planting- and harvest-season composites
PRUE	Detects agricultural fields and field boundaries, as the successor to Fields of the World from the same team	Sentinel-2 planting- and harvest-season composites
ChesapeakeRSC	Detects roads, including roads obscured by tree cover	1 m NAIP

For each model’s Inference Complexity Factor, see RasterFlow Billing.

Example applications

Agricultural Field Mapping

Detect field boundaries from Sentinel-2 imagery
Segment crop fields across counties/regions
Convert raster predictions to vector geometries

Example application: Map all agricultural fields in Haskell County, Kansas using Sentinel-2 imagery and the Fields of the World modelTo run this model, see the code examples in its Models page listing.PRUE (recipe prue) is the successor to Fields of the World, from the same team. It takes the same inputs, Sentinel-2 planting- and harvest-season composites at 10 m, and returns the same non_field_background, field and field_boundaries bands. Its composite loss functions and targeted data augmentations improve accuracy on the Fields of the World benchmark, and make predictions more consistent across changes in illumination, spatial scale and geographic location. Use full calendar-year dates, such as January 1, 2024 through January 1, 2025, for the 2024 composites.

When to choose it: when you want the newer model, or want to compare it with Fields of the World on your area of interest. To continue an existing Fields of the World analysis, use Fields of the World.
License: CC-BY-4.0
Citation: Muhawenayo et al., PRUE: A Practical Recipe for Field Boundary Segmentation at Scale, CVPR 2026 (arXiv:2603.27101)

Example application: Map agricultural fields on the Shōnai plain in Yamagata, Japan using 2024 Sentinel-2 imagery with the PRUE modelTo run this model, see the code examples in its Models page listing.

Urban Infrastructure Detection

Identify sidewalks, crosswalks, and pedestrian pathways
Generate detailed maps for urban planning
Analyze accessibility from high-resolution aerial imagery

Example application: Detect and map sidewalk networks in College Park, Maryland using 30cm NAIP imagery with the Tile2Net modelTo run this model, see the code examples in its Models page listing.

Canopy Height Estimation

Predict tree canopy heights from aerial imagery
Monitor forest health and vegetation structure
Support conservation and urban forestry initiatives

Example application: Estimate tree heights across Nashua, NH using 60cm NAIP imagery with the Meta CHM v1 modelTo run this model, see the code examples in its Models page listing.Meta CHM v2 (recipe meta-chm-v2) is Meta’s DINOv3-based canopy height model. Like v1, it takes 60 cm NAIP RGB imagery and returns canopy height in meters. Compared with v1, it reduces the underestimation of tall forests and better preserves canopy edges and gaps.

When to choose it: when you need the newer model, or want to compare it with v1 on your area of interest. To continue an existing v1 analysis, use v1. The two models share an input resolution, but their predictions aren’t interchangeable.
License: check the DINOv3 License for your use case.

Example application: Estimate tree heights in Capitol State Forest, Washington using 60cm NAIP imagery with the Meta CHM v2 modelTo run this model, see the code examples in its Models page listing.

Rural Road Detection

Identify roads, especially in rural environments
Map road networks to support routing and navigation
Detect road network changes to keep maps up to date

Example application: Detect roads in Maryland using 1m NAIP imagery with the ChesapeakeRSC modelTo run this model, see the code examples in its Models page listing.

Text-Prompted Object Detection

Detect objects from a natural language prompt
Return georeferenced bounding boxes or polygons with confidence scores
Skip vectorization, since output is already vector

Example application: Detect roofs in College Park, Maryland from 30cm NAIP imagery using the SAM3 modelTo run this model, see the code examples in its Models page listing.

Bring your own model

The built-in models are a starting point, not a limit. Export a custom PyTorch model to a RasterFlow-compatible format, register it, and run it at scale over a mosaic alongside the built-in models. See the Bringing Your Own PyTorch Model to RasterFlow notebook for the complete workflow, from model export to scalable raster inference.

Running model inference

There are two options for running model inference in RasterFlow:

Run an end-to-end task that ingests the required imagery, generates a mosaic and runs the model using a pre-configured recipe: predict_mosaic_recipe, or predict_mosaic_geometries_recipe for SAM3’s text-prompted geometries.
Run a model, including your own, on an existing mosaic with run_mosaic_inference, or on Cloud Optimized GeoTIFFs with run_cog_inference.

This example maps agricultural fields in Haskell County, Kansas, with the Fields of the World model. model_recipe picks the built-in model: ftw, tile2net, meta-chm-v1, meta-chm-v2, chesapeakersc or prue.

The examples on this page run RasterFlow through the Tasks API, in two tabs. Python uses the Wherobots Python SDK, and API calls the REST API with curl. Outside a Wherobots notebook or job, both need a Wherobots API key in WHEROBOTS_API_KEY. Each example starts a task run; to wait for it and read its results, see Get started and Run RasterFlow Tasks.

# pip install wherobots-python-sdk
import wherobots

wb = wherobots.Wherobots()  # outside Wherobots, reads WHEROBOTS_API_KEY

run = wb.tasks.run("predict_mosaic_recipe", {
    "aoi": "s3://wherobots-examples/rasterflow/aois/haskell.parquet",
    "start": "2023-01-01T00:00:00Z",
    "end": "2024-01-01T00:00:00Z",  # FTW needs full calendar years
    "model_recipe": "ftw",
}, region="aws-us-west-2")
# When the run succeeds, results["mosaic_index_uri"] lists the prediction stores.

curl -X POST "https://api.cloud.wherobots.com/tasks/predict_mosaic_recipe/runs" \
  -H "X-API-Key: $WHEROBOTS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "region": "aws-us-west-2",
    "name": "Haskell County fields",
    "inputs": {
      "aoi": "s3://wherobots-examples/rasterflow/aois/haskell.parquet",
      "start": "2023-01-01T00:00:00Z",
      "end": "2024-01-01T00:00:00Z",
      "model_recipe": "ftw"
    }
  }'

# When the run succeeds, results.mosaic_index_uri lists the prediction stores.

Inspecting model outputs on a map

Inference writes its predictions as a Zarr store at a single native resolution, so a map client has to stream full-resolution pixels at every zoom level. Build overview levels on the prediction store first, then view the visualization-ready store:

wb.tasks.run("predict_mosaic_recipe", {...}, region="aws-us-west-2")

# When the predictions run succeeds, build multiscales on a store from its mosaic index
wb.tasks.run("build_zarr_multiscales", {
    "source_store": "s3://<bucket>/<path>/prediction.zarr",
}, region="aws-us-west-2")
# Paste that run's results["output_uri"] into Layer URL in the Wherobots Cloud map viewer

curl -X POST "https://api.cloud.wherobots.com/tasks/predict_mosaic_recipe/runs" \
  -H "X-API-Key: $WHEROBOTS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"region": "aws-us-west-2", "name": "Predictions", "inputs": {...}}'

# When the run succeeds, pass a Zarr URI from the index's location column
curl -X POST "https://api.cloud.wherobots.com/tasks/build_zarr_multiscales/runs" \
  -H "X-API-Key: $WHEROBOTS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"region": "aws-us-west-2", "name": "Prediction multiscales", "inputs": {"source_store": "s3://<bucket>/<path>/prediction.zarr"}}'

The visualization-ready store renders responsively in Wherobots-GL, both in the Wherobots Cloud map viewer and in the inline wherobots_gl.Map() widget. Prior to vectorizing, view the raw prediction scores on the map to pick a threshold. See Build Multiscales for the full build_zarr_multiscales workflow and Visualize RasterFlow Outputs for the viewing options.

Vectorization of model outputs

Convert raster predictions to vector geometries for further spatial analysis with the vectorize_mosaic task. This example vectorizes the road band of a public ChesapeakeRSC prediction store:

wb.tasks.run("vectorize_mosaic", {
    "mosaic_uri": "s3://wherobots-examples/rasterflow/model-outputs/chesapeakersc.zarr",
    "features": ["road"],
    "threshold": 0.5,
    "stats": True,
}, region="aws-us-west-2")
# When the run succeeds, results["vector_results_uri"] is the road polygons, or None when nothing passed the threshold

curl -X POST "https://api.cloud.wherobots.com/tasks/vectorize_mosaic/runs" \
  -H "X-API-Key: $WHEROBOTS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "region": "aws-us-west-2",
    "name": "ChesapeakeRSC roads",
    "inputs": {
      "mosaic_uri": "s3://wherobots-examples/rasterflow/model-outputs/chesapeakersc.zarr",
      "features": ["road"],
      "threshold": 0.5,
      "stats": true
    }
  }'

features must match band names in the prediction store, and threshold is compared directly with each pixel value. mosaic_uri also accepts a mosaic index, in which case every store it lists is vectorized. Vectorization enables you to:

Join with other vector datasets (e.g., cadastral data, yield records)
Calculate area statistics for each field
Perform spatial queries in WherobotsDB
Export to standard GIS formats for visualization

Use Get a task with vectorize_mosaic for every input and the output columns.

API reference

For detailed API documentation, see:

Run a task - POST /tasks/{taskName}/runs
Get a task run - state, results, and errors
Wherobots Python SDK - wb.tasks and wb.task_runs