geometry

func Area ¶

func Area(g Geometry, u Unit) (float64, error)

Area returns the planar (XY) area of g in u². Non-polygonal geometries return 0.

func BoundsCompatible ¶ added in v0.4.1

func BoundsCompatible(pred Predicate, ab, bb Bounds) bool

BoundsCompatible reports whether the two bounds are compatible under pred's necessary-condition. Wrong answers here would falsely reject valid predicate matches, so err on the side of "compatible" for any predicate we don't specifically handle.

Used by TestPrepared internally and by the per-row bbox-reject fast paths in Series predicate ops (which read row bboxes via BoundsFromWKB and can short-circuit false without a full ParseWKB when this returns false).

PredIntersects / PredTouches / PredCrosses / PredOverlaps: bboxes must overlap. PredContains: a's bbox must cover b's bbox. PredWithin: b's bbox must cover a's bbox.

func BoundsMinDistance ¶ added in v0.4.1

func BoundsMinDistance(a, b Bounds) float64

BoundsMinDistance returns the minimum Euclidean distance between two axis-aligned bounding rectangles. Zero when they overlap or touch. Empty bounds → +Inf.

Used by WithinDistance's short-circuit; also exposed publicly so per-row `Series.GeomDWithin` callers can reject far rows via `BoundsFromWKB` + this helper without a full ParseWKB.

func CentroidAndBoundsFromWKB ¶ added in v0.4.1

func CentroidAndBoundsFromWKB(data []byte) (Point, Bounds, error)

CentroidAndBoundsFromWKB is the fused-scan variant: computes the centroid AND the 2D bounding box in a single byte-stream pass. The centroid semantics match CentroidFromWKB; the bounds semantics match BoundsFromWKB. Callers who need both (e.g. the fused HilbertSortWithCovering write path) save a full second byte-scan.

func Contains ¶

func Contains(a, b Geometry) bool

Contains reports whether a fully contains b.

func ConvexHullFromXY ¶ added in v0.4.1

func ConvexHullFromXY(xs, ys []float64) (hullXs, hullYs []float64)

ConvexHullFromXY runs Andrew's monotone-chain algorithm on parallel Xs / Ys slabs and returns the convex hull as a fresh pair of slabs in counter-clockwise order, with the closing vertex (a repeat of the first) appended so the output is a closed ring.

Design vs the AoS Graham scan ¶

The AoS Polygon.ConvexHull in polygon.go runs Graham scan: find a pivot, sort every other vertex by polar angle from the pivot via `sort.Slice` on []Point (which boxes the closure function-value and moves 40-byte Point structs during partition), then stack-scan retaining CCW turns. Two nested allocations (the closure box + the sorted []Point copy) plus point-struct swaps in-place.

Andrew's monotone chain replaces the polar-angle sort with an index sort by (x, y) lex — the resulting order is the same linear structure for the two half-hulls. Two O(n) stack scans over an index permutation (lower hull, then upper hull) produce the CCW output. Sort is on `[]int` indices via `slices.SortFunc` (8-byte swaps + typed callback — no closure boxing that `sort.Slice` would incur); the hull-scan reads coordinates directly from the input slabs so the inner-loop arithmetic operates on cache-friendly float64 arrays.

Semantics ¶

• Fewer than 3 unique points return a copy of the input slabs (no closing vertex appended — matches the AoS shape which also returns the input unchanged when Exterior() has <3 points).
• Duplicate points are tolerated. Since the (x,y) lex order is a total order over distinct points, sort stability is irrelevant — equal keys mean the same point, and the CCW scan drops the extra via strict `<= 0` cross-product rejection just like collinear points on the hull edge (matches the AoS behavior).
• Output vertex count includes the closing repeat, so a hull with k unique vertices has k+1 entries.

func Crosses ¶ added in v0.3.0

func Crosses(a, b Geometry) bool

Crosses reports whether a and b have some interior points in common but not all — typically LineString vs Polygon or LineString vs LineString. Matches shapely's a.crosses(b).

