Ottieni il raggio della mappa visibile in Android

Question

Esiste un modo per trovare il raggio della mappa visibile dal punto centrale?

voglio ottenere i posti vicino contro il punto centrale della mappa da un API, e che richiedono API lat, lng e raggio. Sono in grado di ottenere lat e lng dal punto centrale ma non riesco a trovare un modo per ottenere il raggio.

grazie

Answer 1

Per l'API di Google Maps di Android, è possibile ottenere i limiti di ...

dal riferimento mappa, ottenere il Projection da getProjection(). E,

una proiezione viene utilizzato per tradurre tra sul posto schermo e le coordinate geografiche ..

Così dalla proiezione, possiamo usare il getVisibleRegion(), e per ottenere il VisibleRegion della mappa, che contiene un LatLngBounds, che è una classe che contiene 2 variabili LatLng, una per l'angolo nord-est del limite e una per l'angolo sud-ovest.

Così il codice dovrebbe essere simile a questa:

 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:

può essere ero troppo ingenuo, dato solo il NE e Il SW può risolvere questo problema, ma solo nel caso particolare in cui l'utente non ha ruotato la mappa o si inclina verso l'alto per la mappa 3D.

Quindi, invece, è possibile afferrare lo VisibleRegion, che ha fornito 4 variabili, lontanoDiLight, lontanoLeft, nearRight, nearLeft, ognuno dei quali rappresenta 4 connessioni dell'area.

Poi possiamo calcolare la larghezza e l'altezza della zona per che i 4 punti e scegliere quello più piccolo (o meglio, a volte la larghezza può essere maggiore dell'altezza suppongo.)

e per il calcolo, possiamo solo usa la funzione Location.distanceBetween(x1,y1,x2,y2,result) ...

che rende il codice simile al seguente:

   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: La risposta che segue è per Google Maps API JavaScript v3
= - = - = - = - = - = - =

Penso che la risposta sarebbe: Sì, può.

Secondo il documentation, è possibile calcolare la distanza tra i 2 punti: computeDistanceBetween(LatLngFrom, LatLngTo)

Inoltre è possibile ottenere il confine della mappa utilizzando getBounds() metodo, che si trova nel google.maps.Map class.

Answer 3

grazie mille per la risposta @kaho, mi ha aiutato un sacco (anche si è calcolato il distanceWidth e distanceHeight nello stesso modo).

Tuttavia, voglio solo chiarire e migliorare un po '. (Per favore rilassati, può facilmente rovinarti: 3).

Poiché:

• farLeft oggetto LatLng che definisce il all'angolo sinistro della telecamera.

• farRight oggetto LatLng che definisce l'angolo all'estrema destra della telecamera.

• nearLeft oggetto LatLng che definisce l'angolo inferiore sinistro della telecamera.

• nearRight oggetto LatLng che definisce la parte inferiore destra della telecamera.

ci sono alcuni campi di VisibleRegion contengono gli stessi valori:

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

Quindi, siamo in grado di ridurre alcuni calcoli:

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; 
    } 

Poi:

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