108 lines
2.7 KiB
Go
108 lines
2.7 KiB
Go
package geo
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
)
|
|
|
|
type geometry struct {
|
|
Type string `json:"type"`
|
|
Coordinates json.RawMessage `json:"coordinates"`
|
|
}
|
|
|
|
// ContainsPoint reports whether a GeoJSON Polygon or MultiPolygon contains p.
|
|
// GeoJSON coordinate order is [longitude, latitude].
|
|
func ContainsPoint(raw []byte, p Point) (bool, error) {
|
|
if len(raw) == 0 {
|
|
return false, fmt.Errorf("geojson geometry is empty")
|
|
}
|
|
|
|
var geom geometry
|
|
if err := json.Unmarshal(raw, &geom); err != nil {
|
|
return false, fmt.Errorf("decode geojson geometry: %w", err)
|
|
}
|
|
|
|
switch geom.Type {
|
|
case "Polygon":
|
|
polygon, err := decodePolygon(geom.Coordinates)
|
|
if err != nil {
|
|
return false, fmt.Errorf("decode polygon: %w", err)
|
|
}
|
|
return polygonContainsPoint(polygon, p), nil
|
|
case "MultiPolygon":
|
|
multiPolygon, err := decodeMultiPolygon(geom.Coordinates)
|
|
if err != nil {
|
|
return false, fmt.Errorf("decode multipolygon: %w", err)
|
|
}
|
|
for _, polygon := range multiPolygon {
|
|
if polygonContainsPoint(polygon, p) {
|
|
return true, nil
|
|
}
|
|
}
|
|
return false, nil
|
|
case "":
|
|
return false, fmt.Errorf("geojson geometry type is required")
|
|
default:
|
|
return false, fmt.Errorf("unsupported geojson geometry type %q", geom.Type)
|
|
}
|
|
}
|
|
|
|
func decodePolygon(raw json.RawMessage) (Polygon, error) {
|
|
var coords [][][]float64
|
|
if err := json.Unmarshal(raw, &coords); err != nil {
|
|
return nil, err
|
|
}
|
|
return polygonFromCoordinates(coords)
|
|
}
|
|
|
|
func decodeMultiPolygon(raw json.RawMessage) ([]Polygon, error) {
|
|
var coords [][][][]float64
|
|
if err := json.Unmarshal(raw, &coords); err != nil {
|
|
return nil, err
|
|
}
|
|
if len(coords) == 0 {
|
|
return nil, fmt.Errorf("multipolygon has no polygons")
|
|
}
|
|
|
|
out := make([]Polygon, 0, len(coords))
|
|
for i, polygonCoords := range coords {
|
|
polygon, err := polygonFromCoordinates(polygonCoords)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("polygons[%d]: %w", i, err)
|
|
}
|
|
out = append(out, polygon)
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func polygonFromCoordinates(coords [][][]float64) (Polygon, error) {
|
|
if len(coords) == 0 {
|
|
return nil, fmt.Errorf("polygon has no rings")
|
|
}
|
|
|
|
polygon := make(Polygon, 0, len(coords))
|
|
for i, ringCoords := range coords {
|
|
ring, err := ringFromCoordinates(ringCoords)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("rings[%d]: %w", i, err)
|
|
}
|
|
polygon = append(polygon, ring)
|
|
}
|
|
return polygon, nil
|
|
}
|
|
|
|
func ringFromCoordinates(coords [][]float64) (Ring, error) {
|
|
if len(coords) == 0 {
|
|
return nil, fmt.Errorf("ring has no points")
|
|
}
|
|
|
|
ring := make(Ring, 0, len(coords))
|
|
for i, pair := range coords {
|
|
if len(pair) < 2 {
|
|
return nil, fmt.Errorf("points[%d] has %d values, need longitude and latitude", i, len(pair))
|
|
}
|
|
ring = append(ring, Point{Longitude: pair[0], Latitude: pair[1]})
|
|
}
|
|
return ring, nil
|
|
}
|