func CrossesAntimeridian ¶ added in v0.3.0

func CrossesAntimeridian(g Geometry) bool

CrossesAntimeridian reports whether any adjacent vertex pair in g has |Δlon| > 180°, which under WGS84 interpretation means the edge between them wraps around the ±180° meridian. Returns false for projected-CRS inputs (the concept doesn't apply) and for empty geometries. Assumes X = longitude, Y = latitude in degrees, matching WKB convention.

func Euclidean ¶

func Euclidean(from, to Point, u Unit) (float64, error)

Euclidean returns the planar distance between two Points, in the requested unit. The input coordinates are assumed to already be in meters (projected CRS); Z / CRS are ignored.

Breaking change in v0.2.16: previously took four float64 args (x1, y1, x2, y2). The new signature aligns with Haversine + HaversineBatch + Point.Distance. Migration: replace `Euclidean(a.X, a.Y, b.X, b.Y, u)` with `Euclidean(a, b, u)`.

func GeomDistance ¶ added in v0.3.0

func GeomDistance(a, b Geometry, u Unit) (float64, error)

GeomDistance returns the minimum planar (Euclidean) distance between any two points in a and b. Returns 0 when they intersect. Uses point-to-segment distance across all vertex-vs-edge pairs from both sides — O(V_a·E_b + V_b·E_a) in the general case.

Coordinates are treated as planar meters; for geographic (WGS84 lon/lat) inputs the result is Euclidean on degrees, which is meaningless. Project to a suitable CRS first (see Point.Distance / Haversine for lon/lat point pairs).

func Haversine ¶

func Haversine(from, to Point, u Unit) (float64, error)

Haversine returns the great-circle distance between two lon/lat Points on a sphere of Earth radius, in the requested unit. Point X = longitude, Y = latitude (WKB convention); Z / CRS are ignored.

Breaking change in v0.2.16: previously took four float64 args (lon1, lat1, lon2, lat2). The new signature aligns with HaversineBatch and Point.Distance so callers holding geometry types can pass them directly. Migration: replace `Haversine(a.X, a.Y, b.X, b.Y, u)` with `Haversine(a, b, u)`.

func HaversineBatch ¶ added in v0.2.16

func HaversineBatch(from, to []Point, u Unit) ([]float64, error)

HaversineBatch returns per-pair great-circle distances between from[i] and to[i] in the requested unit. Semantically equivalent to calling Haversine(from[i], to[i], u) in a loop, but bulk-optimized:

• The unit conversion factor, Earth-radius constant, and degree-to-radian scale are hoisted outside the inner loop (one metersPerUnit call for the whole batch).
• Per-row math runs in a fixed-count vars body — Go's inliner keeps it tight vs. the per-call scalar Haversine which pays a function-call boundary + defer + err-check per row.

Both input slices must be the same length; a mismatch returns ErrColumnLenMismatch. Empty slices are legal and return an empty (non-nil) result.

CRS on each Point is ignored — Haversine is a lon/lat sphere computation that expects Y=latitude, X=longitude in degrees. Points in a projected CRS give nonsensical distances; converting via ToCRS(WGS84) before calling is the caller's responsibility.

Return type is a flat []float64 — same shape a downstream SIMD kernel or arrow builder wants. Nulls in the input aren't signaled (Point isn't a nullable type); to skip-and-preserve row positions, either pre-filter or pass sentinel points and mask the output.

func HilbertIndex ¶ added in v0.3.5

func HilbertIndex(x, y float64, bounds Bounds, order int) uint64

HilbertIndex returns the 1D position of (x, y) along a space-filling Hilbert curve of the given order, computed after normalizing (x, y) into a `2^order × 2^order` integer grid derived from bounds.

The Hilbert curve preserves 2D locality: points close in (x, y) tend to be close in HilbertIndex. Sorting rows by their centroid's HilbertIndex before writing a GeoParquet file makes per-row-group bboxes small, which is what the v0.3.4 row-group pushdown machinery actually needs to prune usefully on real data.

