Menghasilkan lokasi acak di dekat sini?

Saya mencoba membuat lokasi acak di dekat lokasi saya. Yang saya inginkan adalah membuat pasangan garis lintang / bujur secara acak di dalam lingkaran 200 meter di sekitar lokasi saya.

Ini adalah rumus yang saya buat (dengan bantuan orang-orang di StackOverFlow): (Angka acak antara -1 dan 1) * radius + (bujur lama) = bujur baru dalam radius bujur lama

(Angka acak antara -1 dan 1) * radius + (lintang lama) = lintang baru dalam radius lintang lama

Masalahnya adalah bahwa ada sesuatu yang aneh terjadi dengan implementasi saya karena semua lokasi acak terlalu dekat dengan pusat lokasi saya, tampaknya rumus tersebut tidak mencakup seluruh jari-jari.

Adakah yang tahu apa yang salah dengan formula saya?

Diedit untuk menampilkan implementasi java saat ini:

public static Location getLocation(Location location, int radius) {
    Random random = new Random();

    // Convert radius from meters to degrees
    double radiusInDegrees = radius / METERS_IN_DEGREES;

    double x0 = location.getLongitude() * 1E6;
    double y0 = location.getLatitude() * 1E6;
    double u = random.nextInt(1001) / 1000;
    double v = random.nextInt(1001) / 1000;
    double w = radiusInDegrees * Math.sqrt(u);
    double t = 2 * Math.PI * v;
    double x = w * Math.cos(t);
    double y = w * Math.sin(t);

    // Adjust the x-coordinate for the shrinking of the east-west distances
    double new_x = x / Math.cos(y0);

    // Set the adjusted location
    Location newLocation = new Location("Loc in radius");
    newLocation.setLongitude(new_x + x0);
    newLocation.setLatitude(y + y0);

    return newLocation;
}

Saya tidak yakin apa yang saya lakukan salah, karena lokasi baru dibuat di tengah laut.

Ada ide?

Ini rumit karena dua alasan: pertama, membatasi titik-titik pada lingkaran alih-alih persegi; kedua, memperhitungkan distorsi dalam perhitungan jarak.

Banyak GIS menyertakan kemampuan yang secara otomatis dan transparan menangani kedua komplikasi. Namun, tag di sini menunjukkan bahwa deskripsi algoritma-independen GIS mungkin diinginkan.

1. Untuk menghasilkan titik secara seragam, acak, dan mandiri dalam lingkaran jari-jari r di sekitar lokasi (x0, y0), mulailah dengan menghasilkan dua nilai acak seragam independen u dan v dalam interval [0, 1). (Inilah yang disediakan oleh hampir setiap generator angka acak.) Hitung

   w = r * sqrt(u)
   t = 2 * Pi * v
   x = w * cos(t) 
   y = w * sin(t)
   

   Titik acak yang diinginkan ada di lokasi (x + x0, y + y0).

