Berekkenje of opfreegje grutte sirkelôfstân tusken punten fan breedte en lingtegraad mei de Haversine-formule (PHP, Python, MySQL, MSSQL-foarbylden)

Haversine Formule - Grutte sirkelôfstân - PHP, Python, MySQL

Dizze moanne haw ik frijwat programmearre yn PHP en MySQL oangeande GIS. Snoekjend om it net, ik hie eins in hurde tiid om wat fan te finen Geografyske berekkeningen de ôfstân te finen tusken twa lokaasjes, dus ik woe se hjir diele.

Fleankaart Jeropa Mei Grutte Sirkelôfstân

De ienfâldige manier om in ôfstân te berekkenjen tusken twa punten is mei de Pythagoreaske formule om de hypotenuse fan in trijehoek te berekkenjen (A² + B² = C²). Dit wurdt bekend as de Euklidyske ôfstân.

Dat is in nijsgjirrige start, mar it is net fan tapassing op Geografy, om't de ôfstân tusken rigels fan breedte en lingtegraad is net gelikense ôfstannen apart. As jo ​​tichter by de evener komme, komme breedtegraad fierder útinoar. As jo ​​in soarte fan ienfâldige triangulaasje-fergeliking brûke, kin it ôfstân krekts mjitte op 'e iene lokaasje en ferskriklik ferkeard yn' e oare, fanwegen de kromming fan 'e Ierde.

Grutte sirkelôfstân

De rûtes dy't lange ôfstannen om 'e ierde wurde reizge steane bekend as de Grutte sirkelôfstân. Dat is ... de koartste ôfstân tusken twa punten op in bol is oars as de punten op in platte kaart. Kombinearje dat mei it feit dat de linen foar breedte- en lingtegraad net lykweardich binne ... en jo hawwe in drege berekkening.

Hjir is in fantastyske fideo-útlis oer hoe't Great Circles wurkje.

De Haversine Formule

De ôfstân mei de kromming fan 'e Ierde is opnaam yn' e Haversine formule, dy't trigonometry brûkt om de kromming fan 'e ierde mooglik te meitsjen. As jo ​​de ôfstân fine tusken 2 plakken op ierde (as de kraai fljocht), is in rjochte line echt in bôge.

Dit is fan tapassing op loftflecht - hawwe jo ea sjoen nei de wirklike kaart fan flechten en hawwe jo opmurken dat se bôgje? Dat komt om't it koarter is om yn in bôge te fleanen tusken twa punten dan direkt nei de lokaasje.

PHP: Berekkenje Ofstân Tusken 2 Punten fan Breedtegraad en Lingtegraad

Hjir is de PHP-formule foar it berekkenjen fan de ôfstân tusken twa punten (tegearre mei Mile vs. Kilometer-konverzje) ôfrûn op twa desimale plakken.

function getDistanceBetweenPointsNew($latitude1, $longitude1, $latitude2, $longitude2, $unit = 'miles') {
  $theta = $longitude1 - $longitude2; 
  $distance = (sin(deg2rad($latitude1)) * sin(deg2rad($latitude2))) + (cos(deg2rad($latitude1)) * cos(deg2rad($latitude2)) * cos(deg2rad($theta))); 
  $distance = acos($distance); 
  $distance = rad2deg($distance); 
  $distance = $distance * 60 * 1.1515; 
  switch($unit) { 
    case 'miles': 
      break; 
    case 'kilometers' : 
      $distance = $distance * 1.609344; 
  } 
  return (round($distance,2)); 
}

De fariabelen binne:

  • $Latitude1 - in fariabele foar de breedtegraad fan jo earste lokaasje.
  • $ Longitude 1 - in fariabele foar de lingtegraad fan jo earste lokaasje
  • $Latitude2 - in fariabele foar de breedtegraad fan jo twadde lokaasje.
  • $ Longitude 2 - in fariabele foar de lingtegraad fan jo twadde lokaasje.
  • $ienheid - it standert wêzen tûzenen. Dit kin wurde bywurke of trochjûn as kilometers.