Contract:

• bounds must be a valid non-empty rectangle. Empty bounds return 0 (all points "index to origin"), which sorts to random-adjacent order — a no-op rather than a crash.
• order in [1, 31]. Values outside clamp to DefaultHilbertOrder. Order 16 (default) is enough for continental datasets; order 24+ approaches meter-scale on a WGS84 world extent.
• Points outside bounds are clamped to the boundary before quantization — an off-by-a-hair polygon still gets a stable index.

The 2D Hilbert construction is the standard iterative quadrant-rotation algorithm (see e.g. Wikipedia's "Hilbert curve" article, xy2d). No lookup tables — hot loop is O(order) integer ops, ~30 ns/call at order=16.

func Intersects ¶

func Intersects(a, b Geometry) bool

Intersects reports whether a and b share any point. The relation is symmetric.

func IsEmpty ¶ added in v0.3.0

func IsEmpty(g Geometry) bool

IsEmpty reports whether g has no coordinates. Matches shapely's .is_empty semantics: a Point with the default (0,0) is NOT empty (shapely's convention), but a Polygon with no rings, a LineString with fewer than 2 points, or a MultiPolygon with no components IS.

func IsValid ¶ added in v0.3.0

func IsValid(g Geometry) bool

IsValid reports whether g satisfies the OGC Simple Features validity rules gobi checks:

• LineString: >= 2 points, no consecutive duplicate vertices.
• Polygon: every ring closed (or auto-closable), >= 3 unique vertices per ring, no ring self-intersection.
• Multi types: all components valid.
• Point / MultiPoint: always valid.

This is deliberately a subset of GEOS's IsValid — full OGC validity includes checks like "holes lie inside exterior" and "rings don't touch except at points" which require more machinery than gobi currently exposes. Returns false for structurally-broken input; callers can rely on IsValid == true meaning "safe to pass to Boolean / Buffer without triggering degenerate-input paths."

func Length ¶

func Length(g Geometry, u Unit) (float64, error)

Length returns the planar (XY) length of g in u. Non-linear geometries (Point, MultiPoint, Polygon) return 0. Polygons don't return perimeter here — use Polygon.Perimeter for that.

func MetersPerUnit ¶ added in v0.2.16

func MetersPerUnit(u Unit) (float64, error)

MetersPerUnit returns the number of meters in one of the given unit. Exported so callers building their own bulk distance kernels can hoist the scale factor outside a hot loop instead of paying a per-call `metersPerUnit` lookup.

func MultiPolygonRingViewsFromWKB ¶ added in v0.4.1

func MultiPolygonRingViewsFromWKB(data []byte) ([][]PointsView, error)

MultiPolygonRingViewsFromWKB parses a MultiPolygon or MultiPolygonZ WKB directly into a [][]PointsView with one []PointsView per sub-polygon. Same layout as MultiPolygon.PolygonRingViews() but no []Point intermediate.

func Overlaps ¶ added in v0.3.0

func Overlaps(a, b Geometry) bool

Overlaps reports whether a and b share interior points but neither contains the other, and both are of the same dimension (both areas or both lines). Matches shapely's a.overlaps(b).

func PIPFromWKB ¶ added in v0.4.1

func PIPFromWKB(data []byte, tx, ty float64) (bool, error)

PIPFromWKB reports whether (tx, ty) lies inside the polygon encoded in data. Semantics match Polygon.Contains(pt) for Polygon inputs (test point against exterior, exclude holes) and MultiPolygon "point in any constituent polygon" for MultiPolygon inputs. Non-polygon type codes (Point, LineString, etc.) return (false, nil) — matches the AoS shape where Polygon.Contains isn't defined on those types.

This is Slice 4's WKB-facing entry point. Walks the byte stream once with an inline even-odd crossing test — no []Point or Polygon allocation, no `closedRing` copy for unclosed rings. Zero allocation per call.