2. Saat menggunakan koordinat geografis (lat, lon), maka x0 (garis bujur) dan y0 (garis lintang) akan dalam derajat tetapi r kemungkinan besar berada dalam meter (atau kaki atau mil atau pengukuran linear lainnya). Pertama, konversikan jari-jari r menjadi derajat seolah-olah Anda berada di dekat khatulistiwa. Di sini, ada sekitar 111.300 meter dalam satu derajat.

   Kedua, setelah menghasilkan x dan y seperti pada langkah (1), sesuaikan koordinat x untuk penyusutan jarak timur-barat:

   x' = x / cos(y0)

   Titik acak yang diinginkan ada di lokasi (x '+ x0, y + y0). Ini adalah prosedur perkiraan. Untuk jari-jari kecil (kurang dari beberapa ratus kilometer) yang tidak melampaui kedua kutub bumi, biasanya akan sangat akurat sehingga Anda tidak dapat mendeteksi kesalahan apa pun bahkan ketika menghasilkan puluhan ribu titik acak di sekitar masing-masing pusat (x0, y0) .

Diimplementasikan untuk Javascript:

var r = 100/111300 // = 100 meters
  , y0 = original_lat
  , x0 = original_lng
  , u = Math.random()
  , v = Math.random()
  , w = r * Math.sqrt(u)
  , t = 2 * Math.PI * v
  , x = w * Math.cos(t)
  , y1 = w * Math.sin(t)
  , x1 = x / Math.cos(y0)

newY = y0 + y1
newX = x0 + x1

Implementasi yang benar adalah:

public static void getLocation(double x0, double y0, int radius) {
    Random random = new Random();

    // Convert radius from meters to degrees
    double radiusInDegrees = radius / 111000f;

    double u = random.nextDouble();
    double v = random.nextDouble();
    double w = radiusInDegrees * Math.sqrt(u);
    double t = 2 * Math.PI * v;
    double x = w * Math.cos(t);
    double y = w * Math.sin(t);

    // Adjust the x-coordinate for the shrinking of the east-west distances
    double new_x = x / Math.cos(Math.toRadians(y0));

    double foundLongitude = new_x + x0;
    double foundLatitude = y + y0;
    System.out.println("Longitude: " + foundLongitude + "  Latitude: " + foundLatitude );
}

Saya menghapus ketergantungan pada perpustakaan eksternal untuk membuatnya lebih mudah diakses.

Jawaban yang diterima dan turunannya tidak bekerja untuk saya. Hasilnya sangat tidak akurat.

Implementasi yang benar dalam javascript:

function pointAtDistance(inputCoords, distance) {
    const result = {}
    const coords = toRadians(inputCoords)
    const sinLat =  Math.sin(coords.latitude)
    const cosLat =  Math.cos(coords.latitude)

    /* go a fixed distance in a random direction*/
    const bearing = Math.random() * TWO_PI
    const theta = distance/EARTH_RADIUS
    const sinBearing = Math.sin(bearing)
    const cosBearing =  Math.cos(bearing)
    const sinTheta = Math.sin(theta)
    const cosTheta =    Math.cos(theta)

    result.latitude = Math.asin(sinLat*cosTheta+cosLat*sinTheta*cosBearing);
    result.longitude = coords.longitude + 
        Math.atan2( sinBearing*sinTheta*cosLat, cosTheta-sinLat*Math.sin(result.latitude )
    );
    /* normalize -PI -> +PI radians (-180 - 180 deg)*/
    result.longitude = ((result.longitude+THREE_PI)%TWO_PI)-Math.PI

    return toDegrees(result)
}

function pointInCircle(coord, distance) {
    const rnd =  Math.random()
    /*use square root of random number to avoid high density at the center*/
    const randomDist = Math.sqrt(rnd) * distance
    return pointAtDistance(coord, randomDist)
}

Inti penuh di sini

Dalam jawaban yang diterima - saya menemukan bahwa titik didistribusikan dalam elips dengan lebarnya 1,5 kali tinggi (di Panama) dan 8 kali tingginya (di utara Swedia). Jika saya menghapus penyesuaian x coord dari jawaban @ whuber elips terdistorsi dengan cara lain, 8 kali lebih tinggi dari lebarnya.

Kode dalam jawaban saya didasarkan pada algoritma dari sini

Di bawah ini Anda dapat melihat dua jsfiddles yang menunjukkan masalah dengan elips peregangan

Algoritma yang benar

Algoritma terdistorsi

Dengan Python

# Testing simlation of generating random points 
from __future__ import division
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.axes_grid1 import host_subplot
import mpl_toolkits.axisartist as AA

def create_random_point(x0,y0,distance):
    """
            Utility method for simulation of the points
    """   
    r = distance/ 111300
    u = np.random.uniform(0,1)
    v = np.random.uniform(0,1)
    w = r * np.sqrt(u)
    t = 2 * np.pi * v
    x = w * np.cos(t)
    x1 = x / np.cos(y0)
    y = w * np.sin(t)
    return (x0+x1, y0 +y)

fig = plt.figure()
ax = host_subplot(111, axes_class=AA.Axes)

#ax.set_ylim(76,78)
#ax.set_xlim(13,13.1)
ax.set_autoscale_on(True)

latitude1,longitude1 = 13.04738626,77.61946793  
ax.plot(latitude1,longitude1,'ro')

for i in range(1,20):
    x,y = create_random_point(latitude1,longitude1 ,500 )
    ax.plot(x,y,'bo')
    dist = haversine(x,y,latitude1,longitude1)
    print "Distance between points is " ,dist    # a value approxiamtely less than 500 meters   


plt.show()

Keluaran

Jarak antara titik adalah 0.288044147914 Jarak antara titik adalah 0.409557451806 Jarak antara titik adalah 0.368260305716 Jarak antara titik adalah 0.340720560546 Jarak antara titik adalah 0.453773334731 Jarak antara titik adalah 0.460608754561 Jarak antara titik adalah 0.497188825576 Jarak antara titik adalah 0.497188825576 Jarak antara titik adalah 0.497188825576. Jarak antara titik adalah 0.503691568896 Jarak antara titik adalah 0.175153349209 Jarak antara titik adalah 0.195149463735 Jarak antara titik adalah 0.424094009858 Jarak antara titik adalah 0.286807741494 Jarak antara titik adalah 0.558049206307 Jarak antara titik adalah 0.498612171417 Jarak antara titik adalah 0.498612171417 Jarak antara titik adalah 0.498612171417

Anda dapat memeriksa hasil perhitungan Anda di sini . Gulir ke bawah ke bagian yang disebut "Titik tujuan diberi jarak dan bantalan dari titik awal". Bahkan ada formula JavaScript sederhana di bagian bawah untuk mengimplementasikannya. Anda masih perlu menghasilkan bantalan acak $ \ theta $ dalam radian (diukur searah jarum jam dari utara), meskipun itu harus cukup lurus ke depan. Rumus-rumus ini mengasumsikan bumi bulat (meskipun berbentuk ellipsoidal), yang cukup baik karena menghasilkan kesalahan hingga 0,3%.

Implementasi untuk Swift

Dapatkan lat dan lng dari geoencoder dan meneruskannya ke fungsi ini

func generateRandomLocation(lat: CLLocationDegrees, lng: CLLocationDegrees){
    let radius : Double = 100000 // this is in meters so 100 KM
    let radiusInDegrees: Double = radius / 111000
    let u : Double = Double(arc4random_uniform(100)) / 100.0
    let v : Double = Double(arc4random_uniform(100)) / 100.0
    let w : Double = radiusInDegrees * u.squareRoot()
    let t : Double = 2 * Double.pi * v
    let x : Double = w * cos(t)
    let y : Double = w * sin(t)

    // Adjust the x-coordinate for the shrinking of the east-west distances
    //in cos converting degree to radian
    let new_x : Double = x / cos(lat * .pi / 180 )

    processedLat = new_x + lat
    processedLng = y + lng

    print("The Lat are :- ")
    print(processedLat)
    print("The Lng are :- ")
    print(processedLng)
}

Dalam contoh saya di atas saya mendapatkan garis lintang dan garis bujur dari geoencoding nama negara, karena setiap kali, nama negara memberikan garis lintang dan garis bujur yang sama, yang juga di tengah negara, jadi saya perlu keacakan.

private void drawPolyline (lat ganda, lng ganda) {

         double Pi=Math.PI;

         double lt=lat;
         double ln=lng;

        //Earth’s radius, sphere
         double R=6378137;

         double dn = 50;
         double de = 50;

         //Coordinate offsets in radians
         double dLat = dn/R;
         double dLon = de/(R*Math.cos(Pi*lat/180));

        //OffsetPosition, decimal degrees
        double lat2 = lt + dLat * 180/Pi;
        double lon2 = ln + dLon * 180/Pi ;



            //12.987859, 80.231038
            //12.987954, 80.231252

        double lat3 = lt - dLat * 180/Pi;
        double lon3 = ln - dLon * 180/Pi ;

            LatLng origin=new LatLng(lt, lon3);

            LatLng dest=new LatLng(lt, lon2);




          Polyline line = googleMap.addPolyline(new PolylineOptions()
         .add(origin, dest)
         .width(6)
         .color(Color.RED));