Package.swift

@@ -5,6 +5,7 @@ import PackageDescription
 let swiftSettings: [SwiftSetting] = [
     .enableExperimentalFeature("StrictConcurrency"), // 5.10
     .enableUpcomingFeature("StrictConcurrency"), // 6.0
+    .enableUpcomingFeature("InferSendableFromCaptures"), // Silences a Sendable warning
 ]
 
 let package = Package(

Sources/GISTools/Algorithms/BooleanPointInPolygon.swift

@@ -88,15 +88,15 @@ extension Polygon {
         ignoreBoundary: Bool = false)
         -> Bool
     {
-        if let boundingBox = boundingBox, !boundingBox.contains(coordinate) {
+        if let boundingBox, !boundingBox.contains(coordinate) {
             return false
         }
 
-        guard let outerRing = outerRing, outerRing.contains(coordinate, ignoreBoundary: ignoreBoundary) else {
-            return false
-        }
+        guard let outerRing = outerRing,
+              outerRing.contains(coordinate, ignoreBoundary: ignoreBoundary)
+        else { return false }
 
-        if let innerRings = innerRings {
+        if let innerRings {
             for ring in innerRings {
                 if ring.contains(coordinate, ignoreBoundary: ignoreBoundary) {
                     return false
@@ -140,6 +140,10 @@ extension MultiPolygon {
         ignoreBoundary: Bool = false)
         -> Bool
     {
+        if let boundingBox, !boundingBox.contains(coordinate) {
+            return false
+        }
+
         for polygon in polygons {
             if polygon.contains(coordinate, ignoreBoundary: ignoreBoundary) {
                 return true

Sources/GISTools/Algorithms/BoundingBoxPosition.swift

@@ -0,0 +1,83 @@
+#if !os(Linux)
+import CoreLocation
+#endif
+import Foundation
+
+extension BoundingBox {
+
+    /// Position of a coordinate in relation to a bounding box.
+    public struct CoordinatePosition: OptionSet, Sendable {
+        public let rawValue: Int
+
+        public init(rawValue: Int) {
+            self.rawValue = rawValue
+        }
+
+        public static let center = CoordinatePosition(rawValue: 1 << 0)
+        public static let top = CoordinatePosition(rawValue: 1 << 1)
+        public static let right = CoordinatePosition(rawValue: 1 << 2)
+        public static let bottom = CoordinatePosition(rawValue: 1 << 3)
+        public static let left = CoordinatePosition(rawValue: 1 << 4)
+        public static let outside = CoordinatePosition(rawValue: 1 << 5)
+    }
+
+    /// Returns the relative position of a coordinate with regards to the bounding box.
+    public func position(of coordinate: Coordinate3D) -> CoordinatePosition {
+        var position: CoordinatePosition = []
+
+        if !contains(coordinate) {
+            position.insert(.outside)
+        }
+
+        let latitudeSpan = northEast.latitude - southWest.latitude
+        let longitudeSpan = northEast.longitude - southWest.longitude
+
+        let topCutoff = southWest.latitude + (latitudeSpan * 0.65)
+        if coordinate.latitude > topCutoff {
+            position.insert(.top)
+        }
+
+        let rightCutoff = southWest.longitude + (longitudeSpan * 0.65)
+        if coordinate.longitude > rightCutoff {
+            position.insert(.right)
+        }
+
+        let bottomCutoff = southWest.latitude + (latitudeSpan * 0.35)
+        if coordinate.latitude < bottomCutoff {
+            position.insert(.bottom)
+        }
+
+        let leftCutoff = southWest.longitude + (longitudeSpan * 0.35)
+        if coordinate.longitude < leftCutoff {
+            position.insert(.left)
+        }
+
+        if position.isEmpty {
+            position.insert(.center)
+        }
+
+        return position
+    }
+
+    /// Returns the relative position of a point with regards to the bounding box.
+    public func postion(of point: Point) -> CoordinatePosition {
+        position(of: point.coordinate)
+    }
+
+    // MARK: - CoreLocation compatibility
+
+#if !os(Linux)
+
+    /// Returns the relative position of a coordinate with regards to the bounding box.
+    public func postion(of coordinate: CLLocationCoordinate2D) -> CoordinatePosition {
+        position(of: Coordinate3D(coordinate))
+    }
+
+    /// Returns the relative position of a location with regards to the bounding box.
+    public func postion(of coordinate: CLLocation) -> CoordinatePosition {
+        position(of: Coordinate3D(coordinate))
+    }
+
+#endif
+
+}

Sources/GISTools/Algorithms/Center.swift

@@ -24,7 +24,11 @@ extension GeoJson {
     public var centroid: Point? {
         let allCoordinates = self.allCoordinates
 
-        guard !allCoordinates.isEmpty else { return nil }
+        guard allCoordinates.isNotEmpty else { return nil }
+
+        if allCoordinates.count == 1 {
+            return Point(allCoordinates[0])
+        }
 
         var sumLongitude: Double = 0.0
         var sumLatitude: Double = 0.0

Sources/GISTools/Algorithms/Conversions.swift

@@ -10,7 +10,7 @@ import Foundation
 extension GISTool {
 
     /// Unit of measurement.
-    public enum Unit {
+    public enum Unit: Sendable {
         case acres
         case centimeters
         case centimetres
@@ -43,7 +43,7 @@ extension GISTool {
         case .millimeters, .millimetres: return earthRadius * 1000.0
         case .nauticalmiles: return earthRadius / 1852.0
         case .radians: return 1.0
-        case .yards: return earthRadius / 1.0936
+        case .yards: return earthRadius / (1.0 / 1.0936)
         default: return nil
         }
     }
@@ -70,28 +70,36 @@ extension GISTool {
     public static func areaFactor(for unit: Unit) -> Double? {
         switch unit {
         case .acres: return 0.000247105
-        case .centimeters, .centimetres: return 10000.0
+        case .centimeters, .centimetres: return 10_000.0
         case .feet: return 10.763910417
         case .inches: return 1550.003100006
         case .kilometers, .kilometres: return 0.000001
         case .meters, .metres: return 1.0
         case .miles: return 3.86e-7
-        case .millimeters, .millimetres: return 1_000_000
+        case .millimeters, .millimetres: return 1_000_000.0
         case .yards: return 1.195990046
         default: return nil
         }
     }
 
     /// Converts a length to the requested unit.
     /// Valid units: miles, nauticalmiles, inches, yards, meters, metres, kilometers, centimeters, feet
-    public static func convert(length: Double, from originalUnit: Unit, to finalUnit: Unit) -> Double? {
+    public static func convert(
+        length: Double,
+        from originalUnit: Unit,
+        to finalUnit: Unit
+    ) -> Double? {
         guard length >= 0 else { return nil }
         return length.lengthToRadians(unit: originalUnit)?.radiansToLength(unit: finalUnit)
     }
 
     /// Converts a area to the requested unit.
     /// Valid units: kilometers, kilometres, meters, metres, centimetres, millimeters, acres, miles, yards, feet, inches
-    public static func convert(area: Double, from originalUnit: Unit, to finalUnit: Unit) -> Double? {
+    public static func convert(
+        area: Double,
+        from originalUnit: Unit,
+        to finalUnit: Unit
+    ) -> Double? {
         guard area >= 0,
               let startFactor = areaFactor(for: originalUnit),
               let finalFactor = areaFactor(for: finalUnit)
@@ -106,15 +114,29 @@ extension GISTool {
 
 extension GISTool {
 
-    /// Converts pixel coordinates in a given zoom level to a coordinate.
+    @available(*, deprecated, renamed: "coordinate(fromPixelX:pixelY:zoom:tileSideLength:projection:)")
     public static func convertToCoordinate(
         fromPixelX pixelX: Double,
         pixelY: Double,
         atZoom zoom: Int,
         tileSideLength: Double = GISTool.tileSideLength,
-        projection: Projection = .epsg4326)
-        -> Coordinate3D
-    {
+        projection: Projection = .epsg4326
+    ) -> Coordinate3D {
+        coordinate(fromPixelX: pixelX,
+                   pixelY: pixelY,
+                   zoom: zoom,
+                   tileSideLength: tileSideLength,
+                   projection: projection)
+    }
+
+    /// Converts pixel coordinates in a given zoom level to a coordinate.
+    public static func coordinate(
+        fromPixelX pixelX: Double,
+        pixelY: Double,
+        zoom: Int,
+        tileSideLength: Double = GISTool.tileSideLength,
+        projection: Projection = .epsg4326
+    ) -> Coordinate3D {
         let resolution = metersPerPixel(atZoom: zoom, tileSideLength: tileSideLength)
 
         let coordinateXY = Coordinate3D(
@@ -144,11 +166,18 @@ extension GISTool {
 
 extension GISTool {
 
+    @available(*, deprecated, renamed: "degrees(fromMeters:atLatitude:)")
     public static func convertToDegrees(
         fromMeters meters: Double,
-        atLatitude latitude: CLLocationDegrees)
-        -> (latitudeDegrees: CLLocationDegrees, longitudeDegrees: CLLocationDegrees)
-    {
+        atLatitude latitude: CLLocationDegrees
+    ) -> (latitudeDegrees: CLLocationDegrees, longitudeDegrees: CLLocationDegrees) {
+        degrees(fromMeters: meters, atLatitude: latitude)
+    }
+
+    public static func degrees(
+        fromMeters meters: CLLocationDistance,
+        atLatitude latitude: CLLocationDegrees
+    ) -> (latitudeDegrees: CLLocationDegrees, longitudeDegrees: CLLocationDegrees) {
         // Length of one minute at this latitude
         let oneDegreeLatitudeDistance: CLLocationDistance = GISTool.earthCircumference / 360.0 // ~111 km
         let oneDegreeLongitudeDistance: CLLocationDistance = cos(latitude * Double.pi / 180.0) * oneDegreeLatitudeDistance
@@ -160,3 +189,13 @@ extension GISTool {
     }
 
 }
+
+extension Coordinate3D {
+
+    public func degrees(
+        fromMeters meters: CLLocationDistance
+    ) -> (latitudeDegrees: CLLocationDegrees, longitudeDegrees: CLLocationDegrees) {
+        GISTool.degrees(fromMeters: meters, atLatitude: latitude)
+    }
+
+}

Sources/GISTools/Algorithms/FrechetDistance.swift

@@ -37,7 +37,7 @@ extension LineString {
     /// - Parameters:
     ///    - from: The other geometry of equal type.
     ///    - distanceFunction: The algorithm to use for distance calculations.
-    ///    - segmentLength: Adds coordinates to the lines for improved matching (in meters).
+    ///    - segmentLength: This value adds intermediate points to the geometry for improved matching, in meters.
     ///
     /// - Returns: The frechet distance between the two geometries.
     public func frechetDistance(