Skip to content

Look at points behind user for snapping #475

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
bsudekum merged 2 commits into from
Aug 10, 2017
Merged

Look at points behind user for snapping #475

Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
54f185a
Look at points behind user for snapping
Aug 9, 2017
f81b0c7
Improve name
Aug 10, 2017
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
35 changes: 18 additions & 17 deletions MapboxCoreNavigation/RouteController.swift
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -256,31 +256,32 @@ open class RouteController: NSObject {
}

let nearByCoordinates = routeProgress.currentLegProgress.nearbyCoordinates
guard let closest = closestCoordinate(on: nearByCoordinates, to: location.coordinate) else { return location }
let slicedLine = polyline(along: nearByCoordinates, from: closest.coordinate, to: nearByCoordinates.last)
let userDistanceBuffer = location.speed * RouteControllerDeadReckoningTimeInterval

// Get closest point infront of user
guard let pointOneSliced = coordinate(at: userDistanceBuffer, fromStartOf: slicedLine) else { return location }
guard let pointOneClosest = closestCoordinate(on: nearByCoordinates, to: pointOneSliced) else { return location }
guard let pointTwoSliced = coordinate(at: userDistanceBuffer * 2, fromStartOf: slicedLine) else { return location }
guard let pointTwoClosest = closestCoordinate(on: nearByCoordinates, to: pointTwoSliced) else { return location }
guard let closest = closestCoordinate(on: nearByCoordinates, to: location.coordinate) else { return nil }

let slicedLineBehind = polyline(along: nearByCoordinates.reversed(), from: closest.coordinate, to: nearByCoordinates.reversed().last)
let slicedLineInfront = polyline(along: nearByCoordinates, from: closest.coordinate, to: nearByCoordinates.last)
let userDistanceBuffer: CLLocationDistance = location.speed * RouteControllerDeadReckoningTimeInterval / 2

guard let pointBehind = coordinate(at: userDistanceBuffer, fromStartOf: slicedLineBehind) else { return nil }
guard let pointBehindClosest = closestCoordinate(on: nearByCoordinates, to: pointBehind) else { return nil }
guard let pointAhead = coordinate(at: userDistanceBuffer, fromStartOf: slicedLineInfront) else { return nil }
guard let pointAheadClosest = closestCoordinate(on: nearByCoordinates, to: pointAhead) else { return nil }

// Get direction of these points
let pointOneDirection = closest.coordinate.direction(to: pointOneClosest.coordinate)
let pointTwoDirection = closest.coordinate.direction(to: pointTwoClosest.coordinate)
let wrappedPointOne = wrap(pointOneDirection, min: -180, max: 180)
let wrappedPointTwo = wrap(pointTwoDirection, min: -180, max: 180)
let pointBehindDirection = pointBehindClosest.coordinate.direction(to: closest.coordinate)
let pointAheadDirection = closest.coordinate.direction(to: pointAheadClosest.coordinate)
let wrappedPointBehind = wrap(pointBehindDirection, min: -180, max: 180)
let wrappedPointAhead = wrap(pointAheadDirection, min: -180, max: 180)
let wrappedCourse = wrap(location.course, min: -180, max: 180)
let relativeAnglepointOne = wrap(wrappedPointOne - wrappedCourse, min: -180, max: 180)
let relativeAnglepointTwo = wrap(wrappedPointTwo - wrappedCourse, min: -180, max: 180)
let averageRelativeAngle = (relativeAnglepointOne + relativeAnglepointTwo) / 2
let relativeAnglepointBehind = wrap(wrappedPointBehind - wrappedCourse, min: -180, max: 180)
let relativeAnglepointAhead = wrap(wrappedPointAhead - wrappedCourse, min: -180, max: 180)
let averageRelativeAngle = (relativeAnglepointBehind + relativeAnglepointAhead) / 2
let absoluteDirection = wrap(wrappedCourse + averageRelativeAngle, min: 0 , max: 360)

// If the course is inaccurate and the user is on the route,
// calculate a rough estimate as to what the course should be at that point on the route.
if location.course <= 0 && snappedCoordinate.distance < RouteControllerUserLocationSnappingDistance {
let calculatedCourse = wrap((wrappedPointOne + wrappedPointTwo) / 2, min: 0 , max: 360)
let calculatedCourse = wrap((wrappedPointBehind + wrappedPointAhead) / 2, min: 0 , max: 360)
return CLLocation(coordinate: snappedCoordinate.coordinate, altitude: location.altitude, horizontalAccuracy: location.horizontalAccuracy, verticalAccuracy: location.verticalAccuracy, course: calculatedCourse, speed: location.speed, timestamp: location.timestamp)
}

Expand Down