Get Radius der sichtbaren Karte in Android

Question

Gibt es eine Möglichkeit, Radius der sichtbaren Karte vom Mittelpunkt zu finden?

Ich mag die in der Nähe von Orten gegen den Mittelpunkt der Karte von einem API zu bekommen, und das API erfordern lat, lng und Radius. Ich bin in der Lage, lat und lng vom Mittelpunkt zu bekommen, konnte aber keinen Weg finden, Radius zu bekommen.

dank

Answer 1

Für die Google Maps Android API können Sie die Grenzen von ...

Von der Karte Referenz erhalten, die getProjection()Projection durch bekommen. Und

ein Vorsprung verwendet, um zwischen auf dem Bildschirm Lage und geographische Koordinaten zu übersetzen ..

So von der Projektion, können wir die getVisibleRegion() verwenden und die VisibleRegion der Karte zu bekommen, das enthält eine LatLngBounds, die eine Klasse ist, die 2 LatLng Variablen enthält, eine für die nordöstliche Ecke der Grenze und eine für die südwestliche Ecke.

So sollte der Code wie folgt aussehen:

 googleMap.setOnCameraChangeListener(new GoogleMap.OnCameraChangeListener() { 
      @Override 
      public void onCameraChange(CameraPosition position) { 
       LatLngBounds bounds = googleMap.getProjection().getVisibleRegion().latLngBounds; 
       LatLng northeast = bounds.northeast; 
       LatLng southwest = bounds.southwest; 

       Context context = getApplicationContext(); 
       CharSequence text = "ne:"+northeast+" sw:"+southwest; 
       int duration = Toast.LENGTH_SHORT; 

       Toast toast = Toast.makeText(context, text, duration); 
       toast.show(); 
      } 
     }); 

= - = - = - = - = - = edit:

Kann sein, ich zu naiv war nur die NE gegeben und SW kann dieses Problem lösen, aber nur in dem speziellen Fall, in dem der Benutzer die Karte nicht gedreht oder für die 3D-Karte hochgeklappt hat.

Stattdessen können Sie einfach greifen die VisibleRegion, die 4 Variable zur Verfügung stellte, farRight, farLeft, nearRight, nearLeft, jeweils 4 Connecers des Gebiets.

Dann können wir die Breite und Höhe des Bereichs für diese 4 Punkte berechnen und die kleineren wählen (na ja, irgendwann kann Breite größer sein als die Höhe denke ich.)

Und für die Berechnung, können wir nur Verwenden Sie die Location.distanceBetween(x1,y1,x2,y2,result) Funktion ...

, die den Code wie folgt aussehen macht:

   VisibleRegion visibleRegion = googleMap.getProjection().getVisibleRegion(); 

       LatLng farRight = visibleRegion.farRight; 
       LatLng farLeft = visibleRegion.farLeft; 
       LatLng nearRight = visibleRegion.nearRight; 
       LatLng nearLeft = visibleRegion.nearLeft; 

       float[] distanceWidth = new float[2]; 
       Location.distanceBetween(
         (farRight.latitude+nearRight.latitude)/2, 
         (farRight.longitude+nearRight.longitude)/2, 
         (farLeft.latitude+nearLeft.latitude)/2, 
         (farLeft.longitude+nearLeft.longitude)/2, 
         distanceWidth 
         ); 


       float[] distanceHeight = new float[2]; 
       Location.distanceBetween(
         (farRight.latitude+nearRight.latitude)/2, 
         (farRight.longitude+nearRight.longitude)/2, 
         (farLeft.latitude+nearLeft.latitude)/2, 
         (farLeft.longitude+nearLeft.longitude)/2, 
         distanceHeight 
       ); 

       float distance; 

       if (distanceWidth[0]>distanceHeight[0]){ 
        distance = distanceWidth[0]; 
       } else { 
        distance = distanceHeight[0]; 
       } 

Answer 2

edit: Die folgende Antwort ist für Google Maps JavaScript API v3
= - = - = - = - = - = - =

Ich denke, die Antwort wäre: Ja, Sie kann.

Nach dem documentation können Sie Abstand zwischen zwei Punkten berechnen nach: computeDistanceBetween(LatLngFrom, LatLngTo)

Sie können auch die Grenze der Karte erhalten, indem getBounds() Methode, die in der google.maps.Map class ist.

Answer 3

Sie so viel Dank für Ihre Antwort @kaho, es hat mir geholfen, eine Menge (auch Sie die distanceWidth und distanceHeight auf die gleiche Weise berechnet).

Allerdings möchte ich nur ein wenig klären und verbessern. (Bitte entspannen Sie, es kann leicht verwirren: 3).

Denn:

• farLeft LatLng Objekt, das die hinteren linken Ecke der Kamera definiert.

• farRight LatLng Objekt, das der Kamera die hintere rechte Ecke definiert.

• nearLeft LatLng Objekt, das die untere linke Ecke der Kamera definiert.

• nearRight LatLng Objekt, das die untere rechte Ecke der Kamera definiert.

Es gibt einige Felder von visible die gleichen Werte enthalten:

• farLeft.longitude == nearLeft.longitude
• farRight.longitude == nearRight.longitude
• farLeft.latitude == farRight.Latitude
• nearLeft.latitude == nearRight.latitude

So können wir eine Berechnung reduzieren:

private double calculateVisibleRadius(VisibleRegion visibleRegion) { 
     float[] distanceWidth = new float[1]; 
     float[] distanceHeight = new float[1]; 

     LatLng farRight = visibleRegion.farRight; 
     LatLng farLeft = visibleRegion.farLeft; 
     LatLng nearRight = visibleRegion.nearRight; 
     LatLng nearLeft = visibleRegion.nearLeft; 

     //calculate the distance width (left <-> right of map on screen) 
     Location.distanceBetween(
       (farLeft.latitude + nearLeft.latitude)/2, 
       farLeft.longitude, 
       (farRight.latitude + nearRight.latitude)/2, 
       farRight.longitude, 
       distanceWidth 
     ); 

     //calculate the distance height (top <-> bottom of map on screen) 
     Location.distanceBetween(
       farRight.latitude, 
       (farRight.longitude + farLeft.longitude)/2, 
       nearRight.latitude, 
       (nearRight.longitude + nearLeft.longitude)/2, 
       distanceHeight 
     ); 

     //visible radius is (smaller distance)/2: 
     return (distanceWidth[0] < distanceHeight[0]) ? distanceWidth[0]/2 : distanceHeight[0]/2; 
    } 

Dann:

VisibleRegion visibleRegion = googleMap.getProjection().getVisibleRegion(); 
double visibleRadius = calculateVisibleRadius(visibleRegion);