Python: Berekkenje ôfstân tusken 2 breedte- en lingtegraadpunten

Hoe dan ek, hjir is de Python-formule foar it berekkenjen fan de ôfstân tusken twa punten (tegearre mei Mile vs. Kilometer-konverzje) ôfrûn op twa desimale plakken. Kredyt oan myn soan, Bill Karr, dy't in Data Scientist is foar OpenINSIGHTS, foar de koade.

from numpy import sin, cos, arccos, pi, round

def rad2deg(radians):
    degrees = radians * 180 / pi
    return degrees

def deg2rad(degrees):
    radians = degrees * pi / 180
    return radians

def getDistanceBetweenPointsNew(latitude1, longitude1, latitude2, longitude2, unit = 'miles'):
    
    theta = longitude1 - longitude2
    
    distance = 60 * 1.1515 * rad2deg(
        arccos(
            (sin(deg2rad(latitude1)) * sin(deg2rad(latitude2))) + 
            (cos(deg2rad(latitude1)) * cos(deg2rad(latitude2)) * cos(deg2rad(theta)))
        )
    )
    
    if unit == 'miles':
        return round(distance, 2)
    if unit == 'kilometers':
        return round(distance * 1.609344, 2)

De fariabelen binne:

  • breedtegraad 1 - in fariabele foar jo earste lokaasjes breedte.
  • lingtegraad 1 - in fariabele foar jo earste lokaasjes lingtegraad
  • breedtegraad 2 - in fariabele foar jo twadde lokaasje's breedte.
  • lingtegraad 2 - in fariabele foar jo twadde lokaasje's lingtegraad.
  • ienheid - it standert wêzen tûzenen. Dit kin wurde bywurke of trochjûn as kilometers.

MySQL: Alle records binnen in berik ophelje troch ôfstân yn milen te berekkenjen mei breedte- en lingtegraad

It is ek mooglik SQL te brûken om in berekkening te dwaan om alle records te finen binnen in spesifike ôfstân. Yn dit foarbyld sil ik MyTable opfreegje yn MySQL om alle records te finen dy't minder dan of gelyk binne oan fariabele $ ôfstân (yn Miles) nei myn lokaasje op $ breedtegraad en $ lingtegraad:

De fraach foar it opheljen fan alle records binnen in spesifyk ôfstân troch berekkenjen fan ôfstân yn milen tusken twa breedte- en breedtegraad binne:

$query = "SELECT *, (((acos(sin((".$latitude."*pi()/180)) * sin((`latitude`*pi()/180)) + cos((".$latitude."*pi()/180)) * cos((`latitude`*pi()/180)) * cos(((".$longitude."- `longitude`)*pi()/180)))) * 180/pi()) * 60 * 1.1515) as distance FROM `table` WHERE distance <= ".$distance."

Jo moatte dit oanpasse:

  • $ lingtegraad - dit is in PHP-fariabele wêr't ik de lingtegraad fan it punt trochjaan.
  • $ breedtegraad - dit is in PHP-fariabele wêr't ik de lingtegraad fan it punt trochjaan.
  • $ ôfstân - dit is de ôfstân dy't jo alle records wolle fine minder as gelyk oan.
  • table - dit is de tabel ... jo wolle dat ferfange troch jo tafelnamme.
  • breedte - dit is it fjild fan jo breedtegraad.
  • lingtegraad - dit is it fjild fan jo lingtegraad.

MySQL: Alle records binnen in berik ophelje troch ôfstân yn kilometers te berekkenjen mei breedte- en lingtegraad

En hjir is de SQL-fraach dy't kilometers brûkt yn MySQL:

$query = "SELECT *, (((acos(sin((".$latitude."*pi()/180)) * sin((`latitude`*pi()/180)) + cos((".$latitude."*pi()/180)) * cos((`latitude`*pi()/180)) * cos(((".$longitude."- `longitude`) * pi()/180)))) * 180/pi()) * 60 * 1.1515 * 1.609344) as distance FROM `table` WHERE distance <= ".$distance."

