geodetic 0.6.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e34b06e1bf493a580a70871173cab9e79b442c1667a1d68e9b9b2cd6181b660
-  data.tar.gz: 3d7cdabbff9c142ae61812dfec12d92cf764cc85cf31458c41226d4f00cc19a2
+  metadata.gz: 542167ec9e7b27122d31d5287f967481dc9d0d4b293eaaaa349ca4203e2eb302
+  data.tar.gz: f544332a931f775df18ce4e0d2ed78e4d2619bbb946df6d287c8bc3a798d6c9f
 SHA512:
-  metadata.gz: a8c06b5625fcbb2df864e913ec687f0075c971ff91910a295bfe112ab645bca2174b7d01e32cb9ef03aa9cad05311cfdee7c00572f629d9c4a5b26af70604d3e
-  data.tar.gz: 3a9e274d50a491b2b1b1791402e4e5ff5c52f2be2cf172162fadc8d246ef64cf8bc410bb7eb869b1c3d1748cbaa33eb4d7e7cddaf503f6a191fcac09b9c93024
+  metadata.gz: cca8fc5c8b38722ab95fecfeea576104c180352a9af854171858702d23a240368bef870b831c463601f06f6f04d76671aa8a5254edfc37880b3acef1aced476a
+  data.tar.gz: 29f289c88b14fcbe64091256d61afaa1752a4f405a5a3f88e55b966c7fbc50076c6db6a5e88bbe4f1e4840f3a424c88e37daf167acdca64b1872d81f8a2dcc01

data/CHANGELOG.md

@@ -8,6 +8,65 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 
 
