update turf

CHANGELOG.md

@@ -17,6 +17,8 @@
 * Custom location snapping in the `RouteController` via the delegate
 * Fix: If the directions API endpoint doesn't include audio instructions, `didArrive:` would never be called.
   * Merged in <https://github.com/maplibre/maplibre-navigation-ios/pull/72>
+* Updated "turf" geometry library from 0.2.2 to 2.8.0
+    * Merged in https://github.com/maplibre/maplibre-navigation-ios/pull/91
 
 ## 3.0.0 (Jun 15, 2024)
 * The `speak` method in `RouteVoiceController` can be used without a given `RouteProgress` or the `RouteProgress` can explicitly ignored so that it will not be added to the voice instruction.

Example/Example.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved

@@ -48,10 +48,10 @@
     {
       "identity" : "turf-swift",
       "kind" : "remoteSourceControl",
-      "location" : "https://github.com/flitsmeister/turf-swift",
+      "location" : "https://github.com/mapbox/turf-swift.git",
       "state" : {
-        "revision" : "b05b4658d1b48eac4127a0d9ebbb5a6f965a8251",
-        "version" : "0.2.2"
+        "revision" : "213050191cfcb3d5aa76e1fa90c6ff1e182a42ca",
+        "version" : "2.8.0"
       }
     }
   ],

MapboxCoreNavigation/CLLocation.swift

