Processing Tools
Model Builder
Processing → Model Builder opens a visual graph workspace. The dense command bar provides an editable model name, New, Save, Arrange, Import, Export, Copy Python script, Run/Cancel, maximize/restore, and close. The left palette is searchable and groups executable tools by provider; + Input and + Output add the explicit boundary nodes used by the graph. The canvas shows labelled ports and connections, while the inspector on the right edits a selected node’s typed parameters and source/result names. Messages appear in the bottom pane. Keyboard activation is available for node selection and port-to-port connections, and dragging a palette item adds it to the canvas.
Saved models keep the graph plus a compatibility steps projection in the project document. Arrange lays out the graph by dependency depth; Import validates a bounded Meratyn graph interchange file before it enters the project; Export writes the same schema. Run validates ports, cycles, required inputs, and provider availability before execution, and Cancel interrupts an in-flight run. Batch Tools is a separate Processing root action for applying one vector tool to several layers; it does not change the Model Builder chrome. Whitebox/WASM tools appear only after the existing executable catalog is available; a catalog or runtime failure is reported in Messages rather than presenting tools that cannot run.
Use Copy Python script to open a review of the same graph as calls to Meratyn’s documented m.run_algorithm(...) and m.run_whitebox_tool(...) APIs. Copying to the clipboard happens only after you approve that review; this flow does not change the Python API. The generated script passes each connected output layer ID into the next node, so it can run in a Meratyn Python map with the model’s original input layers loaded. For malformed graphs, cycles, unknown tools, unsupported parameters, and connections that do not target a layer parameter, Meratyn reports the reason instead of producing a script that cannot run.
An AI-created workflow is still a draft: inspect the selected tools, input layers, parameters, and connections before choosing Run.
The Processing menu collects Meratyn’s analysis and conversion tools: vector geometry and overlay tools, raster terrain and clipping tools, AI segmentation, format conversion, and the Whitebox toolbox. The SQL Workspace, Python Console, AI Assistant, and AI Segmentation also live here and have their own pages.
Page order This page groups the tools by theme. In the menu itself the items appear in a different order: AI Assistant, Whitebox Toolbox, Conversion, Vector, Raster, Hydrology, LiDAR, Network, Projection, Remote Sensing, Terrain, Spatial Statistics, DGGS, Geocode Addresses, Batch Tools, AI Segmentation, Object Detection, Segment Everything, Model Builder, SQL Workspace, Python Console, Jupyter Notebook, Dashboard, History, Planetary Computer, Earth Engine.
Vector
Processing → Vector opens the Vector tools dialog. Pick a tool from the list, choose the input layer and parameters, select an engine, then Run. Output appears as a new layer.
Geometry
| Tool | Description |
|---|---|
| Buffer | Create a buffer polygon around each feature by a fixed distance. |
| Centroids | Compute the centroid point of each feature. |
| Convex hull | Compute the convex hull enclosing all features. |
| Dissolve | Merge polygon features into a single geometry, optionally grouped by a field. |
| Bounding box | Compute the rectangular envelope of all features. |
| Simplify | Reduce the number of vertices using Douglas-Peucker. |
| Extract vertices | Emit one point feature for every vertex in the input geometries. |
| Points along geometry | Interpolate points at a chosen interval along line geometries. |
Bounding box, centroids, and buffer stop with a message when the layer has no geometry, and Simplify rejects a negative tolerance. Voronoi diagrams need WGS84 points spanning at most 180 degrees of longitude.
DGGS
Processing → DGGS contains DGGS generator, DGGS binning, and DGGS compact / expand. The generator fills a layer geometry, layer extent, map viewport, or manual bounding box at a selected or automatic resolution. It supports H3, S2, A5, DGGRID, and DGGAL. DGGAL exposes its grid system, while DGGRID exposes cell type, projection, and aperture. H3 uses DuckDB-WASM, S2 and A5 run in the browser, and DGGRID and DGGAL use bundled WebAssembly engines.
DGGS binning aggregates points with count, sum, mean, minimum, or maximum. Compact / expand operates on hierarchical H3, S2, A5, and DGGAL cells.
A layer extent that crosses the antimeridian, such as islands on both sides of 180 degrees, is covered as one narrow band across it rather than the whole globe.
| Tool | Description |
|---|---|
| DGGS generator | Generate H3, S2, A5, DGGRID, or DGGAL cells from a layer geometry, layer extent, map viewport, or manual bounding box. |
| DGGS binning | Aggregate point features into H3, S2, A5, DGGRID, or DGGAL cells. |
| DGGS compact / expand | Compact sibling cells or expand H3, S2, A5, or DGGAL cells to a target resolution. |
Data admin
| Tool | Description |
|---|---|
| Merge layers | Combine compatible GeoJSON layers into one output layer while preserving source attributes. |
Encoded polylines
| Tool | Description |
|---|---|
| Decode polyline | Decode pasted Google/OSRM or Valhalla strings at precision 5 or 6. Newline, tab, and custom delimiters are supported; malformed or truncated values are skipped. |
| Encode polyline | Encode line and multi-line layer geometry into precision-5 or precision-6 strings shown in the run log. |
Overlay
| Tool | Description |
|---|---|
| Clip | Clip the input layer to the area covered by an overlay layer (keeps input attributes). |
| Intersection | Keep only the areas where both polygon layers overlap (merges attributes from both). |
| Difference | Remove the overlay layer’s area from the input layer (keeps input attributes). |
| Union | Merge two polygon layers into a single combined geometry (attributes are not preserved on either engine). |
Join
| Tool | Description |
|---|---|
| Spatial join | Attach attributes from a join layer to each input feature based on a spatial relationship (intersects, within, or contains). Choose an inner join to keep only matched features or a left join to keep all input features. Works with any geometry type. |
| Attribute join | Attach attributes from a join layer (a table) onto each input feature where a key field matches — no geometry involved (e.g. join census stats to boundary polygons by FIPS code). One-to-one: the first matching join row wins. Choose which fields to bring over, and an inner join (keep only matched) or left join (keep all input). |
Select
| Tool | Description |
|---|---|
| Select by value | Extract features whose attribute matches a condition into a new layer. Pick a field, an operator (=, ≠, >, ≥, <, ≤, contains, starts with, is empty, is not empty) and a value. Comparisons are numeric when both sides are numbers, otherwise text. |
| Select by location | Extract features by their spatial relationship to a second layer (intersects, within, contains, or disjoint) into a new layer. Works with any geometry type. |
Engines
Every vector tool can run on one of three engines, selectable in the dialog:
- Client (Turf.js): runs entirely in the browser. No setup, works offline, and operates on the layer’s GeoJSON.
- Sidecar (GeoPandas): runs on the optional Python sidecar for projection-aware results, backed by GeoPandas and Shapely. The dialog falls back to the client engine when the sidecar’s optional
vectorextra is not installed. - Python (Pyodide): runs the same GeoPandas/Shapely code as the sidecar, but entirely in your browser via Pyodide — no server needed. The first run downloads the Python runtime once (a few tens of MB), so an internet connection is needed the first time; later runs reuse the warmed-up runtime. Because it shares the sidecar’s Python, results match the Sidecar engine.
See the Vector Analysis tutorial.
Spatial Statistics
Processing → Spatial Statistics runs client-side in Meratyn’s statistics worker. Alongside Moran’s I, Getis-Ord Gi*, nearest-neighbor, kernel-density, and emerging-hot-spot tools, Composite score (suitability index) builds one index from two or more numeric fields.
For each field, choose min-max, z-score, rank, or quantile normalization; a relative weight; and whether higher or lower values are better. Weighted arithmetic mean allows strong fields to compensate for weak ones, while weighted geometric mean keeps a weak component influential. Weights are displayed as percentages of the total.
Missing values require an explicit choice: drop the feature, or renormalize its weights over the values it has. The output range is 0–100 by default or 0–1 for downstream calculations. Keep normalized components adds each component beside the final score for auditability. The result opens as a new layer already styled with graduated colors on the score field.
Raster
Processing → Raster opens the Raster tools dialog. Supported operations run in the browser; the optional rasterio Python sidecar adds native file paths and operations outside the browser engine. Results are added to the map.
Terrain
| Tool | Description |
|---|---|
| Hillshade | Compute a shaded-relief raster from an elevation model. |
| Slope | Compute slope (steepness) from an elevation model. |
| Aspect | Compute aspect (compass direction of the steepest slope) from an elevation model. |
For an elevation model in geographic coordinates, these tools convert the cell size from degrees (or arc-minutes, arc-seconds, or radians) to metres and correct the east-west spacing for latitude. Projected models use their cell size as it is.
Reproject
| Tool | Description |
|---|---|
| Reproject | Warp a raster to a different coordinate reference system. |
| Resample | Resample a raster to a different pixel size (resolution). |
Clip
| Tool | Description |
|---|---|
| Clip by extent | Crop a raster to a bounding box (in the raster’s CRS). |
| Clip by mask layer | Clip a raster to the geometries of a vector mask file. |
Raster to Vector
| Tool | Description |
|---|---|
| Polygonize | Convert a raster band into vector polygons grouped by pixel value. |
| Contour | Generate contour lines from an elevation model. |
Vector to Raster
| Tool | Description |
|---|---|
| Interpolation (IDW / Kriging) | Interpolate a point layer’s numeric attribute into a continuous raster surface using inverse distance weighting or ordinary kriging. The output grid spans the points’ extent at the chosen pixel size, in the layer’s CRS. |
See the Terrain Analysis tutorial.
Conversion
Processing → Conversion writes data to cloud-native formats:
| Tool | Engine | Description |
|---|---|---|
| Vector to Vector | Browser + Sidecar | Convert between any formats DuckDB’s spatial extension supports; input and output formats are detected from the file extensions. The desktop app (sidecar) writes any GDAL format (FlatGeobuf, GeoPackage, Shapefile, KML, GML, SQLite, …); the browser writes GeoJSON, CSV, GeoParquet, GeoPackage, and Shapefile. |
| Vector to GeoParquet | Browser (DuckDB-WASM) | Hilbert-sorted, compressed GeoParquet. |
| Vector to FlatGeobuf | Sidecar | Hilbert-sorted, cloud-optimized, spatially indexed vector. |
| Vector to Shapefile | Sidecar | Hilbert-sorted, zipped ESRI Shapefile (field names truncated to 10 characters). |
| Vector to GeoPackage | Sidecar | Hilbert-sorted GeoPackage for sharing with QGIS/ArcGIS. |
| CSV to GeoParquet | Browser (DuckDB-WASM) | Convert a CSV with coordinates to GeoParquet. |
| Vector to PMTiles | Sidecar | Build a vector tile archive. |
| Raster to COG | Sidecar | Write a Cloud-Optimized GeoTIFF. |
Browser conversions preserve the message returned by the WebAssembly engine, including size-limit refusals that previously appeared only as a generic conversion failure. Raster to COG also reports the inspected raster shape; when the 32-bit browser decoder rejects a raster as too large, the job includes a hint to use the desktop app or sidecar.
The conversion sidecar is hardened with a path allowlist.
Whitebox
Processing → Whitebox Toolbox opens the Whitebox toolbox for geoprocessing. Browser builds run supported tools locally with WebAssembly; the desktop app can also use its managed Python sidecar for native file paths and sidecar-only tools.
Tools that accept a dataset list expose an ordered multi-input picker: select several loaded layers, add paths, or browse multiple files. The same order is preserved in browser WASM runs, desktop sidecar runs, and Python scripting; filenames containing commas remain a single input.
AI Segmentation
The Processing → AI Segmentation entry is backed by the typed SamGeo/SAM 3
sidecar integration. It accepts a text prompt or automatic segmentation, then
reprojects the returned GeoJSON before publishing a new layer. The
samgeo-api sidecar is required. For foreground/background points, map-drawn boxes, and model/backend
controls, use the separate Plugins → SamGeo panel described on the
dedicated AI Segmentation page.
Planetary Computer and Earth Engine
The Processing menu also opens the Planetary Computer and Earth Engine panels for browsing and loading cloud datasets. See Data Integrations.
The Python sidecar
The optional Python sidecar handles raster workflows that need native file paths or operations outside the browser engine, sidecar conversion tools, Whitebox tools outside the WebAssembly catalog, and the optional GeoPandas vector engine. Browser engines cover supported raster and Whitebox operations without a server.
Browser vs desktop Client-side vector tools, browser conversions (Vector to Vector, Vector to GeoParquet, CSV to GeoParquet), and supported raster and Whitebox tools run in the browser. Vector to Vector’s full any-format output, other sidecar conversions, raster paths or operations outside browser support, and Whitebox tools outside the WebAssembly catalog require the desktop app and Python sidecar. on sidecar.