Same "points on the boundary have undefined containment" caveat as the AoS pointInRing kernel. Callers requiring boundary-inclusive semantics should pair this with a separate on-boundary scan, matching the pointInPolygon → pointOnPolygonBoundary shape in the AoS path.

func PIPInclusiveFromWKB ¶ added in v0.4.1

func PIPInclusiveFromWKB(data []byte, tx, ty float64) (bool, error)

PIPInclusiveFromWKB reports whether (tx, ty) lies inside the polygon encoded in data OR on its boundary. Semantics match the AoS `pointInPolygon(pt, poly)` exactly, i.e. boundary-inclusive containment. This is the entry point SJoin's Points × Polygons refine needs — the strict-interior `PIPFromWKB` has documented undefined behavior on boundaries, which would silently change SJoin semantics for grid-aligned data.

Single WKB pass: extends the ring scan to also do a point-on-segment test per segment (collinearity + within-bbox). Returns true on first boundary hit; otherwise finalizes with the crossing-count parity. Zero allocation on well-formed input.

Non-polygon type codes (Point, LineString, etc.) return (false, nil) — matches PIPFromWKB.

func PIPPolygonFromRings ¶ added in v0.4.1

func PIPPolygonFromRings(rings []PointsView, tx, ty float64) bool

PIPPolygonFromRings tests point-in-polygon over a full polygon represented as an ordered slice of PointsViews: rings[0] is the exterior ring; rings[1:] are holes. Returns true iff (tx, ty) lies inside the exterior and outside every hole.

Semantics match Polygon.Contains on the AoS representation. Zero allocation. Callers holding a Polygon can obtain the RingViews once via `polygon.RingViews()` (Slice 1 amortization) and reuse the slice across many candidate points — the common pattern in spatial-join refine loops.

Empty rings input returns false.

func PIPRingFromXY ¶ added in v0.4.1

func PIPRingFromXY(xs, ys []float64, tx, ty float64) bool

PIPRingFromXY reports whether the point (tx, ty) lies inside the polygon ring defined by parallel Xs / Ys slices. Even-odd crossing rule; matches the semantics of pointInRing on the AoS `[]Point` representation.