Jo moatte dit oanpasse:

  • $ lingtegraad - dit is in PHP-fariabele wêr't ik de lingtegraad fan it punt trochjaan.
  • $ breedtegraad - dit is in PHP-fariabele wêr't ik de lingtegraad fan it punt trochjaan.
  • $ ôfstân - dit is de ôfstân dy't jo alle records wolle fine minder as gelyk oan.
  • table - dit is de tabel ... jo wolle dat ferfange troch jo tafelnamme.
  • breedte - dit is it fjild fan jo breedtegraad.
  • lingtegraad - dit is it fjild fan jo lingtegraad.

Ik brûkte dizze koade yn in platfoarm foar bedriuwsmapping dat wy brûkten foar in winkel mei mear dan 1,000 lokaasjes yn Noard-Amearika en it wurke prachtich.

Microsoft SQL Server Geografyske Ofstân: STDistance

As jo ​​​​Microsoft SQL Server brûke, biede se har eigen funksje, STDistance foar it berekkenjen fan de ôfstân tusken twa punten mei it gegevenstype Geografy.

DECLARE @g geography;  
DECLARE @h geography;  
SET @g = geography::STGeomFromText('LINESTRING(-122.360 47.656, -122.343 47.656)', 4326);  
SET @h = geography::STGeomFromText('POINT(-122.34900 47.65100)', 4326);  
SELECT @g.STDistance(@h);  

Hat tip oan Manash Sahoo, VP en Arsjitekt fan Highbridge.