@@ -61,27 +61,29 @@ extension CLLocation {
      Returns a Boolean value indicating whether the receiver is within a given distance of a route step.
      */
     func isWithin(_ maximumDistance: CLLocationDistance, of routeStep: RouteStep) -> Bool {
-        guard let closestCoordinate = Polyline(routeStep.coordinates!).closestCoordinate(to: coordinate) else {
+        guard let closestCoordinate = LineString(routeStep.coordinates!).closestCoordinate(to: coordinate) else {
             return false
         }
-        return closestCoordinate.distance < maximumDistance
+        let distance = closestCoordinate.coordinate.distance(to: self.coordinate)
+        return distance < maximumDistance
     }
 
     // MARK: - Route Snapping
 
     func snapped(to legProgress: RouteLegProgress) -> CLLocation? {
         let coords = self.coordinates(for: legProgress)
 
-        guard let closest = Polyline(coords).closestCoordinate(to: coordinate) else { return nil }
+        guard let closest = LineString(coords).closestCoordinate(to: coordinate) else { return nil }
         guard let calculatedCourseForLocationOnStep = interpolatedCourse(along: coords) else { return nil }
 
         let userCourse = calculatedCourseForLocationOnStep
         let userCoordinate = closest.coordinate
         guard let firstCoordinate = legProgress.leg.steps.first?.coordinates?.first else { return nil }
 
         guard self.shouldSnapCourse(toRouteWith: calculatedCourseForLocationOnStep, distanceToFirstCoordinateOnLeg: coordinate.distance(to: firstCoordinate)) else { return nil }
-
-        guard closest.distance <= (RouteControllerUserLocationSnappingDistance + horizontalAccuracy) else {
+
+        let distanceFromLeg = closest.coordinate.distance(to: self.coordinate)
+        guard distanceFromLeg <= (RouteControllerUserLocationSnappingDistance + horizontalAccuracy) else {
             return nil
         }
 
@@ -121,12 +123,12 @@ extension CLLocation {
      Given a location and a series of coordinates, compute what the course should be for a the location.
      */
     func interpolatedCourse(along coordinates: [CLLocationCoordinate2D]) -> CLLocationDirection? {
-        let nearByPolyline = Polyline(coordinates)
-        
+        let nearByPolyline = LineString(coordinates)
+
         guard let closest = nearByPolyline.closestCoordinate(to: coordinate) else { return nil }
 
-        let slicedLineBehind = Polyline(coordinates.reversed()).sliced(from: closest.coordinate, to: coordinates.reversed().last)
-        let slicedLineInFront = nearByPolyline.sliced(from: closest.coordinate, to: coordinates.last)
+        guard let slicedLineBehind = LineString(coordinates.reversed()).sliced(from: closest.coordinate, to: coordinates.reversed().last) else { return nil }
+        guard let slicedLineInFront = nearByPolyline.sliced(from: closest.coordinate, to: coordinates.last) else { return nil }
         let userDistanceBuffer: CLLocationDistance = max(speed * RouteControllerDeadReckoningTimeInterval / 2, RouteControllerUserLocationSnappingDistance / 2)
 
         guard let pointBehind = slicedLineBehind.coordinateFromStart(distance: userDistanceBuffer) else { return nil }
@@ -145,10 +147,11 @@ extension CLLocation {
 
         let averageRelativeAngle: Double
             // User is at the beginning of the route, there is no closest point behind the user.
-            = if pointBehindClosest.distance <= 0, pointAheadClosest.distance > 0 {
+            = if pointBehindClosest.coordinate.distance(to: pointBehind) <= 0, pointAheadClosest.coordinate.distance(to: pointAhead) > 0 {
             relativeAnglepointAhead
             // User is at the end of the route, there is no closest point in front of the user.
-        } else if pointAheadClosest.distance <= 0, pointBehindClosest.distance > 0 {
+        } else if pointAheadClosest.coordinate.distance(to: pointAhead) <= 0,
+                  pointBehindClosest.coordinate.distance(to: pointBehind) > 0 {
             relativeAnglepointBehind
         } else {
             (relativeAnglepointBehind + relativeAnglepointAhead) / 2

MapboxCoreNavigation/RouteController.swift

@@ -254,7 +254,7 @@
             self.userSnapToStepDistanceFromManeuver = nil
             return
         }
-        self.userSnapToStepDistanceFromManeuver = Polyline(coordinates).distance(from: coordinate)
+        self.userSnapToStepDistanceFromManeuver = LineString(coordinates).distance(from: coordinate)
     }
 
     /**
@@ -303,7 +303,7 @@
     @objc func interpolateLocation() {
         guard let location = locationManager.lastKnownLocation else { return }
         guard let coordinates = routeProgress.route.coordinates else { return }
-        let polyline = Polyline(coordinates)
+        let polyline = LineString(coordinates)
 
         let distance = location.speed as CLLocationDistance
 
@@ -380,9 +380,9 @@
 
         self.updateIntersectionIndex(for: currentStepProgress)
         // Notify observers if the step’s remaining distance has changed.
-        let polyline = Polyline(routeProgress.currentLegProgress.currentStep.coordinates!)
-        if let closestCoordinate = polyline.closestCoordinate(to: location.coordinate) {
-            let remainingDistance = polyline.distance(from: closestCoordinate.coordinate)
+        let polyline = LineString(routeProgress.currentLegProgress.currentStep.coordinates!)
+        if let closestCoordinate = polyline.closestCoordinate(to: location.coordinate),
+           let remainingDistance = polyline.distance(from: closestCoordinate.coordinate) {
             let distanceTraveled = currentStep.distance - remainingDistance
             currentStepProgress.distanceTraveled = distanceTraveled
             NotificationCenter.default.post(name: .routeControllerProgressDidChange, object: self, userInfo: [
@@ -671,7 +671,7 @@
             if let _ = error { return }
             guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 else { return }
 
             guard let data, let currentVersion = String(data: data, encoding: .utf8)?.trimmingCharacters(in: .newlines) else { return }
 
             if latestVersion != currentVersion {
                 let updateString = NSLocalizedString("UPDATE_AVAILABLE", bundle: .mapboxCoreNavigation, value: "Mapbox Navigation SDK for iOS version %@ is now available.", comment: "Inform developer an update is available")
@@ -727,7 +727,7 @@
         self.routeProgress.currentLegProgress.currentStepProgress.intersectionsIncludingUpcomingManeuverIntersection = intersections
 
         if let upcomingIntersection = routeProgress.currentLegProgress.currentStepProgress.upcomingIntersection {
-            self.routeProgress.currentLegProgress.currentStepProgress.userDistanceToUpcomingIntersection = Polyline(currentStepProgress.step.coordinates!).distance(from: location.coordinate, to: upcomingIntersection.location)
+            self.routeProgress.currentLegProgress.currentStepProgress.userDistanceToUpcomingIntersection = LineString(currentStepProgress.step.coordinates!).distance(from: location.coordinate, to: upcomingIntersection.location)
         }
 
         if self.routeProgress.currentLegProgress.currentStepProgress.intersectionDistances == nil {
@@ -828,8 +828,8 @@
 
     func updateIntersectionDistances() {
         if let coordinates = routeProgress.currentLegProgress.currentStep.coordinates, let intersections = routeProgress.currentLegProgress.currentStep.intersections {
-            let polyline = Polyline(coordinates)
-            let distances: [CLLocationDistance] = intersections.map { polyline.distance(from: coordinates.first, to: $0.location) }
+            let polyline = LineString(coordinates)
+            let distances: [CLLocationDistance] = intersections.compactMap { polyline.distance(from: coordinates.first, to: $0.location) }
             self.routeProgress.currentLegProgress.currentStepProgress.intersectionDistances = distances
         }
     }

MapboxCoreNavigation/RouteProgress.swift

@@ -23,7 +23,7 @@
     @objc public var legIndex: Int {
         didSet {
             assert(self.legIndex >= 0 && self.legIndex < self.route.legs.endIndex)
             // TODO: Set stepIndex to 0 or last index based on whether leg index was incremented or decremented.
             self.currentLegProgress = RouteLegProgress(leg: self.currentLeg)
         }
     }
@@ -368,17 +368,18 @@
 
         for (currentStepIndex, step) in remainingSteps.enumerated() {
             guard let coords = step.coordinates else { continue }
-            guard let closestCoordOnStep = Polyline(coords).closestCoordinate(to: coordinate) else { continue }
+            guard let closestCoordOnStep = LineString(coords).closestCoordinate(to: coordinate) else { continue }
             let foundIndex = currentStepIndex + self.stepIndex
 
+            let distanceFromLine = closestCoordOnStep.coordinate.distance(to: coordinate)
             // First time around, currentClosest will be `nil`.
             guard let currentClosestDistance = currentClosest?.distance else {
-                currentClosest = (index: foundIndex, distance: closestCoordOnStep.distance)
+                currentClosest = (index: foundIndex, distance: distanceFromLine)
                 continue
             }
 
-            if closestCoordOnStep.distance < currentClosestDistance {
-                currentClosest = (index: foundIndex, distance: closestCoordOnStep.distance)
+            if distanceFromLine < currentClosestDistance {
+                currentClosest = (index: foundIndex, distance: distanceFromLine)
             }
         }
 

MapboxCoreNavigation/SimulatedLocationManager.swift

@@ -163,7 +163,7 @@ open class SimulatedLocationManager: NavigationLocationManager {
     @objc fileprivate func tick() {
         NSObject.cancelPreviousPerformRequests(withTarget: self, selector: #selector(self.tick), object: nil)
 
-        let polyline = Polyline(routeLine)
+        let polyline = LineString(routeLine)
 
         guard let newCoordinate = polyline.coordinateFromStart(distance: currentDistance) else {
             return
@@ -177,12 +177,12 @@ open class SimulatedLocationManager: NavigationLocationManager {
         let distanceToClosest = closestLocation.distance(from: CLLocation(newCoordinate))
 
         let distance = min(max(distanceToClosest, 10), safeDistance)
-        let coordinatesNearby = polyline.trimmed(from: newCoordinate, distance: 100).coordinates
-        
+        guard let coordinatesNearby = polyline.trimmed(from: newCoordinate, distance: 100)?.coordinates else { return }
+
         // Simulate speed based on expected segment travel time
         if let expectedSegmentTravelTimes = routeProgress?.currentLeg.expectedSegmentTravelTimes,
            let coordinates = routeProgress?.route.coordinates,
-           let closestCoordinateOnRoute = Polyline(routeProgress!.route.coordinates!).closestCoordinate(to: newCoordinate),
+           let closestCoordinateOnRoute = LineString(routeProgress!.route.coordinates!).closestCoordinate(to: newCoordinate),
            let nextCoordinateOnRoute = coordinates.after(element: coordinates[closestCoordinateOnRoute.index]),
            let time = expectedSegmentTravelTimes.optional[closestCoordinateOnRoute.index] {
             let distance = coordinates[closestCoordinateOnRoute.index].distance(to: nextCoordinateOnRoute)

MapboxCoreNavigationTests/RouteControllerTests.swift

@@ -145,7 +145,7 @@ class RouteControllerTests: XCTestCase {
         navigation.locationManager(navigation.locationManager, didUpdateLocations: [firstLocation])
         XCTAssertEqual(navigation.location!.coordinate, firstLocation.coordinate, "Check snapped location is working")
 
-        let futureCoord = Polyline(navigation.routeProgress.currentLegProgress.nearbyCoordinates).coordinateFromStart(distance: 100)!
+        let futureCoord = LineString(navigation.routeProgress.currentLegProgress.nearbyCoordinates).coordinateFromStart(distance: 100)!
         let futureInaccurateLocation = CLLocation(coordinate: futureCoord, altitude: 0, horizontalAccuracy: 1, verticalAccuracy: 200, course: 0, speed: 5, timestamp: Date())
 
         navigation.locationManager(navigation.locationManager, didUpdateLocations: [futureInaccurateLocation])
@@ -165,7 +165,7 @@ class RouteControllerTests: XCTestCase {
         let navigation = RouteController(along: route, directions: directions)
         let firstCoord = navigation.routeProgress.currentLegProgress.nearbyCoordinates.first!
         let firstLocation = CLLocation(latitude: firstCoord.latitude, longitude: firstCoord.longitude)
-        let coordNearStart = Polyline(navigation.routeProgress.currentLegProgress.nearbyCoordinates).coordinateFromStart(distance: 10)!
+        let coordNearStart = LineString(navigation.routeProgress.currentLegProgress.nearbyCoordinates).coordinateFromStart(distance: 10)!
 
         navigation.locationManager(navigation.locationManager, didUpdateLocations: [firstLocation])
 

MapboxCoreNavigationTests/TunnelIntersectionManagerTests.swift

@@ -186,7 +186,7 @@ private extension TunnelIntersectionManagerTests {
                   for routeController: RouteController,
                   intersection: Intersection,
                   distance: CLLocationDistance? = 200) -> CLLocation {
-        let polyline = Polyline(routeController.routeProgress.currentLegProgress.currentStep.coordinates!)
+        let polyline = LineString(routeController.routeProgress.currentLegProgress.currentStep.coordinates!)
         let newLocation = CLLocationCoordinate2D(latitude: coordinate.latitude,
                                                  longitude: coordinate.longitude).coordinate(
             at: distance!,

MapboxNavigation/NavigationMapView.swift

@@ -600,16 +600,19 @@
         let minimumZoomLevel: Float = 14.5
 
         let shaftLength = max(min(30 * metersPerPoint(atLatitude: maneuverCoordinate.latitude), 30), 10)
-        let polyline = Polyline(routeCoordinates)
-        let shaftCoordinates = Array(polyline.trimmed(from: maneuverCoordinate, distance: -shaftLength).coordinates.reversed()
-            + polyline.trimmed(from: maneuverCoordinate, distance: shaftLength).coordinates.suffix(from: 1))
+        let polyline = LineString(routeCoordinates)
+        guard let beforeTrimmedPolyline = polyline.trimmed(from: maneuverCoordinate, distance: -shaftLength),
+              let afterTrimmedPolyline = polyline.trimmed(from: maneuverCoordinate, distance: shaftLength) else {
+            return
+        }
+        let shaftCoordinates = Array(beforeTrimmedPolyline.coordinates.reversed() + afterTrimmedPolyline.coordinates.suffix(from: 1))
         if shaftCoordinates.count > 1 {
             var shaftStrokeCoordinates = shaftCoordinates
             let shaftStrokePolyline = ArrowStrokePolyline(coordinates: &shaftStrokeCoordinates, count: UInt(shaftStrokeCoordinates.count))
             let shaftDirection = shaftStrokeCoordinates[shaftStrokeCoordinates.count - 2].direction(to: shaftStrokeCoordinates.last!)
             let maneuverArrowStrokePolylines = [shaftStrokePolyline]
             let shaftPolyline = ArrowFillPolyline(coordinates: shaftCoordinates, count: UInt(shaftCoordinates.count))
-            
+
             let arrowShape = MLNShapeCollection(shapes: [shaftPolyline])
             let arrowStrokeShape = MLNShapeCollection(shapes: maneuverArrowStrokePolylines)
 
@@ -748,7 +751,7 @@
         }
     }
 
     // TODO: Change to point-based distance calculation
     private func waypoints(on routes: [Route], closeTo point: CGPoint) -> [Waypoint]? {
         let tapCoordinate = convert(point, toCoordinateFrom: self)
         let multipointRoutes = routes.filter { $0.routeOptions.waypoints.count >= 3 }
@@ -781,17 +784,17 @@
         let closest = routes.sorted { left, right -> Bool in
 
             // existance has been assured through use of filter.
-            let leftLine = Polyline(left.coordinates!)
-            let rightLine = Polyline(right.coordinates!)
-            let leftDistance = leftLine.closestCoordinate(to: tapCoordinate)!.distance
-            let rightDistance = rightLine.closestCoordinate(to: tapCoordinate)!.distance
-            
+            let leftLine = LineString(left.coordinates!)
+            let rightLine = LineString(right.coordinates!)
+            let leftDistance = leftLine.closestCoordinate(to: tapCoordinate)!.coordinate.distance(to: tapCoordinate)
+            let rightDistance = rightLine.closestCoordinate(to: tapCoordinate)!.coordinate.distance(to: tapCoordinate)
+
             return leftDistance < rightDistance
         }
 
         // filter closest coordinates by which ones are under threshold.
         let candidates = closest.filter {
-            let closestCoordinate = Polyline($0.coordinates!).closestCoordinate(to: tapCoordinate)!.coordinate
+            let closestCoordinate = LineString($0.coordinates!).closestCoordinate(to: tapCoordinate)!.coordinate
             let closestPoint = self.convert(closestCoordinate, toPointTo: self)
 
             return closestPoint.distance(to: point) < self.tapGestureDistanceThreshold
@@ -1037,7 +1040,7 @@
             for (stepIndex, step) in leg.steps.enumerated() {
                 for instruction in step.instructionsSpokenAlongStep! {
                     let feature = MLNPointFeature()
-                    feature.coordinate = Polyline(route.legs[legIndex].steps[stepIndex].coordinates!.reversed()).coordinateFromStart(distance: instruction.distanceAlongStep)!
+                    feature.coordinate = LineString(route.legs[legIndex].steps[stepIndex].coordinates!.reversed()).coordinateFromStart(distance: instruction.distanceAlongStep)!
                     feature.attributes = ["instruction": instruction.text]
                     features.append(feature)
                 }
@@ -1075,8 +1078,12 @@
      Sets the camera directly over a series of coordinates.
      */
     @objc public func setOverheadCameraView(from userLocation: CLLocationCoordinate2D, along coordinates: [CLLocationCoordinate2D], for bounds: UIEdgeInsets) {
+        assert(!coordinates.isEmpty, "must specify coordinates when setting overhead camera view")
+
         self.isAnimatingToOverheadMode = true
-        let slicedLine = Polyline(coordinates).sliced(from: userLocation).coordinates
+        guard let slicedLine = LineString(coordinates).sliced(from: userLocation)?.coordinates else {
+            return
+        }
         let line = MLNPolyline(coordinates: slicedLine, count: UInt(slicedLine.count))
 
         self.tracksUserCourse = false