Handles both closed rings (last point equals first) and unclosed rings — the crossing test walks segments (i, i+1) for i in [0, n-1) and (if the ring isn't already closed) implicitly the (n-1, 0) closing segment via the modulo-wrap loop shape.

Points on the boundary have undefined containment, same as the AoS pointInRing kernel. Callers requiring boundary-inclusive semantics should combine with a separate on-boundary check (matches pointInPolygon → pointOnPolygonBoundary in the AoS path).

Empty ring (fewer than 3 points) or mismatched-length slices return false. Zero-allocation on every input.

func PROJJSONFor ¶ added in v0.3.0

func PROJJSONFor(epsg int32) map[string]any

PROJJSONFor returns the canonical PROJJSON object for the given EPSG code, or nil if we don't have one on file. Callers include this in GeoParquet's "geo" metadata so downstream readers (geopandas via pyproj) can round-trip the CRS.

func PlanarAreaFromWKB ¶ added in v0.4.1

func PlanarAreaFromWKB(data []byte) (float64, error)

PlanarAreaFromWKB returns the absolute planar (XY) area of the WKB geometry in coord² without materializing intermediate []Point / Polygon structs. Polygon area is exterior − holes; MultiPolygon sums per-polygon area; GeometryCollection recurses. Non-areal types (Point, LineString, MultiPoint, MultiLineString) contribute 0.

Semantics match `PlanarRingArea` composed via `Polygon.Area` on a projected CRS — i.e. the shoelace formula applied ring-by- ring with unclosed rings treated as if the first vertex were virtually appended. Unit conversion is left to the caller (multiply by `1 / (perM*perM)` for a projected CRS whose linear unit is meters). Geographic CRSes must fall back to the AoS spherical-excess path.

Byte-order / type-code handling mirrors ParseWKB; malformed input returns an error. Zero-allocation on well-formed input.

func PlanarLengthFromWKB ¶ added in v0.4.1

func PlanarLengthFromWKB(data []byte) (float64, error)

PlanarLengthFromWKB returns the planar (XY) length of the WKB geometry in coordinate units without materializing any intermediate []Point / LineString structs. Sums Euclidean segment lengths for LineString / MultiLineString; recurses into GeometryCollections. All other type codes (Point, MultiPoint, Polygon, MultiPolygon) contribute 0 — matches the AoS shape of `geometry.Length` where non-linear geometries return 0.

This is the SoA sibling of BoundsFromWKB / CentroidFromWKB for callers that only need the planar linear extent — e.g. a Series GeomLength column over a projected CRS. Returns coordinate-unit length; Unit conversion is left to the caller (multiply by `1 / metersPerUnit(u)` for a projected CRS whose linear unit is meters). Geographic CRSes must fall back to the AoS Haversine path — the WKB blob doesn't carry CRS context.

Byte-order / type-code handling mirrors ParseWKB; malformed input returns an error. Zero-allocation on well-formed input.

func PlanarMinDistanceFromWKB ¶ added in v0.4.1

func PlanarMinDistanceFromWKB(a, b []byte) (float64, error)

PlanarMinDistanceFromWKB returns the min planar Euclidean distance between two WKB-encoded geometries. Parses both to slab-form representations directly (no `[]Point` intermediate) and runs the Slice-11 min-distance nested loop with a single `math.Sqrt` at the end.

Allocation shape ¶

The parse skips `[]Point` materialization but does `append` onto per-role slabs (pointXs/pointYs, polylines). For most workloads this amortizes to a small constant number of `growslice` calls; callers that need strict zero-alloc must pre-scan geometry counts and pass hinted slabs — not a supported entry point today.

Non-intersection assumption ¶

This function is a fast path for the (bbox-disjoint → definitely non-intersecting) case that `Series.GeomDistance` uses when filtering rows against a fixed `other`. It does NOT run a segment-segment intersects check; intersecting geometries can produce a nonzero distance (matching the vertex-to-segment approach that `planarMinDistance` returns for non-intersecting inputs). Callers that need `Intersects → 0` semantics must verify bboxes are disjoint or fall through to the AoS `GeomDistance(a, b, u)` path.

Returns math.Inf(+1) when both inputs are empty (no vertex or segment to compare against). Malformed WKB returns an error.

func PlanarRingArea ¶ added in v0.3.4

func PlanarRingArea(ring []Point) float64

PlanarRingArea returns the planar (unsigned) area of a ring via the shoelace formula. Independent of CRS — callers that need the spherical-area interpretation for geographic coordinates should use Polygon.Area with a Unit instead. Exposed so downstream packages (predicate stats, buffer heuristics) can compute planar areas without re-implementing the shoelace loop.

Rings that aren't explicitly closed (first vertex != last vertex) are treated as if the caller had appended the first vertex again.

func PointToPolylineMinDistanceSq ¶ added in v0.4.1

func PointToPolylineMinDistanceSq(px, py float64, xs, ys []float64, closed bool) float64

PointToPolylineMinDistanceSq returns the minimum squared Euclidean distance from (px, py) to any point on the polyline held in parallel Xs / Ys slabs. When closed=true the closing segment (last, first) is also considered — matching the ring closure that Polygon.Segments enumerates.

Empty polyline returns math.Inf(1) (no segments to compare against). Single-point polyline returns squared distance from (px, py) to that single vertex.

Zero-alloc; single pass over the polyline slabs.

func PointToSegmentDistanceSqXY ¶ added in v0.4.1

func PointToSegmentDistanceSqXY(px, py, ax, ay, bx, by float64) float64

PointToSegmentDistanceSqXY returns the squared Euclidean distance from (px, py) to the closed line segment ((ax, ay), (bx, by)). Handles a == b (zero-length segment) as squared point-to-point distance.

Why squared ¶

Min-distance loops repeatedly compare distances and only need the sqrt on the final answer. The classic AoS pointToSegmentDistance in distance_geom.go calls math.Hypot per segment; on a polygon×polygon distance with ~100 vertices each, that's 10k sqrts per per-row call. Squared form defers to a single sqrt at the outermost call — see planarMinDistance's slab-form rewrite (Slice 11).

The formula is the standard projection-onto-line-segment:

t = ((p-a) · (b-a)) / |b-a|²   clamped to [0, 1]
f = a + t·(b-a)                 nearest point on segment
d² = (p.x - f.x)² + (p.y - f.y)²

When |b-a|² == 0 the segment is a single point; return squared distance from p to a directly.

func RegisterCRS ¶

func RegisterCRS(c CRS)

RegisterCRS adds a CRS to the runtime registry. Overwrites any prior entry for the same EPSG code.

func SimplifyDPFromXY ¶ added in v0.4.1

func SimplifyDPFromXY(xs, ys []float64, tolerance float64) (outXs, outYs []float64)

SimplifyDPFromXY runs iterative Douglas-Peucker on parallel Xs / Ys slabs, returning a fresh pair of slabs containing the retained coordinates. Endpoints are always preserved. tolerance ≤ 0 or n < 3 returns a copy of the input coordinates.

Design vs. the AoS douglasPeucker ¶

The AoS `douglasPeucker([]Point, float64)` in simplify.go is recursive; at every split it slices the []Point twice and stitches the two halves with a fresh append allocation. Frequent splits on real-world polylines (coastlines, admin boundaries) mean O(log n) heap allocations per polyline alongside the O(n) `[]Point` walks the recursion drives.

This SoA rewrite is iterative on an explicit (lo, hi) stack plus a keep-bitmap:

• One []bool allocation of length n.
• One stack allocation (typically log₂(n) frames — 20-ish for a coastline-scale ring).
• Two final output []float64 allocations sized to the exact retained count.

Total: 3-4 allocations regardless of split count, vs the AoS recursion's O(log n) per-split appends.

The perpendicular-distance kernel avoids the sqrt+div on non-splitting segments: instead of computing `d = |cross| / segLen` per point and comparing against `tolerance`, it tracks `argmax(cross²)` across the sub-array and compares once against `tolerance² * segLen²`. Saves one sqrt per split when no interior point exceeds tolerance (the common case near the leaves of the DP tree).

Determinism vs. AoS ¶

Split order matches the AoS recursion (left before right) so the produced vertex indices are identical for well-formed input. Tie-breaking on argmax also matches (both use strict `>` which picks the first occurrence of the max).

func String ¶

func String(g Geometry) string

String returns g's WKT representation, prefixed by its CRS if set.

func Test ¶

func Test(pred Predicate, a, b Geometry) bool

Test evaluates pred on the ordered pair (a, b).

func TestPointPrepared ¶ added in v0.4.2

func TestPointPrepared(pred Predicate, x, y float64, prep PreparedGeometry) bool

TestPointPrepared evaluates pred on (Point{x, y}, prep.G) without the interface-boxing allocation that Prepare(Point{...}) + TestPrepared would incur. The atomic query underlying TestPointsPrepared — the batch API is essentially a loop over this with a held R-tree scratch.

Fast-path shapes (same as TestPrepared, non-swapped ordering):

• Point × Polygon: pred ∈ {Intersects, Within}
• Point × MultiPolygon: pred ∈ {Intersects, Within}

Every other pred / prep shape falls through to per-call Test — no panic, no error, just AoS semantics.

Concurrent-safe against the prep (atomic lazy slots).

func TestPointsPrepared ¶ added in v0.4.2

func TestPointsPrepared(pred Predicate, xs, ys []float64, prep PreparedGeometry, out []bool)

TestPointsPrepared evaluates pred for each (Point{xs[i], ys[i]}, prep.G) pair, writing results into out. Semantics match a per- index Test(pred, Point{X: xs[i], Y: ys[i]}, prep.G).

The batch amortizes prep-side work across every point:

• Ring views / R-tree / bounds are materialized once by Prepare and shared across the entire call.
• No per-point interface-boxing of the point into a Geometry (single-point TestPrepared costs one alloc per Prepare(Point{...})).
• MultiPolygon R-tree Search scratch is held for the whole batch, not Get/Put'd per point.
• Bbox reject is inlined into the loop with no dispatch overhead.

Fast-path shapes (same as TestPrepared, non-swapped ordering):

• Point × Polygon: pred ∈ {Intersects, Within}
• Point × MultiPolygon: pred ∈ {Intersects, Within}

Every other pred (Contains, Disjoint, ...) or prep shape falls through to per-point Test — correctness preserved, no batch speedup.

len(xs) must equal len(ys); len(out) must be ≥ len(xs). Panics on mismatch (matches compute-package convention).

Concurrent-safe against the prep — atomic lazy slots let multiple goroutines batch-query the same prep. The out buffer obviously must not be shared across goroutines.

func TestPrepared ¶ added in v0.4.1

func TestPrepared(pred Predicate, a, b PreparedGeometry) bool

TestPrepared evaluates pred on the ordered pair (a, b) using precomputed SoA views when the pair shape has a fast path. Semantically equivalent to Test(pred, a.G, b.G).

Nil geometry on either side returns false for every predicate (matches Test). Non-fast-path shapes fall through to Test — the only cost of using TestPrepared over Test on those shapes is the bounds-reject double-check + the type-switch overhead (single-digit nanoseconds per call).

func Touches ¶ added in v0.3.0

func Touches(a, b Geometry) bool

Touches reports whether a and b share at least one boundary point but no interior points. Matches shapely's a.touches(b). Empty geometries return false.

func TypeString ¶ added in v0.3.0

func TypeString(g Geometry) string

TypeString returns the OGC-style name for g's concrete type ("Point", "MultiPolygon", etc.). Matches shapely's .geom_type output.

func UTMEpsgFor ¶

func UTMEpsgFor(lon, lat float64) int32

UTMEpsgFor returns the EPSG code of the UTM CRS covering (lon, lat) on the WGS84 datum. Latitude sign selects hemisphere.

func UTMZoneFor ¶

func UTMZoneFor(lon float64) int

UTMZoneFor returns the UTM zone number [1..60] whose central meridian nearest longitude lon.

func WKB ¶

func WKB(g Geometry) []byte

WKB returns the Well-Known Binary encoding of g.

func WKBTypeCode ¶ added in v0.4.1

func WKBTypeCode(data []byte) (typ uint32, hasZ bool, err error)

WKBTypeCode returns the OGC type code (and whether Z is present) of the WKB blob without decoding any coordinates. Zero-alloc. Callers dispatching per-type fast paths (SoA scanners vs AoS fallback based on shape) use this to peek before committing to a full ParseWKB.

Returned codes match the WKB spec: 1=Point, 2=LineString, 3=Polygon, 4=MultiPoint, 5=MultiLineString, 6=MultiPolygon, 7=GeometryCollection. hasZ=true when the code is the 1001-1007 variant.

func Within ¶

func Within(a, b Geometry) bool

Within is Contains(b, a).

func WithinDistance ¶ added in v0.3.5

func WithinDistance(a, b Geometry, d float64) bool

WithinDistance reports whether any two points in a and b are at most d coordinate units apart. Equivalent to `GeomDistance(a, b) <= d` but with a bbox-distance short-circuit that lets far-apart pairs return false without walking edges.

d must be non-negative; d = 0 is equivalent to Intersects(a, b). Nil operands or NaN d return false. Coordinates are treated as planar — for lon/lat inputs, project to a suitable CRS first (Haversine + a per-row loop covers the geographic case).

The bbox short-circuit computes the minimum distance between the two bounding rectangles: if that's already > d, no interior point pair could be closer. This is what makes DWithin's row- group pushdown pay off — a row whose bbox is far from an AOI bbox never gets its WKB decoded.