77 Comments

  1. 1

    Tige tank foar it dielen. Dit wie in maklike taak foar kopiearje en plakke en wurket geweldich. Jo hawwe my in protte tiid bewarre.
    FYI foar elkenien dy't porteart nei C:
    dûbele deg2rad(dûbele deg) { return deg*(3.14159265358979323846/180.0); }

  2. 2

    Hiel moai stikje post - wurke hiel moai - ik moast allinnich feroarje de namme fan 'e tafel holding de lat-long. It wurket frij fluch om .. Ik haw in ridlik lyts oantal lat-longs (< 400), mar ik tink dat dit soe skaal moai. Moaie side ek - ik haw it krekt tafoege oan myn del.icio.us-akkount en sil regelmjittich kontrolearje.

  3. 4
  4. 5

    Ik socht de hiele dei foar ôfstânsberekkeningen en fûn it harversine-algoritme, tank oan jo foar it jaan fan it foarbyld oer hoe't jo it yn in sql-statement sette. Tank en groetnis, Daniel

  5. 8

    ik tink dat jo SQL moat in hawwende ferklearring.
    ynstee fan WHERE ôfstân <= $ôfstân dy't jo miskien moatte
    brûk HAVING ôfstân <= $ôfstân

    oars tank foar it bewarjen fan my in boskje tiid en enerzjy.

  6. 10
  7. 11
  8. 12

    Tige tank foar it dielen fan dizze koade. It hat my in protte ûntwikkelingstiid besparre. Ek tank oan jo lêzers foar it oanjaan dat in HAVING-ferklearring nedich is foar MySQL 5.x. Tige behelpsum.

  9. 14
  10. 15
  11. 16

    Ik fûn ek dat WHERE net foar my wurke. Feroare it nei HAVING en alles wurket perfekt. Earst haw ik de opmerkingen net lêzen en it opnij skreaun mei in nestele seleksje. Beide sille gewoan goed wurkje.

  12. 17
  13. 18

    Geweldich behelpsum, tige tank! Ik hie wat problemen mei it nije "HAVING", yn stee fan "WHERE", mar doe't ik de opmerkings hjir lies (nei sawat in healoere fan frustraasje fan 'e tosken =P), krige ik it goed te wurkjen. Tankewol ^_^

  14. 19
  15. 20

    Hâld der rekken mei dat in selekteare útspraak lykas dat tige komputerysk yntinsyf wêze sil en dêrom stadich. As jo ​​​​in protte fan dy fragen hawwe, kin it dingen frij fluch ferdwine.

    In folle minder yntinsive oanpak is it útfieren fan in earste (grut) seleksje mei in SQUARE gebiet definiearre troch in berekkene ôfstân ie "selektearje * út tabelnamme dêr't breedtegraad tusken lat1 en lat2 en lingtegraad tusken lon1 en lon2". lat1 = targetlatitude - latdiff, lat2 = targetlatitude + latdiff, fergelykber mei lon. latdiff ~= ôfstân / 111 (foar km), of ôfstân/69 foar milen, om't 1 breedtegraad ~ 111 km is (lytse fariaasje, om't de ierde in bytsje ovaal is, mar genôch foar dit doel). londiff = ôfstân / (abs(cos(deg2rad(breedte))*111)) - of 69 foar milen (jo kinne eins in wat grutter fjouwerkant nimme om fariaasjes te rekkenjen). Nim dan it resultaat fan dat en fiede it yn 'e radiale seleksje. Ferjit gewoan net te rekkenjen mei koördinaten bûten grinzen - dws it berik fan akseptabele lingtegraad is -180 oant +180 en it berik fan akseptabele breedtegraad is -90 oant +90 - yn it gefal dat jo latdiff of londiff bûten dit berik rint . Tink derom dat dit yn 'e measte gefallen miskien net fan tapassing is, om't it allinich ynfloed hat op berekkeningen oer in line troch de Stille Oseaan fan poal nei poal, hoewol it in diel fan tsjoekotka en in diel fan alaska krúst.

    Wat wy berikke troch dit is in signifikante fermindering fan it oantal punten dêr't jo meitsje dizze berekkening. As jo ​​in miljoen globale punten yn 'e databank hawwe dy't rûchwei gelyk ferdield binne en jo wolle sykje binnen 100 km, dan is jo earste (snelle) sykopdracht fan in gebiet fan 10000 km² en sil wierskynlik sa'n 20 resultaten opleverje (basearre op evenredige ferdieling oer in oerflak fan sawat 500M sq km), wat betsjut dat jo de komplekse ôfstânsberekkening 20 kear útfiere foar dizze fraach ynstee fan in miljoen kear.

    • 21
      • 22

        Fantastysk advys! Ik wurke eins mei in ûntwikkelder dy't in funksje skreau dy't it binnenplein luts en dan in rekursive funksje dy't 'kwadraten' om 'e perimeter makke om de oerbleaune punten op te nimmen en út te sluten. It resultaat wie in ongelooflijk fluch resultaat - hy koe miljoenen punten yn mikrosekonden evaluearje.

        Myn oanpak hjirboppe is perfoarst 'rûd' mar kapabel. Nochris tank!

        • 23

          Doug,

          Ik haw besocht mysql en php te brûken om te evaluearjen oft in lat-lange punt binnen in polygon is. Witte jo as jo ûntwikkeldersfreon foarbylden publisearre oer hoe't jo dizze taak kinne útfiere. Of kenne jo goede foarbylden. Alfêst tank.

  16. 24

    Hoi elkenien dit is myn test SQL statement:

    SELECT DISTINCT area_id, (
    (
    (
    acos( sin( ( 13.65 * pi( ) /180 ) ) * sin( (
    `lat_dec` * pi( ) /180 ) ) + cos( ( 13.65 * pi( ) /180 ) ) * cos( (
    `lat_dec` * pi( ) /180 )
    ) * cos( (
    ( 51.02 - `lon_dec` ) * pi( ) /180 )
    )
    )
    ) *180 / pi( )
    ) *60 * 1.1515 * 1.609344
    ) AS distance
    FROM `post_codes` WHERE distance <= 50

    en Mysql fertelt my dat ôfstân, bestiet net as in kolom, ik kin folchoarder brûke, ik kin it dwaan sûnder WHERE, en it wurket, mar net mei ...

  17. 26

    Dit is geweldich, lykwols is it krekt as de fûgels fleane. It soe geweldich wêze om te besykjen en de google maps API op ien of oare manier op te nimmen (miskien mei diken ensfh.) Krekt om in idee te jaan mei in oare foarm fan ferfier. Ik noch moatte meitsje in simulearre annealing funksje yn PHP dat soe wêze kinne om te bieden in effisjinte oplossing foar de reizgjende ferkeaper probleem. Mar ik tink dat ik miskien wat fan jo koade opnij brûke kin om dit te dwaan.

  18. 27
  19. 28

    Goed artikel! Ik fûn in protte artikels dy't beskriuwe hoe't jo ôfstân tusken twa punten berekkenje, mar ik wie echt op syk nei it SQL-snippet.

  20. 29
  21. 30
  22. 31
  23. 32
  24. 36

    2 dagen fan ûndersyk om einlings dizze side te finen dy't myn probleem oplost. It liket derop dat ik better myn WolframAlpha útbrekke en myn wiskunde ophelje. De feroaring fan WHERE nei HAVING hat myn skript yn wurking. DANKEWOL

  25. 37
  26. 39

    Ik woe dat dit de earste side wie dy't ik hjir op fûn hie. Nei it besykjen fan in protte ferskillende kommando's wie dit de iennichste dy't goed wurke, en mei minimale feroarings dy't nedich binne om te passen oan myn eigen database.
    Tige dank!

  27. 40

    Ik woe dat dit de earste side wie dy't ik hjir op fûn hie. Nei it besykjen fan in protte ferskillende kommando's wie dit de iennichste dy't goed wurke, en mei minimale feroarings dy't nedich binne om te passen oan myn eigen database.
    Tige dank!

  28. 41
  29. 42
  30. 43
  31. 45
  32. 46
  33. 47

    Ik wit dat dizze formule wurket, mar ik kin net sjen wêr't de straal fan 'e ierde wurdt rekken holden. Kin immen my ferljochtsje, asjebleaft?

  34. 49
  35. 50
  36. 52
  37. 53
  38. 55
  39. 56
  40. 58

    tank foar it pleatsen fan dit nuttige artikel,  
    mar om ien of oare reden soe ik it freegje wolle
    hoe krije jo de ôfstân tusken koördinaten binnen mysql db en koördinaten ynfoege yn php troch brûker?
    foar dúdliker beskriuwe:
    1.brûker moat [id] ynfoegje foar it selektearjen fan spesifisearre gegevens fan db en de koördinaten fan 'e brûker sels
    2.it php-bestân krije de doelgegevens (koördinaten) mei [id] en berekkenje dan de ôfstân tusken brûker en doelpunt

    of kin gewoan gewoan ôfstân krije fan 'e koade hjirûnder?

    $qry = “SELECT *,(((acos(sin((“.$latitude.”*pi()/180)) * sin((`Latitude`*pi()/180))+cos((“. $latitude.”*pi()/180)) * cos((`Latitude`*pi()/180)) * cos(((“.$longitude.”- `Longitude`)*pi()/180) )))*180/pi())*60*1.1515*1.609344) as ôfstân FROM `MyTable` WHERE ôfstân >= ".$distance." >>>>kin ik de ôfstân hjirwei "útnimme"?
    nochris tank,
    Timmy S

  41. 60

    ok, alles wat ik haw besocht wurket net. Ik bedoel, wat ik haw wurket, mar de ôfstannen binne fier fuort.

    Koe immen miskien sjen wat der mis is mei dizze koade?

    if(isset($_POST['ferstjoerd'])){ $z = $_POST['postkoade']; $r = $_POST['radius']; echo "Resultaten foar ".$z; $sql = mysql_query(“SELECT DISTINCT m.zipcode, m.MktName,m.LocAddSt,m.LocAddCity,m.LocAddState,m.x1,m.y1,m.verified,z1.lat,z2.lon,z1. stêd,z1.state FROM mrk m, zip z1, zip z2 WHERE m.zipcode = z1.zipcode EN z2.zipcode = $z EN (3963 * acos( truncate( sin(z2.lat / 57.2958) * sin(m. y1 / 57.2958 ) + cos( z2.lat / 57.2958 ) * cos( m.y1 / 57.2958 ) * cos( m.x1 / 57.2958 – z2.lon / 57.2958 ) , 8 ) r ) ) <= die (mysql_error()); while($row = mysql_fetch_array($sql)) { $store1 = $row['MktName'].""; $store = $row['LocAddSt'].””; $store .= $row['LocAddCity'].”, “.$row['LocAddState'].” ".$rige['postkoade']; $latitude1 = $rige['lat']; $longitude1 = $rige['lon']; $latitude2 = $rige['y1']; $longitude2 = $rige['x1']; $stêd = $rige['stêd']; $state = $rige['steat']; $dis = getnew($latitude1, $longitude1, $latitude2, $longitude2, $unit = 'Mi'); // $dis = ôfstân($lat1, $lon1, $lat2, $lon2); $ferifiearre = $rige['ferifiearre']; if($verified == '1'){ echo ""; echo "".$store.""; echo $dis. " fier fuort"; echo ""; } else { echo "".$store.""; echo $dis. " fier fuort"; echo ""; } }}

    myn functions.php koade
    function getnew($latitude1, $longitude1, $latitude2, $longitude2, $unit = 'Mi') { $theta = $longitude1 – $longitude2; $distance = (sin(deg2rad($latitude1)) * sin(deg2rad($latitude2))) + (cos(deg2rad($latitude1)) * cos(deg2rad($latitude2)) * cos(deg2rad($theta)) ); $ôfstân = acos($ôfstân); $ôfstân = rad2deg($ôfstân); $ôfstân = $ôfstân * 60 * 1.1515; switch($unit) { gefal 'Mi': break; case 'Km' : $ôfstân = $ôfstân * 1.609344; } return (rûn($ôfstân,2)); }

    Dankje jo foarôfgeand

  42. 61
  43. 62

    Hey Douglas, geweldich artikel. Ik fûn jo útlis fan 'e geografyske begripen en de koade echt ynteressant. Myn iennichste suggestje soe wêze om de koade foar werjefte romte te meitsjen en te ynspringen (lykas Stackoverflow, bygelyks). Ik begryp dat jo romte besparje wolle, mar konvinsjonele koade-ôfstân / ynspringing soe it foar my, as programmeur, in protte makliker meitsje om te lêzen en te dissectearjen. Hoe dan ek, dat is in lyts ding. Keep up it grutte wurk.

  44. 64
  45. 65
  46. 66
  47. 67
  48. 68
  49. 69
  50. 70

    it liket flugger (mysql 5.9) om twa kear de formule te brûken yn 'e seleksje en wêr:
    $formula = “(((acos(sin((“.$latitude.”*pi()/180)) * sin((`Latitude`*pi()/180))+cos((“.$latitude. ”*pi()/180)) * cos((`Latitude`*pi()/180)) * cos(((“.$longitude.”- `Longitude`)*pi()/180)))) *180/pi())*60*1.1515*1.609344)”;
    $sql = 'SELECT *, '.$formula.' as ôfstân FROM tabel WHERE '..$formula.' <= '.$ôfstân;

  51. 71
  52. 72

    Tige tank foar it skuorjen fan dit artikel.it is heul nuttich.
    PHP waard earst makke as in ienfâldich skriptplatfoarm neamd "Persoanlike thússide". Tsjintwurdich is PHP (de koarte foar Hypertext Preprocessor) in alternatyf fan 'e Microsoft's Active Server Pages (ASP) technology.

    PHP is in iepen boarne tsjinner-side taal dy't brûkt wurdt foar it meitsjen fan dynamyske websiden. It kin wurde ynbêde yn HTML. PHP wurdt normaal brûkt yn kombinaasje mei in MySQL-database op Linux / UNIX-webservers. It is wierskynlik de populêrste skripttaal.

  53. 73

    Ik fûn boppesteande oplossing net goed wurkje.
    Ik moat feroarje nei:

    $qqq = “SELECT *,(((acos(sin((“.$latitude.”*pi()/180)) * sin((`latt`*pi()/180))+cos((” . $latitude . “*pi()/180)) * cos((`latt`*pi()/180)) * cos(((” . $longitude . “- `longt`)*pi()/180) )))*180/pi())*60*1.1515) as ôfstân FROM `register` ";

  54. 75
  55. 76

    Hallo, asjebleaft, ik sil jo help hjir echt nedich hawwe.

    Ik makke in get-fersyk oan myn webserver http://localhost:8000/users/findusers/53.47792/-2.23389/20/
    53.47792 = $breedte
    -2.23389 = $longitude
    en 20 = de ôfstân ik wol te heljen

    Lykwols, mei help fan jo formule, it heljen alle rigen yn myn db

    $results = DB::select( DB::raw(“SELECT *,(((acos(sin((“.$latitude.”*pi()/180)) * sin((lat*pi()/180 ))+cos((“.$latitude.”*pi()/180)) * cos((lat*pi()/180)) * cos(((“.$longitude.”- lng)*pi( )/180))))*180/pi())*60*1.1515*1.609344) as ôfstân FROM markers HAVE ôfstân >= “.$ôfstân ));

    [{"id":1,"name":"Frankie Johnnie & Luigo Too","adres":"939 W El Camino Real, Mountain View, CA","lat":37.386337280273,"lng":-122.08582305908, "ôfstân":16079.294719663},{"id":2,"name":"Amici's East Coast Pizzeria","adres":"790 Castro St, Mountain View, CA","lat":37.387138366699,"lng": -122.08323669434,"ôfstân":16079.175940152},{"id":3,"name":"Kapp's Pizza Bar & Grill","adres":"191 Castro St, Mountain View, CA","lat":37.393886566162, "lng":-122.07891845703,"ôfstân":16078.381373826},{"id":4,"name":"Round Table Pizza: Mountain View","adres":"570 N Shoreline Blvd, Mountain View, CA", "lat":37.402652740479,"lng":-122.07935333252,"ôfstân":16077.420540582},{"id":5,"name":"Tony & Alba's Pizza & Pasta","adres":"619, Mountain Escuela" View, CA","lat":37.394012451172,"lng":-122.09552764893,"ôfstân":16078.563225154},{"id":6,"name":"Oregano's Wood-Fired Pizza","adres":"4546" El Camino Real, Los Altos, CA","lat":37.401725769043,"lng":-122.11464691162,"ôfstân":16077.937560795},{" id":7,"name":"De bars en grillen","adres":"24 Whiteley Street, Manchester","lat":53.485118865967,"lng":-2.1828699111938,"ôfstân":8038.7620112314}]

    Ik wol te heljen krekt rigen mei 20 miles, mar it bringt alle rigen. Please wat doch ik ferkeard

  56. 77

    Ik bin op syk nei in soartgelikense fraach, mar stapte in bytsje op - koartsein is dit om alle koördinaten binnen 2 milen fan elke koördinaat te groepearjen en dan te tellen hoefolle koördinaten yn elke groep en mar ien groep útfiere dy't de measte koördinaten hat - sels as jo hawwe mear dan ien groep ûnder groepen dy't it measte oantal koördinaten hawwe - útfier gewoan de willekeurige groep út 'e groepen mei itselde grutste oantal -

Wat tinksto?

Dizze side brûkt Akismet om spam te ferleegjen. Learje hoe't jo kommentaargegevens ferwurke wurde.