Add example of vanishing route line feature for eHorizon. (#175)

Author: ShanMa1991

Navigation-Examples/Examples/Upcoming-Intersection.swift

@@ -18,13 +18,16 @@ class ElectronicHorizonEventsViewController: UIViewController {
     private let upcomingIntersectionLabel = UILabel()
     private let passiveLocationManager = PassiveLocationManager()
     private lazy var passiveLocationProvider = PassiveLocationProvider(locationManager: passiveLocationManager)
+    private let routeLineColor: UIColor = .green.withAlphaComponent(0.9)
+    private let traversedRouteColor: UIColor = .clear
+    private var totalDistance: CLLocationDistance = 0.0
 
     override func viewDidLoad() {
         super.viewDidLoad()
 
         setupNavigationMapView()
         setupUpcomingIntersectionLabel()
-        subscribeToElectronicHorizonUpdates()
+        setupElectronicHorizonUpdates()
     }
 
     func setupNavigationMapView() {
@@ -37,6 +40,13 @@ class ElectronicHorizonEventsViewController: UIViewController {
 
         view.addSubview(navigationMapView)
     }
+    
+    func setupElectronicHorizonUpdates() {
+        // Customize the `ElectronicHorizonOptions` for `PassiveLocationManager` to start Electronic Horizon updates.
+        let options = ElectronicHorizonOptions(length: 500, expansionLevel: 1, branchLength: 50, minTimeDeltaBetweenUpdates: nil)
+        passiveLocationManager.startUpdatingElectronicHorizon(with: options)
+        subscribeToElectronicHorizonUpdates()
+    }
 
     private func setupUpcomingIntersectionLabel() {
         upcomingIntersectionLabel.translatesAutoresizingMaskIntoConstraints = false
@@ -62,17 +72,27 @@ class ElectronicHorizonEventsViewController: UIViewController {
 
     @objc private func didUpdateElectronicHorizonPosition(_ notification: Notification) {
         let horizonTreeKey = RoadGraph.NotificationUserInfoKey.treeKey
-        guard let horizonTree = notification.userInfo?[horizonTreeKey] as? RoadGraph.Edge else {
+        guard let horizonTree = notification.userInfo?[horizonTreeKey] as? RoadGraph.Edge,
+              let position = notification.userInfo?[RoadGraph.NotificationUserInfoKey.positionKey] as? RoadGraph.Position,
+              let updatesMostProbablePath = notification.userInfo?[RoadGraph.NotificationUserInfoKey.updatesMostProbablePathKey] as? Bool else {
             return
         }
 
         let currentStreetName = streetName(for: horizonTree)
         let upcomingCrossStreet = nearestCrossStreetName(from: horizonTree)
         updateLabel(currentStreetName: currentStreetName, predictedCrossStreet: upcomingCrossStreet)
 
-        // Drawing the most probable path
-        let mostProbablePath = routeLine(from: horizonTree, roadGraph: passiveLocationManager.roadGraph)
-        updateMostProbablePath(with: mostProbablePath)
+        // Update the most probable path when the position update indicates a new most probable path (MPP).
+        if updatesMostProbablePath {
+            let mostProbablePath = routeLine(from: horizonTree, roadGraph: passiveLocationManager.roadGraph)
+            updateMostProbablePath(with: mostProbablePath)
+        }
+        
+        // Update the most probable path layer when the position update indicates
+        // a change of the fraction of the point traveled distance to the current edge’s length.
+        updateMostProbablePathLayer(fractionFromStart: position.fractionFromStart,
+                                    roadGraph: passiveLocationManager.roadGraph,
+                                    currentEdge: horizonTree.identifier)
     }
 
     private func streetName(for edge: RoadGraph.Edge) -> String? {
@@ -123,10 +143,16 @@ class ElectronicHorizonEventsViewController: UIViewController {
     private func routeLine(from edge: RoadGraph.Edge, roadGraph: RoadGraph) -> [LocationCoordinate2D] {
         var coordinates = [LocationCoordinate2D]()
         var edge: RoadGraph.Edge? = edge
+        totalDistance = 0.0
+        
+        // Update the route line shape and total distance of the most propable path.
         while let currentEdge = edge {
             if let shape = roadGraph.edgeShape(edgeIdentifier: currentEdge.identifier) {
                 coordinates.append(contentsOf: shape.coordinates.dropFirst(coordinates.isEmpty ? 0 : 1))
             }
+            if let distance = roadGraph.edgeMetadata(edgeIdentifier: currentEdge.identifier)?.length {
+                totalDistance += distance
+            }
             edge = currentEdge.outletEdges.max(by: { $0.probability < $1.probability })
         }
         return coordinates
@@ -138,9 +164,22 @@ class ElectronicHorizonEventsViewController: UIViewController {
                                                                            geoJSON: .feature(feature))
     }
 
+    private func updateMostProbablePathLayer(fractionFromStart: Double,
+                                             roadGraph: RoadGraph,
+                                             currentEdge: RoadGraph.Edge.Identifier) {
+        // Based on the length of current edge and the total distance of the most propable path (MPP),
+        // calculate the fraction of the point traveled distance to the whole most propable path (MPP).
+        if totalDistance > 0.0,
+           let currentLength = roadGraph.edgeMetadata(edgeIdentifier: currentEdge)?.length {
+            let fraction = fractionFromStart * currentLength / totalDistance
+            updateMostProbablePathLayerFraction(fraction)
+        }
+    }
+    
     private func setupMostProbablePathStyle() {
         var source = GeoJSONSource()
         source.data = .geometry(Geometry.lineString(LineString([])))
+        source.lineMetrics = true
         try? navigationMapView.mapView.mapboxMap.style.addSource(source, id: sourceIdentifier)
 
         var layer = LineLayer(id: layerIdentifier)
@@ -152,10 +191,31 @@ class ElectronicHorizonEventsViewController: UIViewController {
                 RouteLineWidthByZoomLevel.mapValues { $0 * 0.5 }
             }
         )
-        layer.lineColor = .constant(.init(UIColor.green.withAlphaComponent(0.9)))
+        layer.lineColor = .constant(.init(routeLineColor))
         layer.lineCap = .constant(.round)
         layer.lineJoin = .constant(.miter)
         layer.minZoom = 9
         try? navigationMapView.mapView.mapboxMap.style.addLayer(layer)
     }
+    
+    // Update the line gradient property of the most probable path line layer,
+    // so the part of the most probable path that has been traversed will be rendered with full transparency.
+    private func updateMostProbablePathLayerFraction(_ fraction: Double) {
+        let nextDown = max(fraction.nextDown, 0.0)
+        let exp = Exp(.step) {
+            Exp(.lineProgress)
+            traversedRouteColor
+            nextDown
+            traversedRouteColor
+            fraction
+            routeLineColor
+        }
+        
+        if let data = try? JSONEncoder().encode(exp.self),
+           let jsonObject = try? JSONSerialization.jsonObject(with: data, options: []) {
+            try? navigationMapView.mapView.mapboxMap.style.setLayerProperty(for: layerIdentifier,
+                                                                            property: "line-gradient",
+                                                                            value: jsonObject)
+        }
+    }
 }