Holen Radius Der Sichtbaren Karte in Android

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

Aus der map reference, Holen Sie sich die Projection durch getProjection(). Und,

Projektion wird verwendet, um zu übersetzen, zwischen auf dem Bildschirm Standort-und geographische Koordinaten..

Also aus der Projektion, können wir die getVisibleRegion(), und um die VisibleRegion der Karte, die enthält eine LatLngBounds, das ist eine Klasse, die enthält 2 LatLng Variablen, eine für die Nordost-Ecke der gebundenen und eine für die Südwest-Ecke.

Also der code sollte 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 das ich zu naiv war, da nur die NE-und SW kann dieses problem lösen, aber nur unter dem speziellen Fall, in dem Benutzer nicht drehen der Karte oder tilt-up für die 3D-Karte.

Also statt, Sie können nur greifen die VisibleRegion vorgesehen, die 4 Variablen, farRight, farLeft, nearRight, nearLeft, repräsentieren jeweils 4 conners von der Gegend.

Dann können wir berechnen Sie die Breite und Höhe der Fläche, für die 4 Punkte und Holen die kleineren (naja, irgendwann Breite kann größer sein als die Höhe, denke ich.)

Für die Berechnung können wir verwenden nur die Location.distanceBetween(x1,y1,x2,y2,result) Funktion...

was macht der code wie folgt Aussehen:

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

Volle Fläche, auch die Ecken!

Glaube ich nicht, siehe andere Antworten decken den gesamten anzeigen Bereich;

siehe das Bild unten, um es zu testen, ich zeichnete einen Kreis overlay zu sehen, die Grenzen des berechneten radius, es deckt nicht die gesamten anzeigen Bereich.

meine Modifikation ist ganz einfach, ich habe Den Satz des Pythagoras zu finden, die den passenden radius enthalten die Karte "Rechteck".

private double getMapVisibleRadius() {
    VisibleRegion visibleRegion = googleMap.getProjection().getVisibleRegion();

    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;

    Location.distanceBetween(
            (farLeft.latitude + nearLeft.latitude) / 2,
            farLeft.longitude,
            (farRight.latitude + nearRight.latitude) / 2,
            farRight.longitude,
            distanceWidth
    );

    Location.distanceBetween(
            farRight.latitude,
            (farRight.longitude + farLeft.longitude) / 2,
            nearRight.latitude,
            (nearRight.longitude + nearLeft.longitude) / 2,
            distanceHeight
    );

    double radiusInMeters = Math.sqrt(Math.pow(distanceWidth[0], 2) + Math.pow(distanceHeight[0], 2)) / 2;
    return radiusInMeters;
}

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

=-=-=-=-=-=-=

Ich denke, die Antwort wäre: ja, Sie können.

Entsprechend der Dokumentation, können Sie berechnen Abstand zwischen 2 Punkten durch: computeDistanceBetween(LatLngFrom, LatLngTo)

Ebenfalls erhalten Sie die Grenze von der Karte, indem Sie mit getBounds() - Methode, die in der google.maps.Map-Klasse.