zoom sur une route spécifique google map
J'ai une liste de points de latitude et de longitude aléatoires et je trace un itinéraire entre eux. Ma question est de savoir comment relier cette route dans google map, j'ai fait ci-dessous la méthode utilitaire
public static void drawRouteIntoMap(final List<? extends MapHelper> position, final GoogleMap googleMap) {
/*List<MapHelper> position = new ArrayList<MapHelper>();
for (int i = lastPosition; i < maps.size(); i++) {
position.add(maps.get(i));
}*/
if (position.size() > 0 && Validator.isNotNull(googleMap)) {
googleMap.clear();
List<PolylineOptions> polylineOptionses = new ArrayList<PolylineOptions>();
PolylineOptions option = null;
Boolean lastPause = null;
for (MapHelper map : position) {
if (map.isPause()) {
if (Validator.isNull(lastPause) || !lastPause) {
option = new PolylineOptions().width(5).color(Color.rgb(255, 0, 155)).geodesic(true);
polylineOptionses.add(option);
}
option.add(new LatLng(map.getLatitude(), map.getLongitude()));
} else {
if (Validator.isNull(lastPause) || lastPause) {
option = new PolylineOptions().width(5).color(Color.rgb(0, 179, 253)).geodesic(true);
polylineOptionses.add(option);
}
option.add(new LatLng(map.getLatitude(), map.getLongitude()));
}
lastPause = map.isPause();
}
for (PolylineOptions options : polylineOptionses) {
googleMap.addPolyline(options);
}
if(Validator.isNotNull(option)){
//List<LatLng> points = option.getPoints();
final LatLngBounds.Builder mapBounds = new LatLngBounds.Builder();
googleMap.setOnMapLoadedCallback(new GoogleMap.OnMapLoadedCallback() {
@Override
public void onMapLoaded() {
LatLng startPoint = new LatLng(position.get(0).getLatitude(), position.get(0).getLongitude());
googleMap.addMarker(new MarkerOptions().position(startPoint).title("start").icon(BitmapDescriptorFactory.defaultMarker(BitmapDescriptorFactory.HUE_GREEN)));
mapBounds.include(startPoint);
LatLng endPoint = new LatLng(position.get(position.size() - 1).getLatitude(), position.get(position.size() - 1).getLongitude());
mapBounds.include(endPoint);
googleMap.addMarker(new MarkerOptions().position(endPoint).title("finish").icon(BitmapDescriptorFactory.defaultMarker(BitmapDescriptorFactory.HUE_RED)));
googleMap.moveCamera(CameraUpdateFactory.newLatLngBounds(mapBounds.build(), 10));
/* googleMap.animateCamera(CameraUpdateFactory.newLatLngBounds(mapBounds.build(), 10));
googleMap.moveCamera(CameraUpdateFactory.zoomOut());*/
}
});
}
}
}
ici la dernière pause est un booléen indiquant s'il s'agit d'un point en pause pour indiquer une polyligne de couleur rouge.
mais cela ne fonctionne pas. Toute aide est appréciée.
Essayez de mettre en œuvre de cette façon
/**
* Zooms a Route (given a List of LalLng) at the greatest possible zoom level.
*
* @param googleMap: instance of GoogleMap
* @param lstLatLngRoute: list of LatLng forming Route
*/
public void zoomRoute(GoogleMap googleMap, List<LatLng> lstLatLngRoute) {
if (googleMap == null || lstLatLngRoute == null || lstLatLngRoute.isEmpty()) return;
LatLngBounds.Builder boundsBuilder = new LatLngBounds.Builder();
for (LatLng latLngPoint : lstLatLngRoute)
boundsBuilder.include(latLngPoint);
int routePadding = 100;
LatLngBounds latLngBounds = boundsBuilder.build();
googleMap.moveCamera(CameraUpdateFactory.newLatLngBounds(latLngBounds, routePadding));
}
METTRE &AGRAVE; JOUR
Après avoir regardé l'image, il y a des dispositions au-dessus de la carte. Donc, il faudrait que vous définissiez Rembourrage variable . Vous pouvez le faire comme
googleMap.setPadding(left, top, right, bottom);
Remarque: Lors de la définition du remplissage des variables, vous pouvez initialiser routePadding = 0; . Dans votre cas, les approximations sont les suivantes: left = right = 10, bottom=100, top=200. Une fois défini, vous pouvez les calibrer selon vos besoins.
Recommendation: You can calculate the height of those (top and bottom) layouts in pixels and then set padding accordingly.
La raison pour laquelle le zoom avant ne fonctionne pas peut être parce que la carte n'a pas encore été gonflée au moment d'appeler la méthode:
moveCamera(com.google.Android.gms.maps.CameraUpdate)
Essayez d’ajouter ViewTreeObserver.OnGlobalLayoutListener à la carte:
ViewTreeObserver vto = googleMap.getViewTreeObserver();
ViewTreeObserver.OnGlobalLayoutListener globalLayoutListener = new ViewTreeObserver.OnGlobalLayoutListener() {
@Override
public void onGlobalLayout() {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
googleMap.getViewTreeObserver().removeOnGlobalLayoutListener(this);
} else {
googleMap.getViewTreeObserver().removeGlobalOnLayoutListener(this);
}
googleMap.moveCamera(CameraUpdateFactory.newLatLngBounds(mapBounds.build(), 10));
}
};
vto.addOnGlobalLayoutListener(globalLayoutListener);
Si la méthode ci-dessus ne fonctionne pas, GoogleMap a son propre écouteur pour la présentation, vous pouvez utiliser ceci:
googleMap.setOnCameraChangeListener(new OnCameraChangeListener() {
@Override
public void onCameraChange(CameraPosition arg0) {
googleMap.moveCamera(CameraUpdateFactory.newLatLngBounds(mapBounds.build(), 10));
googleMap.setOnCameraChangeListener(null);
}
});
Cependant, à partir de la version 9.4.0 de play-services-maps de l'API, la méthode ci-dessus est obsolète. Utilisez l'un des:
Vous devez inclure tous les points qui forment la polyligne dans votre objet mapBounds.
De plus, vous mettez à jour la caméra à l'aide de animateCamera, puis vous la déplacez à l'aide de moveCamera. Cette deuxième mise à jour de la caméra remplace la première. Il suffit de retirer la ligne
googleMap.moveCamera(CameraUpdateFactory.zoomOut());
Cette ligne est également innecesary (vous n'avez pas besoin de déplacer et d'animer la caméra, juste l'un d'entre eux):
googleMap.moveCamera(CameraUpdateFactory.newLatLngBounds(mapBounds.build(), 10));
Si vous devez effectuer un zoom arrière sur votre carte, vous pouvez jouer avec le paramètre de remplissage de la méthode CameraUpdateFactory.newLatLngBounds.
J'ai implémenté une solution similaire à @ rishabh-dutt-sharma avec quelques modifications:
- Tout d’abord, avant d’agrandir, vérifiez si les points sont déjà dans la vue. S'ils le sont, ne le changez pas. Cela signifie des modifications moins nécessaires dans l'interface utilisateur pour l'utilisateur.
- Deuxièmement, un cas particulier est quand il n'y a qu'un seul point. Ceci est utile lors de l'affichage d'une liste de marqueurs, et n'est peut-être pas nécessaire dans votre cas particulier. Pourquoi est-ce utile? En effet, dans le cas d’un point unique, le zoom est généralement augmenté au maximum, ce qui est généralement excessif.
Voici le code (adapté de mon code original, j'espère qu'il n'y a pas de fautes de frappe):
public void zoomRoute(GoogleMap googleMap, List<LatLng> lstLatLngRoute) {
if (googleMap == null || lstLatLngRoute == null || lstLatLngRoute.isEmpty()) return;
LatLngBounds currentLatLongBounds =
googleMap.getProjection().getVisibleRegion().latLngBounds;
boolean updateBounds = false;
for (LatLng latLng : lstLatLngRoute) {
if (!currentLatLongBounds.contains(latLng)) {
updateBounds = true;
}
}
if (updateBounds) {
CameraUpdate cameraUpdate;
if (lstLatLngRoute.size() == 1) {
LatLng latLng = lstLatLngRoute.iterator().next();
cameraUpdate = CameraUpdateFactory.newLatLng(latLng);
} else {
LatLngBounds.Builder builder = LatLngBounds.builder();
for (LatLng latLng : lstLatLngRoute) {
builder.include(latLng);
}
LatLngBounds latLongBounds = builder.build();
cameraUpdate =
CameraUpdateFactory.newLatLngBounds(latLongBounds, MAP_ZOOM_PADDING);
}
try {
googleMap.animateCamera(cameraUpdate, MAP_CAMERA_ANIMATION_DURATION_IN_MILLIS,
new GoogleMap.CancelableCallback() {
@Override
public void onFinish() {
}
@Override
public void onCancel() {
}
});
} catch (IllegalStateException ex) {
// Ignore it. We're just being a bit lazy, as this exception only happens if
// we try to animate the camera before the map has a size
}
}
}
vous pouvez faire une chose, trouver la distance entre la latitude et la longitude et vérifier la distance que vous avez obtenue. Voyez comment cela fonctionne. C'est une astuce qui pourrait vous être utile.
googleMap.moveCamera(CameraUpdateFactory.newLatLng(reachLocationLatLng));
if (dist > 2 && dist <= 5) {
googleMap.animateCamera(CameraUpdateFactory.zoomTo(13.0f));
mapZoomLevel = 12;
} else if (dist > 5 && dist <= 10) {
googleMap.animateCamera(CameraUpdateFactory.zoomTo(12.0f));
mapZoomLevel = 11;
} else if (dist > 10 && dist <= 20) {
googleMap.animateCamera(CameraUpdateFactory.zoomTo(11.0f));
mapZoomLevel = 11;
} else if (dist > 20 && dist <= 40) {
googleMap.animateCamera(CameraUpdateFactory.zoomTo(10.0f));
mapZoomLevel = 10;
} else if (dist > 40 && dist < 100) {
googleMap.animateCamera(CameraUpdateFactory.zoomTo(9.0f));
mapZoomLevel = 9;
} else if (dist > 100 && dist < 200) {
googleMap.animateCamera(CameraUpdateFactory.zoomTo(8.0f));
mapZoomLevel = 8;
} else if (dist > 200 && dist < 400) {
googleMap.animateCamera(CameraUpdateFactory.zoomTo(7.0f));
mapZoomLevel = 7;
} else if (dist > 400 && dist < 700) {
googleMap.animateCamera(CameraUpdateFactory.zoomTo(6.0f));
mapZoomLevel = 7;
} else if (dist > 700 && dist < 1000) {
googleMap.animateCamera(CameraUpdateFactory.zoomTo(5.0f));
mapZoomLevel = 6;
} else if (dist > 1000) {
googleMap.animateCamera(CameraUpdateFactory.zoomTo(4.0f));
mapZoomLevel = 5;
} else {
googleMap.animateCamera(CameraUpdateFactory.zoomTo(14.0f));
mapZoomLevel = 14;
}
Merci j'espère que cela vous aidera.
googleMap.moveCamera(CameraUpdateFactory.newLatLngZoom(endPoint,zoomLevel));
Essayez si ça vous aide
Probablement, ce serait la solution la plus simple pour le problème mentionné ci-dessus, cela a très bien fonctionné pour moi.
Ajoutez tous les points de cheminement à la cible sous GoogleMapOptions: caméra, le zoom et le centrage automatique de la carte seront alors respectés par rapport à Polyligne (Route donnée).
loadMap() {
let mapOptions: GoogleMapOptions = {
camera: {
target: this.wayPoints,
zoom: 25,
tilt: 30
}
};
this.map = GoogleMaps.create('map_canvas', mapOptions);
this.map.one(GoogleMapsEvent.MAP_READY)
.then(() => {
console.log('Map is ready!');
this.map.addPolyline({
points:this.wayPoints,
color:'#586bff',
width: 8,
geodesic:true,
});
});
}
Les points de cheminement (this.wayPoints) doivent être au format suivant:
[{lat: 52.33806, lng: 8.61179},
{lat: 52.33812, lng: 8.61185},
{lat: 52.33812, lng: 8.61186},
{lat: 52.33812, lng: 8.61188}]
C'est très tard pour répondre Essayez avec ce chemin le plus court
Tout d’abord, obtenez votre latitude actuelle, puis votre code d’écriture pour votre destination, puis calculez la distance entre votre position actuelle et la destination avec ce code.
private double distance(double lat1, double lon1, double lat2, double lon2) {
double theta = lon1 - lon2;
double dist = Math.sin(deg2rad(lat1)) * Math.sin(deg2rad(lat2)) + Math.cos(deg2rad(lat1)) * Math.cos(deg2rad(lat2)) * Math.cos(deg2rad(theta));
dist = Math.acos(dist);
dist = rad2deg(dist);
dist = dist * 60 * 1.1515;
return (dist);
}
private double deg2rad(double deg) {
return (deg * Math.PI / 180.0);
}
private double rad2deg(double rad) {
return (rad * 180.0 / Math.PI);
}
vous ne pouvez jamais obtenir les mêmes données lat long en raison du nombre GPS situé à 95 mètres de votre position actuelle pour afficher les données NIP ou lat longue de votre position actuelle. Vous devez donc obtenir une distance entre votre position actuelle et vos points de données fixes.
chaque fois que vous trouvez " distance " à partir de votre destination, pointez vers le dernier point puis déclenchez ce code pour animer l'appareil photo et zoomer.
map.moveCamera( CameraUpdateFactory.newLatLngZoom(new LatLng(xxxx,xxxx),21));
Comment je l'ai fait.
Android - tracer des coordonnées GPS sur une carte personnalisée
Oui, vous pouvez dessiner des points qui ne sont pas sur la carte visible. Contournez cela en mettant en place un LatLngBounds. Affichez ensuite la carte pour les LatLngBounds. Vous pouvez également déplacer la carte pour afficher les LatLngBounds. Il n'y a rien de délicat ici, pas de tangentes ni de pentes ni de courbure hyperbolique de la terre. Tout ce qui est pris en charge par le point qui est en degrés alors ne pensez pas trop votre solution. Si vous tournez la carte, les points vont tourner avec elle. Alors ajoutez vos points sur la carte, trouvez les limites et inclinez la caméra. Inclinez la caméra en arrière et tous les points resteront à l'écran! Cela vous permettra de commencer avec tous les points à l'écran.
Identique aux exemples, référence à une carte Google.
private void setUpMapIfNeeded() {
// Do a null check to confirm that we have not already instantiated the
// map.
if (mMap == null) {
// Try to obtain the map from the SupportMapFragment.
// mMap = mMapFragment.getMap();
// // Check if we were successful in obtaining the map.
// Try to obtain the map from the SupportMapFragment.
mMap = ((SupportMapFragment) getSupportFragmentManager()
.findFragmentById(R.id.map)).getMap();
// use the settings maptype
// Check if we were successful in obtaining the map.
if (mMap != null) {
setUpMap();
}
}
}
Commençons à trouver les limites de la carte.
import com.google.Android.gms.maps.model.LatLng;
import com.google.Android.gms.maps.model.LatLngBounds;
A field for LatLngBounds and a LatLngBounds.Builder
private LatLngBounds bounds;
private LatLngBounds.Builder myLatLngBuilder;
initialize the LatLngBounds.Builder
myLatLngBuilder = new LatLngBounds.Builder();
for each point on your map.
LatLng myLatLng = new LatLng(latitude, longitude);
myLatLngBuilder.include(myLatLng);
Then when your finished adding points build your boundary.
bounds = myLatLngBuilder.build();
Now I have the bounds of all the points on my map and I can display just that area of the map. This code I lifted from the map samples.
final View mapView = getSupportFragmentManager().findFragmentById(
R.id.map).getView();
if (mapView.getViewTreeObserver().isAlive()) {
mapView.getViewTreeObserver().addOnGlobalLayoutListener(
new OnGlobalLayoutListener() {
@SuppressWarnings("deprecation")
// We use the new method when supported
@SuppressLint("NewApi")
// We check which build version we are using.
@Override
public void onGlobalLayout() {
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN) {
mapView.getViewTreeObserver()
.removeGlobalOnLayoutListener(this);
} else {
mapView.getViewTreeObserver()
.removeOnGlobalLayoutListener(this);
}
mMap.moveCamera(CameraUpdateFactory
.newLatLngBounds(bounds, 50));
}
});
}