+## [0.8.0] - 2026-03-11
+
+### Added
+
+- **Map adapter pattern** (`Geodetic::Map`) for rendering geodetic objects on maps with pluggable backends
+  - `Geodetic::Map::Base` — abstract adapter interface with `add(object, **style)` auto-dispatch by geometry type
+  - `Geodetic::Map::LibGdGis` — concrete adapter for raster PNG output via the `libgd-gis` gem
+  - `MapMethods` mixin — adds `add_to_map(map, **style)` to all coordinates, paths, segments, areas, and features
+  - Render block pattern: `map.render(path) { |gd_map| ... }` for custom GD drawing after adapter layers
+  - `gd_map` accessor for post-render access to the underlying `GD::GIS::Map`
+  - Accepts `BoundingBox` or `[west, south, east, north]` array for bbox
+  - Supports point, line, and polygon layers with style options (color, stroke, fill, width, label, icon, font, symbol, segments)
+- GEOS map rendering example (`examples/14_geos_map_rendering.rb`) — visualizes 8 GEOS operation categories (boolean intersection/difference, point/path buffering, convex hull, simplification, nearest points, prepared geometry containment) on a single raster map with distinct colors and an embedded legend
+- 28 new map adapter tests covering all geometry types, style handling, ENU/NED rejection, chaining, and LibGdGis bbox resolution
+- Documentation: `docs/reference/map-rendering.md` (architecture, usage, style options, color format, prerequisites)
+
+### Changed
+
+- Refactored `examples/05_map_rendering/demo.rb` to use the new `Map::LibGdGis` adapter instead of raw `GD::GIS::Map` calls
+- Updated `docs/reference/geos-acceleration.md` with reference to example 14
+- Updated `examples/README.md` with example 14 description
+- Updated `CLAUDE.md` with map adapter architecture, file layout, and expanded examples range
+
+## [0.7.0] - 2026-03-10
+
+### Added
+
+- **`Geodetic::Geos` module** — optional GEOS C library integration via `fiddle` for accelerated spatial operations
+  - **Library binding**: auto-discovers `libgeos_c` on macOS and Linux; uses reentrant `_r` API for thread safety
+  - **Predicates**: `Geos.contains?(a, b)`, `Geos.intersects?(a, b)`, `Geos.is_valid?(geom)`, `Geos.is_valid_reason(geom)`
+  - **Boolean operations**: `Geos.intersection(a, b)`, `Geos.difference(a, b)`, `Geos.symmetric_difference(a, b)`, `Geos.union(geom)`
+  - **Geometry construction**: `Geos.buffer(geom, distance)`, `Geos.buffer_with_style(geom, distance, ...)`, `Geos.convex_hull(geom)`, `Geos.simplify(geom, tolerance)`, `Geos.make_valid(geom)`
+  - **Measurements**: `Geos.area(geom)`, `Geos.length(geom)`, `Geos.distance(a, b)`, `Geos.nearest_points(a, b)`
+  - **`PreparedGeometry`**: `Geos.prepare(polygon)` builds a spatial index for O(log n) batch `contains?`/`intersects?` queries
+  - **Graceful degradation**: `Geos.available?` returns false when `libgeos_c` is not installed; all operations fall back to pure Ruby
+  - **`GEODETIC_GEOS_DISABLE` env var**: forces pure Ruby for all operations even when GEOS is installed
+  - **`LIBGEOS_PATH` env var**: specify a custom `libgeos_c` library path
+  - All GEOS operations accept any Geodetic geometry type and return standard Geodetic objects (Polygon, Path, LLA, etc.)
+- **GEOS-accelerated polygon validation** — `Polygon.new` delegates self-intersection validation to GEOS when available, using O(n log n) spatial indexing vs Ruby's O(n^2) pairwise test
+- **GEOS-accelerated point-in-polygon** — `polygon.includes?(point)` uses GEOS for polygons with 15+ vertices (`Polygon::GEOS_INCLUDES_THRESHOLD`); below threshold, Ruby's winding-number algorithm is faster
+- **GEOS-accelerated path intersection** — `path.intersects?(other_path)` uses GEOS when available (wins at all tested sizes vs Ruby's O(n*m) brute-force)
+- **Improved Ruby polygon validation** — added `validate_distinct_vertices!` and `validate_noncollinear!` checks so pure Ruby matches GEOS accuracy for degenerate polygons
+- GEOS benchmark example (`examples/12_geos_benchmark.rb`) — compares Ruby vs GEOS performance across polygon validation, point-in-polygon, path intersection, PreparedGeometry batch containment, single segment (Ruby wins), and GEOS-only operations
+- GEOS operations example (`examples/13_geos_operations.rb`) — 11-section demo covering boolean overlay, buffering, convex hull, simplification, validity checking, geometry repair, planar measurements, nearest points, PreparedGeometry, operation chaining, and GeoJSON/WKT export of results
+- 27 GEOS tests covering all operations, predicates, PreparedGeometry, and error handling
+- 3 new polygon validation tests: collinear boundary, insufficient distinct vertices, all-same-point
+- Documentation: `docs/reference/geos-acceleration.md` (installation, automatic dispatch, performance expectations, API reference)
+
+### Changed
+
+- Updated README with GEOS Acceleration feature, optional dependency section, and examples 12-13 in the examples table
+- Updated `examples/README.md` with example 12 and 13 descriptions
+- Updated `examples/sample_geometries.wkb.hex` to use valid (non-degenerate) triangles in polygon entries
+
+### Fixed
+
+- WKB test data used collinear triangle `(1,2)-(3,4)-(5,6)` which is now correctly rejected; updated to valid triangle `(1,2)-(3,4)-(5,2)`
+- Polygon validation error message regex in tests updated to match both Ruby and GEOS formats
+
 ## [0.6.0] - 2026-03-10
 
 ### Added

data/README.md

@@ -27,6 +27,7 @@
 - <strong>GeoJSON Export</strong> - Build FeatureCollections from any mix of objects and save to file<br>
 - <strong>WKT Serialization</strong> - Well-Known Text export/import with SRID/EWKT and Z-dimension support<br>
 - <strong>WKB Serialization</strong> - Well-Known Binary export/import with EWKB, SRID, hex encoding, and file I/O<br>
+- <strong>GEOS Acceleration</strong> - Optional native acceleration for polygon validation, point-in-polygon, path intersection, and boolean operations<br>
 - <strong>Validated Setters</strong> - Type coercion and range validation on all coordinate attributes<br>
 - <strong>Serialization</strong> - to_s(precision), to_a, from_string, from_array, DMS format<br>
 - <strong>Multiple Datums</strong> - WGS84, Clarke 1866, GRS 1980, Airy 1830, and more<br>
@@ -65,6 +66,26 @@ brew install h3
 
 You can also set the `LIBH3_PATH` environment variable to point to a custom `libh3` location.
 
+### Optional: GEOS Spatial Acceleration
+
+The [GEOS](https://libgeos.org/) library accelerates polygon validation, point-in-polygon tests, path intersection, and adds boolean geometry operations (intersection, difference, convex hull, etc.). Without it, all operations use pure Ruby implementations. Geodetic automatically uses GEOS when available and falls back to Ruby when it is not.
+
+```bash
+# macOS
+brew install geos
+
+# Linux (Debian/Ubuntu)
+sudo apt-get install libgeos-dev
+```
+
+Geodetic uses GEOS selectively — only where it provides a measurable speedup. Single segment intersections stay in Ruby (FFI overhead exceeds the computation cost). For polygons with fewer than 15 vertices, point-in-polygon tests also stay in Ruby.
+
+Set `GEODETIC_GEOS_DISABLE=1` to force pure Ruby for all operations, even when GEOS is installed. See [GEOS Acceleration](docs/reference/geos-acceleration.md) for detailed performance analysis and [example 12](examples/12_geos_benchmark.rb) for a runnable benchmark.
+
+```ruby
+Geodetic::Geos.available?  # => true when libgeos_c is found and not disabled
+```
+
 ## Usage
 
 ### Basic Coordinate Creation
@@ -873,6 +894,8 @@ The [`examples/`](examples/) directory contains runnable demo scripts showing pr
 | [`09_geojson_export.rb`](examples/09_geojson_export.rb) | GeoJSON export: `to_geojson` on all geometry types, `GeoJSON` class for building FeatureCollections with `<<`, delete/clear, Enumerable, and `save` to file |
 | [`10_wkt_serialization.rb`](examples/10_wkt_serialization.rb) | WKT serialization: `to_wkt` on all geometry types, SRID/EWKT, Z-dimension handling, parsing, and roundtrip verification |
 | [`11_wkb_serialization.rb`](examples/11_wkb_serialization.rb) | WKB serialization: `to_wkb`/`to_wkb_hex` on all geometry types, EWKB/SRID, Z-dimension, parsing, roundtrip, and binary/hex file I/O |
+| [`12_geos_benchmark.rb`](examples/12_geos_benchmark.rb) | GEOS performance benchmark: polygon validation, point-in-polygon, path intersection, PreparedGeometry batch containment, and GEOS-only boolean operations |
+| [`13_geos_operations.rb`](examples/13_geos_operations.rb) | GEOS-only operations: boolean overlay (intersection, difference, symmetric difference, union), buffering, convex hull, simplification, validity checking, geometry repair, planar measurements, nearest points, PreparedGeometry, and operation chaining |
 
 Run any example with:
 

data/docs/reference/geos-acceleration.md

@@ -0,0 +1,176 @@
+# GEOS Acceleration
+
+Geodetic optionally integrates with the [GEOS](https://libgeos.org/) (Geometry Engine - Open Source) C library to accelerate spatial operations. When `libgeos_c` is available, Geodetic transparently delegates performance-critical geometry operations to GEOS while keeping pure Ruby as the fallback.
+
+## Installation
+
+```bash
+# macOS
+brew install geos
+
+# Linux (Debian/Ubuntu)
+sudo apt-get install libgeos-dev
+
+# Linux (Fedora/RHEL)
+sudo dnf install geos-devel
+```
+
+Verify installation:
+
+```ruby
+require "geodetic"
+Geodetic::Geos.available?  # => true
+```
+
+## How It Works
+
+Geodetic uses Ruby's `fiddle` stdlib (the same approach used for H3) to call the GEOS C API directly — no compiled extensions or external gems required. The integration uses the reentrant `_r` API for thread safety.
+
+The bridge works through WKT serialization:
+
+1. Geodetic objects are converted to WKT via `to_wkt`
+2. GEOS parses the WKT into its internal geometry representation
+3. GEOS performs the operation using optimized C code with spatial indexing
+4. Results are converted back to WKT and parsed into Geodetic objects
+
+This approach keeps the integration simple and maintainable while providing significant performance gains for complex geometries.
+
+## Automatic Dispatch
+
+Geodetic selectively uses GEOS only where it provides a measurable speedup. The dispatch logic is built into the existing classes:
+
+### Polygon Validation
+
+`Polygon.new(boundary: [...])` automatically validates the boundary for self-intersection. GEOS uses an O(n log n) spatial index compared to Ruby's O(n^2) pairwise segment test.
+
+- GEOS is used at **all polygon sizes** when available
+- Speedup grows with vertex count: ~2x at 50 vertices, ~5x at 100, ~50x+ at 500
+
+### Point-in-Polygon
+
+`polygon.includes?(point)` tests whether a point lies inside a polygon.
+
+- GEOS is used for polygons with **15 or more vertices** (`Polygon::GEOS_INCLUDES_THRESHOLD`)
+- Below 15 vertices, Ruby's winding-number algorithm is faster (FFI overhead dominates)
+- Above the threshold, GEOS provides 2-10x speedup depending on polygon complexity
+
+### Path Intersection
+
+`path.intersects?(other_path)` tests whether two paths cross.
+
+- GEOS is **always used** when available (wins at all tested sizes)
+- Ruby uses O(n*m) brute-force segment pair testing
+- GEOS uses spatial indexing for efficient intersection detection
+- Speedup is most dramatic for non-intersecting paths with overlapping bounds (worst case for Ruby): 10x at 100 points, 100x+ at 1000 points
+
+### Where Ruby Wins
+
+Single segment intersection (`segment.intersects?(other_segment)`) stays in pure Ruby at all times. The FFI marshaling overhead for a single pair of line segments exceeds the computation cost. Geodetic does not use GEOS for this operation.
+
+## PreparedGeometry
+
+For batch operations (testing many points against the same polygon), `PreparedGeometry` builds a spatial index once and reuses it for O(log n) queries:
+
+```ruby
+polygon = Geodetic::Areas::Polygon.new(boundary: vertices)
+prepared = Geodetic::Geos.prepare(polygon)
+
+points.each do |pt|
+  prepared.contains?(pt)  # O(log n) per query
+end
+
+prepared.release  # free the GEOS geometry
+```
+
+This is significantly faster than calling `polygon.includes?` in a loop, which creates a new GEOS geometry for each call.
+
+## GEOS-Only Operations
+
+GEOS provides operations that have no pure Ruby equivalent in Geodetic:
+
+```ruby
+Geos = Geodetic::Geos
+
+# Boolean operations — return Geodetic objects
+Geos.intersection(poly_a, poly_b)        # area of overlap
+Geos.difference(poly_a, poly_b)          # A minus B
+Geos.symmetric_difference(poly_a, poly_b) # area in either but not both
+
+# Geometry analysis
+Geos.convex_hull(polygon)                # smallest convex polygon
+Geos.simplify(polygon, tolerance)        # Douglas-Peucker simplification
+Geos.make_valid(polygon)                 # repair invalid geometry
+Geos.is_valid?(polygon)                  # OGC validity check
+Geos.is_valid_reason(polygon)            # human-readable validity reason
+
+# Measurements
+Geos.area(polygon)                       # area in coordinate units
+Geos.length(path)                        # length in coordinate units
+Geos.distance(geom_a, geom_b)           # minimum distance
+
+# Spatial relationships
+Geos.nearest_points(geom_a, geom_b)     # closest point pair
+Geos.contains?(polygon, point)          # containment test
+Geos.intersects?(geom_a, geom_b)        # intersection test
+
+# Buffering
+Geos.buffer(geometry, width)            # buffer zone
+Geos.buffer_with_style(geometry, width, quad_segs:, cap_style:, join_style:)
+```
+
+## Disabling GEOS
+
+Set the `GEODETIC_GEOS_DISABLE` environment variable to force pure Ruby for all operations:
+
+```bash
+GEODETIC_GEOS_DISABLE=1 ruby -Ilib my_script.rb
+```
+
+```ruby
+ENV['GEODETIC_GEOS_DISABLE'] = '1'
+Geodetic::Geos.available?  # => false (even when libgeos_c is installed)
+```
+
+This is useful for:
+
+- Benchmarking Ruby vs GEOS performance (see example 12)
+- Debugging to isolate whether an issue is in GEOS or Ruby code
+- Running in environments where GEOS cannot be installed
+
+## Performance Expectations
+
+The following table shows representative speedups measured with [example 12](../../examples/12_geos_benchmark.rb). Actual results vary by hardware and polygon complexity.
+
+| Operation | Size | Typical Speedup |
+|-----------|------|-----------------|
+| Polygon validation | 50 vertices | ~2x |
+| Polygon validation | 100 vertices | ~5x |
+| Polygon validation | 500 vertices | ~50x |
+| Point-in-polygon | 30 vertices | ~2x |
+| Point-in-polygon | 100 vertices | ~5x |
+| Point-in-polygon | 500 vertices | ~10x |
+| Path intersection | 100 points | ~10x |
+| Path intersection | 500 points | ~50x |
+| Path intersection | 1000 points | ~100x |
+| Batch containment (prepared) | 1000 points × 100v | ~20x |
+| Single segment | 2 points | Ruby is ~2x faster |
+
+Run the benchmark yourself:
+
+```bash
+ruby -Ilib examples/12_geos_benchmark.rb
+```
+
+For a visual demonstration of GEOS operations rendered on a map:
+
+```bash
+ruby -Ilib examples/14_geos_map_rendering.rb
+```
+
+## Architecture Notes
+
+- **Thread safety**: Uses the reentrant GEOS `_r` API with per-process context initialization
+- **No compiled extensions**: Uses `fiddle` from Ruby's stdlib, same pattern as the H3 integration
+- **Graceful degradation**: All operations work without GEOS; it is purely an optimization
+- **WKT bridge**: Geometries are serialized to WKT for transfer between Ruby and GEOS, leveraging Geodetic's existing WKT infrastructure
+- **Memory management**: GEOS geometries and readers/writers are properly freed via `GEOSGeom_destroy_r`, `GEOSWKTReader_destroy_r`, etc.

data/docs/reference/map-rendering.md

@@ -1,25 +1,106 @@
-# Map Rendering with libgd-gis
+# Map Rendering
 
-Geodetic coordinates and areas can be rendered on raster maps using the [libgd-gis](https://rubygems.org/gems/libgd-gis) gem, which provides tile-based basemap rendering on top of [ruby-libgd](https://rubygems.org/gems/ruby-libgd).
+Geodetic provides a map adapter pattern (`Geodetic::Map`) for rendering coordinates, paths, areas, and features on maps. The adapter abstracts the rendering backend so the same Geodetic objects work with different map engines.
 
-## Overview
+## Architecture
 
-The `libgd-gis` gem downloads map tiles and stitches them into a single raster image for a given bounding box and zoom level. Geodetic's coordinate objects provide the geographic data, and `GD::GIS::Geometry.project` converts longitude/latitude pairs into pixel positions on the rendered map. From there, ruby-libgd primitives (lines, circles, polygons, text, image compositing) can draw overlays on top of the basemap.
+```
+Geodetic::Map::Base          # Abstract adapter interface
+├── Geodetic::Map::LibGdGis  # Raster PNG output via libgd-gis
+├── (future) Leaflet         # Interactive HTML/JS maps
+├── (future) GoogleMaps      # Google Maps HTML or Static API
+└── (future) KML             # KML XML output
+```
 
-This combination supports:
+`MapMethods` is a mixin applied to all coordinates, areas, paths, segments, and features, providing `add_to_map(map, **style)`.
 
-- **Point markers** for any Geodetic coordinate
-- **Polygon overlays** from `Geodetic::Areas::Polygon` boundaries
-- **Bearing arrows** computed with `Feature#bearing_to` and drawn as lines with arrowheads
-- **Distance labels** using `Feature#distance_to` for annotation
-- **Icon compositing** with scaled PNG images positioned at projected coordinates
-- **Light and dark basemaps** via `:carto_light` and `:carto_dark`
+## Usage
 
-## Feature Class
+### Adding objects to a map
+
+Two equivalent APIs — use whichever reads better:
+
+```ruby
+# Map-centric
+map = Geodetic::Map::LibGdGis.new(bbox: bbox, zoom: 12, basemap: :carto_dark)
+map.add(polygon, fill: [0, 200, 120, 170], stroke: [0, 200, 120, 30], width: 2)
+map.add(path, color: [255, 220, 50], width: 3)
+map.add(coordinate, color: [255, 0, 0], label: "Marker")
+
+# Object-centric (via MapMethods mixin)
+polygon.add_to_map(map, fill: [0, 200, 120, 170])
+path.add_to_map(map, color: [255, 220, 50], width: 3)
+coordinate.add_to_map(map, color: [255, 0, 0], label: "Marker")
+```
+
+The `add` method auto-detects the object type and dispatches to the appropriate handler. Supported types:
+
+| Object | Layer type | Notes |
+|--------|-----------|-------|
+| Any coordinate (18 systems) | `:point` | Converts to LLA automatically |
+| `Path` | `:line` | Renders all waypoints as a line |
+| `Segment` | `:line` | Two-point line |
+| `Polygon` (and subclasses) | `:polygon` | Includes Triangle, Rectangle, Hexagon, etc. |
+| `Circle` | `:polygon` | Approximated as N-gon (default 32 segments) |
+| `BoundingBox` | `:polygon` | Four corners as a rectangle |
+| `Feature` | delegates | Extracts geometry; merges label into style |
+| `ENU` / `NED` | rejected | Raises `ArgumentError` (relative systems) |
+
+### Rendering
+
+```ruby
+# Simple render to file
+map.render("output.png")
+
+# Render with custom drawing block (LibGdGis-specific)
+map.render("output.png") do |gd_map|
+  img = gd_map.image
+  # Use GD::Image primitives for custom markers, labels, arrows, etc.
+end
+
+# Render without saving (returns GD::GIS::Map)
+gd_map = map.render
+```
 
-`Geodetic::Feature` wraps a geometry (any coordinate or area) with a label and a metadata hash. It delegates `distance_to` and `bearing_to` to its geometry, using the centroid for area geometries. This makes it straightforward to attach display properties like icon paths and categories alongside the spatial data.
+### Bounding box
 
-## Prerequisites
+The LibGdGis adapter accepts bounding boxes as either:
+
+```ruby
+# Geodetic BoundingBox object
+bbox = Geodetic::Areas::BoundingBox.new(nw: nw_point, se: se_point)
+map = Geodetic::Map::LibGdGis.new(bbox: bbox, zoom: 12)
+
+# Raw [west, south, east, north] array
+map = Geodetic::Map::LibGdGis.new(bbox: [-74.05, 40.65, -73.75, 40.82], zoom: 12)
+```
+
+## LibGdGis Adapter
+
+### Color format
+
+Colors are `[r, g, b]` or `[r, g, b, alpha]` arrays. The alpha channel follows libgd convention:
+
+- `0` = fully opaque
+- `255` = fully transparent
+
+### Style options
+
+| Option | Point | Line | Polygon |
+|--------|:-----:|:----:|:-------:|
+| `color` | marker color | stroke color | — |
+| `stroke` | — | stroke color | outline color |
+| `fill` | — | — | fill color |
+| `width` | — | line width (px) | outline width (px) |
+| `label` | text label | — | — |
+| `icon` | image path | — | — |
+| `font` | font path | — | — |
+| `size` | font size | — | — |
+| `font_color` | label color | — | — |
+| `symbol` | marker style | — | — |
+| `segments` | — | — | circle approximation (default 32) |
+
+### Prerequisites
 
 ```bash
 gem install libgd-gis
@@ -27,6 +108,11 @@ brew install gd   # macOS
 # apt install libgd-dev   # Linux
 ```
 
-## Example
+## Feature Class
+
+`Geodetic::Feature` wraps a geometry (any coordinate or area) with a label and a metadata hash. It delegates `distance_to` and `bearing_to` to its geometry, using the centroid for area geometries. When added to a map, the label is automatically included in the style.
+
+## Examples
 
-See [`examples/05_map_rendering/demo.rb`](https://github.com/madbomber/geodetic/tree/main/examples/05_map_rendering) for a complete working demo that renders NYC landmarks with icons, a Central Park polygon boundary, and bearing arrows between landmarks. The demo supports light/dark themes, icon scaling, and CLI flags for toggling features.
+- [`examples/05_map_rendering/demo.rb`](https://github.com/madbomber/geodetic/tree/main/examples/05_map_rendering) — NYC landmarks with icons, Central Park polygon, bearing arrows, light/dark themes
+- [`examples/14_geos_map_rendering.rb`](https://github.com/madbomber/geodetic/tree/main/examples/14_geos_map_rendering.rb) — GEOS operations (intersection, difference, buffer, convex hull, simplification, nearest points, prepared geometry) all visualized on a single map with distinct colors