Dessin d'itinéraire entre deux emplacements sur GMSMapView sous iOS
Je développe une application iOS. Dans cette application, je vais avoir 2 champs de et à. J'ai saisi l'adresse à l'aide de Google Auto Complete API. Je peux également obtenir le Latitude et Longitude des 2 emplacements et pouvoir afficher des marqueurs sur la GMSMapView.
Maintenant, je veux tracer une route entre ces 2 lieux. J'ai trouvé une solution lorsque nous utilisons MKMapView. Mais j’ai été incapable de trouver la solution pour GMSMapView. aidez-moi s'il vous plaît à tracer la route entre ces 2 points en GMSMapView.
Si possible, donnez-moi des liens importants pour cela.
Merci.
`first get all points coordinates which are coming in route then add these points latitude and longitude in path in will draw path according to that`
GMSCameraPosition *cameraPosition=[GMSCameraPosition cameraWithLatitude:18.5203 longitude:73.8567 zoom:12];
_mapView =[GMSMapView mapWithFrame:CGRectZero camera:cameraPosition];
_mapView.myLocationEnabled=YES;
GMSMarker *marker=[[GMSMarker alloc]init];
marker.position=CLLocationCoordinate2DMake(18.5203, 73.8567);
marker.icon=[UIImage imageNamed:@"aaa.png"] ;
marker.groundAnchor=CGPointMake(0.5,0.5);
marker.map=_mapView;
GMSMutablePath *path = [GMSMutablePath path];
[path addCoordinate:CLLocationCoordinate2DMake(@(18.520).doubleValue,@(73.856).doubleValue)];
[path addCoordinate:CLLocationCoordinate2DMake(@(16.7).doubleValue,@(73.8567).doubleValue)];
GMSPolyline *rectangle = [GMSPolyline polylineWithPath:path];
rectangle.strokeWidth = 2.f;
rectangle.map = _mapView;
self.view=_mapView;
J'ai écrit le code suivant qui devrait faire l'affaire pour vous:
- (void)drawRoute
{
[self fetchPolylineWithOrigin:myOrigin destination:myDestination completionHandler:^(GMSPolyline *polyline)
{
if(polyline)
polyline.map = self.myMap;
}];
}
- (void)fetchPolylineWithOrigin:(CLLocation *)Origin destination:(CLLocation *)destination completionHandler:(void (^)(GMSPolyline *))completionHandler
{
NSString *originString = [NSString stringWithFormat:@"%f,%f", Origin.coordinate.latitude, Origin.coordinate.longitude];
NSString *destinationString = [NSString stringWithFormat:@"%f,%f", destination.coordinate.latitude, destination.coordinate.longitude];
NSString *directionsAPI = @"https://maps.googleapis.com/maps/api/directions/json?";
NSString *directionsUrlString = [NSString stringWithFormat:@"%@&Origin=%@&destination=%@&mode=driving", directionsAPI, originString, destinationString];
NSURL *directionsUrl = [NSURL URLWithString:directionsUrlString];
NSURLSessionDataTask *fetchDirectionsTask = [[NSURLSession sharedSession] dataTaskWithURL:directionsUrl completionHandler:
^(NSData *data, NSURLResponse *response, NSError *error)
{
NSDictionary *json = [NSJSONSerialization JSONObjectWithData:data options:kNilOptions error:&error];
if(error)
{
if(completionHandler)
completionHandler(nil);
return;
}
NSArray *routesArray = [json objectForKey:@"routes"];
GMSPolyline *polyline = nil;
if ([routesArray count] > 0)
{
NSDictionary *routeDict = [routesArray objectAtIndex:0];
NSDictionary *routeOverviewPolyline = [routeDict objectForKey:@"overview_polyline"];
NSString *points = [routeOverviewPolyline objectForKey:@"points"];
GMSPath *path = [GMSPath pathFromEncodedPath:points];
polyline = [GMSPolyline polylineWithPath:path];
}
// run completionHandler on main thread
dispatch_sync(dispatch_get_main_queue(), ^{
if(completionHandler)
completionHandler(polyline);
});
}];
[fetchDirectionsTask resume];
}
Pour que Swift 3 dessine une polyligne
func getPolylineRoute(from source: CLLocationCoordinate2D, to destination: CLLocationCoordinate2D){
let config = URLSessionConfiguration.default
let session = URLSession(configuration: config)
let url = URL(string: "https://maps.googleapis.com/maps/api/directions/json?origin=\(source.latitude),\(source.longitude)&destination=\(destination.latitude),\(destination.longitude)&sensor=true&mode=driving&key=YOURKEY")!
let task = session.dataTask(with: url, completionHandler: {
(data, response, error) in
if error != nil {
print(error!.localizedDescription)
self.activityIndicator.stopAnimating()
}
else {
do {
if let json : [String:Any] = try JSONSerialization.jsonObject(with: data!, options: .allowFragments) as? [String: Any]{
guard let routes = json["routes"] as? NSArray else {
DispatchQueue.main.async {
self.activityIndicator.stopAnimating()
}
return
}
if (routes.count > 0) {
let overview_polyline = routes[0] as? NSDictionary
let dictPolyline = overview_polyline?["overview_polyline"] as? NSDictionary
let points = dictPolyline?.object(forKey: "points") as? String
self.showPath(polyStr: points!)
DispatchQueue.main.async {
self.activityIndicator.stopAnimating()
let bounds = GMSCoordinateBounds(coordinate: source, coordinate: destination)
let update = GMSCameraUpdate.fit(bounds, with: UIEdgeInsetsMake(170, 30, 30, 30))
self.mapView!.moveCamera(update)
}
}
else {
DispatchQueue.main.async {
self.activityIndicator.stopAnimating()
}
}
}
}
catch {
print("error in JSONSerialization")
DispatchQueue.main.async {
self.activityIndicator.stopAnimating()
}
}
}
})
task.resume()
}
func showPath(polyStr :String){
let path = GMSPath(fromEncodedPath: polyStr)
let polyline = GMSPolyline(path: path)
polyline.strokeWidth = 3.0
polyline.strokeColor = UIColor.red
polyline.map = mapView // Your map view
}
Remarque: vous devez mettre la clé de l'API googleDirection dans l'URL.
Si quelqu'un recherche Swift 3.0 pour la réponse de @ Tarek, vous pouvez l'utiliser. Ceci utilise également Alamofire et SwiftyJSON .
func drawPath()
{
let Origin = "\(currentLocation.latitude),\(currentLocation.longitude)"
let destination = "\(destinationLoc.latitude),\(destinationLoc.longitude)"
let url = "https://maps.googleapis.com/maps/api/directions/json?origin=\(Origin)&destination=\(destination)&mode=driving&key=YOURKEY"
Alamofire.request(url).responseJSON { response in
print(response.request) // original URL request
print(response.response) // HTTP URL response
print(response.data) // server data
print(response.result) // result of response serialization
let json = JSON(data: response.data!)
let routes = json["routes"].arrayValue
for route in routes
{
let routeOverviewPolyline = route["overview_polyline"].dictionary
let points = routeOverviewPolyline?["points"]?.stringValue
let path = GMSPath.init(fromEncodedPath: points!)
let polyline = GMSPolyline.init(path: path)
polyline.map = self.mapView
}
}
}
Voici une traduction rapide de la réponse de John Kumar.
let cameraPositionCoordinates = CLLocationCoordinate2D(latitude: 18.5203, longitude: 73.8567)
let cameraPosition = GMSCameraPosition.cameraWithTarget(cameraPositionCoordinates, zoom: 12)
let mapView = GMSMapView.mapWithFrame(CGRectZero, camera: cameraPosition)
mapView.myLocationEnabled = true
let marker = GMSMarker()
marker.position = CLLocationCoordinate2DMake(18.5203, 73.8567)
marker.groundAnchor = CGPointMake(0.5, 0.5)
marker.map = mapView
let path = GMSMutablePath()
path.addCoordinate(CLLocationCoordinate2DMake(18.520, 73.856))
path.addCoordinate(CLLocationCoordinate2DMake(16.7, 73.8567))
let rectangle = GMSPolyline(path: path)
rectangle.strokeWidth = 2.0
rectangle.map = mapView
self.view = mapView
Je l'ai fait avec AlamoFire et SwiftyJson dans xCode 8.3.3 et Swift 3.1 . Mettez le dessin du chemin dans une fonction qui nécessite seulement deux paramètres
un exemple d’origine de chaîne "48.7788,9.22222" et un exemple de destination de chaîne "49.3212232,8.334151"
func drawPath (Origin: String, destination: String) {
/* set the parameters needed */
String prefTravel = "walking" /* options are driving, walking, bicycling */
String gmapKey = "Ask Google"
/* Make the url */
let url = URL(string: "https://maps.googleapis.com/maps/api/directions/json?origin=\(Origin)&destination=\(destination)&mode=\(prefTravel)&key=" + gmapKey)
/* Fire the request */
Alamofire.request(url!).responseJSON{(responseData) -> Void in
if((responseData.result.value) != nil) {
/* read the result value */
let swiftyJsonVar = JSON(responseData.result.value!)
/* only get the routes object */
if let resData = swiftyJsonVar["routes"].arrayObject {
let routes = resData as! [[String: AnyObject]]
/* loop the routes */
if routes.count > 0 {
for rts in routes {
/* get the point */
let overViewPolyLine = rts["overview_polyline"]?["points"]
let path = GMSMutablePath(fromEncodedPath: overViewPolyLine as! String)
/* set up poly line */
let polyline = GMSPolyline.init(path: path)
polyline.strokeWidth = 2
polyline.map = self.mapView
}
}
}
}
}
}
- Swift 3.0 & XCode 8.0 Ligne Staright :(
let cameraPosition = GMSCameraPosition.camera(withLatitude: 18.5203, longitude: 73.8567, zoom: 12)
self.mapView = GMSMapView.map(withFrame: CGRect.zero, camera: cameraPosition)
self.mapView.isMyLocationEnabled = true
let marker = GMSMarker()
marker.position = CLLocationCoordinate2DMake(18.5203, 73.8567)
// marker.icon = UIImage(named: "aaa.png")!
marker.groundAnchor = CGPoint(x: 0.5, y: 0.5)
marker.map = mapView
let path = GMSMutablePath()
path.add(CLLocationCoordinate2DMake(CDouble((18.520)), CDouble((73.856))))
path.add(CLLocationCoordinate2DMake(CDouble((16.7)), CDouble((73.8567))))
let rectangle = GMSPolyline.init(path: path)
rectangle.strokeWidth = 2.0
rectangle.map = mapView
self.view = mapView
Faites une demande d'URL à l'API Google Directions et lorsque vous recevez un fichier JSON, suivez toutes les étapes et décodez les objets de points.
Comme vous le savez, les itinéraires et les itinéraires de Google sont PAS GRATUIT et l’année dernière, Google a modifié ses prix d’appels api beaucoup! Donc, cela peut ne pas convenir à tout le monde. Donc, si vous avez toutes les coordonnées de la clé et que vous voulez simplement les relier, vous pouvez utiliser ce qui suit.
- Swift 4 Extensions
Faire un chemin avec des coordonnées:
extension GMSMutablePath {
convenience init(coordinates: [CLLocationCoordinate2D]) {
self.init()
for coordinate in coordinates {
add(coordinate)
}
}
}
Ajouter un chemin à la carte:
extension GMSMapView {
func addPath(_ path: GMSPath, strokeColor: UIColor? = nil, strokeWidth: CGFloat? = nil, geodesic: Bool? = nil, spans: [GMSStyleSpan]? = nil) {
let line = GMSPolyline(path: path)
line.strokeColor = strokeColor ?? line.strokeColor
line.strokeWidth = strokeWidth ?? line.strokeWidth
line.geodesic = geodesic ?? line.geodesic
line.spans = spans ?? line.spans
line.map = self
}
}
Usage:
let path = GMSMutablePath(coordinates: [<#Coordinates#>])
mapView.addPath(path)
- NOTE: Vous pouvez créer exactement la même ligne que Google juste une fois en utilisant des outils ou même Google, la stocker quelque part et la donner à votre client selon les besoins.
DirectionResponse de la API Google Directions Les NSLogs sont utiles pour voir avec quoi vous travaillez.
[[GMDirectionService sharedInstance] getDirectionsFrom:Origin to:destination succeeded:^(GMDirection *directionResponse) {
if ([directionResponse statusOK]){
NSLog(@"Duration : %@", [directionResponse durationHumanized]);
NSLog(@"Distance : %@", [directionResponse distanceHumanized]);
NSArray *routes = [[directionResponse directionResponse] objectForKey:@"routes"];
// NSLog(@"Route : %@", [[directionResponse directionResponse] objectForKey:@"routes"]);
GMSPath *path = [GMSPath pathFromEncodedPath:routes[0][@"overview_polyline"] [@"points"]];
GMSPolyline *polyline = [GMSPolyline polylineWithPath:path];
polyline.strokeColor = [UIColor redColor];
polyline.strokeWidth = 5.f;
polyline.map = mapView;
}
} failed:^(NSError *error) {
NSLog(@"Can't reach the server")
}];
Bonjour, Vous pouvez utiliser "LRouteController", c’est un meilleur moyen de montrer un itinéraire entre deux
[_routeController getPolyline With Locations: (Array of first and last location)]
Essayez, j'espère que cela résoudra votre problème.