ఈ నెల నేను GIS కి సంబంధించి PHP మరియు MySQL లో కొంచెం ప్రోగ్రామింగ్ చేస్తున్నాను. నెట్ చుట్టూ స్నూపింగ్, వాస్తవానికి కొన్నింటిని కనుగొనడం నాకు చాలా కష్టమైంది భౌగోళిక లెక్కలు రెండు ప్రదేశాల మధ్య దూరాన్ని కనుగొనడానికి నేను వాటిని ఇక్కడ భాగస్వామ్యం చేయాలనుకుంటున్నాను.
రెండు పాయింట్ల మధ్య దూరాన్ని లెక్కించే సరళమైన మార్గం పైథాగరియన్ సూత్రాన్ని ఉపయోగించి త్రిభుజం (A² + B² = C²) యొక్క హైపోటెన్యూస్ను లెక్కించడం. దీనిని అంటారు యూక్లిడియన్ దూరం.
ఇది ఆసక్తికరమైన ప్రారంభం కాని అక్షాంశం మరియు రేఖాంశాల రేఖల మధ్య దూరం ఉన్నందున ఇది భౌగోళికంతో వర్తించదు సమాన దూరాలు కాదు వేరుగా. మీరు భూమధ్యరేఖకు దగ్గరవుతున్నప్పుడు, అక్షాంశ రేఖలు మరింత వేరుగా ఉంటాయి. మీరు ఒకరకమైన సరళమైన త్రిభుజాకార సమీకరణాన్ని ఉపయోగిస్తే, అది భూమి యొక్క వక్రత కారణంగా ఒక ప్రదేశంలో దూరాన్ని ఖచ్చితంగా మరియు మరొక ప్రదేశంలో చాలా తప్పుగా కొలవవచ్చు.
గొప్ప సర్కిల్ దూరం
భూమి చుట్టూ చాలా దూరం ప్రయాణించే మార్గాలను అంటారు గొప్ప సర్కిల్ దూరం. అంటే... ఒక గోళంలో రెండు బిందువుల మధ్య అతి తక్కువ దూరం ఫ్లాట్ మ్యాప్లోని పాయింట్ల కంటే భిన్నంగా ఉంటుంది. అక్షాంశం మరియు రేఖాంశ రేఖలు సమదూరంలో లేనందున దానిని కలపండి… మరియు మీకు కష్టమైన గణన ఉంది.
గ్రేట్ సర్కిల్స్ ఎలా పనిచేస్తాయో అద్భుతమైన వీడియో వివరణ ఇక్కడ ఉంది.
ది హేవర్సిన్ ఫార్ములా
భూమి యొక్క వక్రతను ఉపయోగించే దూరం హేవర్సిన్ సూత్రం, ఇది భూమి యొక్క వక్రతను అనుమతించడానికి త్రికోణమితిని ఉపయోగిస్తుంది. మీరు భూమిపై 2 ప్రదేశాల మధ్య దూరాన్ని కనుగొన్నప్పుడు (కాకి ఎగిరినట్లు), సరళ రేఖ నిజంగా ఒక ఆర్క్.
ఇది విమాన విమానంలో వర్తిస్తుంది - మీరు ఎప్పుడైనా విమానాల వాస్తవ పటాన్ని చూశారా మరియు అవి వంపులో ఉన్నట్లు గమనించారా? ఎందుకంటే ఇది నేరుగా స్థానానికి రెండు పాయింట్ల మధ్య వంపులో ప్రయాణించడం తక్కువ.
PHP: అక్షాంశం మరియు రేఖాంశం యొక్క 2 పాయింట్ల మధ్య దూరాన్ని లెక్కించండి
రెండు పాయింట్ల మధ్య దూరాన్ని (మైల్ వర్సెస్ కిలోమీటర్ మార్పిడితో పాటు) రెండు దశాంశ స్థానాలకు గుండ్రంగా లెక్కించడానికి PHP ఫార్ములా ఇక్కడ ఉంది.
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));
}
వేరియబుల్స్:
- $Latitude1 – మీ మొదటి స్థానం యొక్క అక్షాంశం కోసం వేరియబుల్.
- $Longitude1 – మీ మొదటి స్థానం యొక్క రేఖాంశం కోసం వేరియబుల్
- $Latitude2 – మీ రెండవ స్థానం యొక్క అక్షాంశం కోసం వేరియబుల్.
- $Longitude2 – మీ రెండవ స్థానం యొక్క రేఖాంశం కోసం వేరియబుల్.
- $యూనిట్ - డిఫాల్ట్ జీవి వేల. దీన్ని ఇలా అప్డేట్ చేయవచ్చు లేదా పాస్ చేయవచ్చు కిలోమీటర్ల.
పైథాన్: అక్షాంశం మరియు రేఖాంశం యొక్క 2 పాయింట్ల మధ్య దూరాన్ని లెక్కించండి
ఏది ఏమైనప్పటికీ, రెండు పాయింట్ల మధ్య దూరాన్ని (మైల్ వర్సెస్ కిలోమీటర్ మార్పిడితో పాటు) రెండు దశాంశ స్థానాలకు గుండ్రంగా లెక్కించడానికి పైథాన్ ఫార్ములా ఇక్కడ ఉంది. డేటా సైంటిస్ట్గా ఉన్న నా కొడుకు బిల్ కర్కి క్రెడిట్ ఓపెన్ఇన్సైట్లు, కోడ్ కోసం.
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)
వేరియబుల్స్:
- అక్షాంశం1 – మీ మొదటి స్థానం కోసం వేరియబుల్ అక్షాంశం.
- రేఖాంశం1 – మీ మొదటి స్థానం కోసం వేరియబుల్ రేఖాంశం
- అక్షాంశం2 – మీ రెండవ స్థానం కోసం వేరియబుల్ అక్షాంశం.
- రేఖాంశం2 – మీ రెండవ స్థానం కోసం వేరియబుల్ రేఖాంశం.
- యూనిట్ - డిఫాల్ట్ జీవి వేల. దీన్ని ఇలా అప్డేట్ చేయవచ్చు లేదా పాస్ చేయవచ్చు కిలోమీటర్ల.
MySQL: అక్షాంశం మరియు రేఖాంశాన్ని ఉపయోగించి మైళ్లలో దూరాన్ని లెక్కించడం ద్వారా ఒక పరిధిలో అన్ని రికార్డులను తిరిగి పొందడం
అన్ని రికార్డులను నిర్దిష్ట దూరం లో కనుగొనడానికి గణన చేయడానికి SQL ను ఉపయోగించడం కూడా సాధ్యమే. ఈ ఉదాహరణలో, $ అక్షాంశం మరియు $ రేఖాంశం వద్ద నా స్థానానికి వేరియబుల్ $ దూరం (మైల్స్లో) కంటే తక్కువ లేదా సమానమైన అన్ని రికార్డులను కనుగొనడానికి నేను MySQL లో MyTable ని ప్రశ్నించబోతున్నాను:
ఒక నిర్దిష్ట పరిధిలోని అన్ని రికార్డులను తిరిగి పొందే ప్రశ్న దూరం అక్షాంశం మరియు రేఖాంశం యొక్క రెండు పాయింట్ల మధ్య మైళ్ళ దూరాన్ని లెక్కించడం ద్వారా:
$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."
మీరు దీన్ని అనుకూలీకరించాలి:
- $ రేఖాంశం - ఇది ఒక PHP వేరియబుల్, ఇక్కడ నేను పాయింట్ యొక్క రేఖాంశాన్ని దాటుతున్నాను.
- $ అక్షాంశం - ఇది ఒక PHP వేరియబుల్, ఇక్కడ నేను పాయింట్ యొక్క రేఖాంశాన్ని దాటుతున్నాను.
- $ దూరం - ఇది మీరు అన్ని రికార్డులను తక్కువ లేదా సమానమైనదిగా కనుగొనాలనుకుంటున్న దూరం.
- పట్టిక - ఇది పట్టిక… మీరు దానిని మీ పట్టిక పేరుతో భర్తీ చేయాలనుకుంటున్నారు.
- అక్షాంశం - ఇది మీ అక్షాంశం యొక్క క్షేత్రం.
- రేఖాంశం - ఇది మీ రేఖాంశం యొక్క క్షేత్రం.
MySQL: అక్షాంశం మరియు రేఖాంశాన్ని ఉపయోగించి కిలోమీటర్లలో దూరాన్ని లెక్కించడం ద్వారా ఒక పరిధిలో అన్ని రికార్డులను తిరిగి పొందడం
MySQL లో కిలోమీటర్లను ఉపయోగించి SQL ప్రశ్న ఇక్కడ ఉంది:
$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."
మీరు దీన్ని అనుకూలీకరించాలి:
- $ రేఖాంశం - ఇది ఒక PHP వేరియబుల్, ఇక్కడ నేను పాయింట్ యొక్క రేఖాంశాన్ని దాటుతున్నాను.
- $ అక్షాంశం - ఇది ఒక PHP వేరియబుల్, ఇక్కడ నేను పాయింట్ యొక్క రేఖాంశాన్ని దాటుతున్నాను.
- $ దూరం - ఇది మీరు అన్ని రికార్డులను తక్కువ లేదా సమానమైనదిగా కనుగొనాలనుకుంటున్న దూరం.
- పట్టిక - ఇది పట్టిక… మీరు దానిని మీ పట్టిక పేరుతో భర్తీ చేయాలనుకుంటున్నారు.
- అక్షాంశం - ఇది మీ అక్షాంశం యొక్క క్షేత్రం.
- రేఖాంశం - ఇది మీ రేఖాంశం యొక్క క్షేత్రం.
నేను ఈ కోడ్ను ఎంటర్ప్రైజ్ మ్యాపింగ్ ప్లాట్ఫామ్లో ఉపయోగించాను, మేము రిటైల్ స్టోర్ కోసం ఉత్తర అమెరికాలో 1,000 కి పైగా స్థానాలతో ఉపయోగించాము మరియు ఇది అందంగా పనిచేసింది.
Microsoft SQL సర్వర్ భౌగోళిక దూరం: STDistance
మీరు మైక్రోసాఫ్ట్ SQL సర్వర్ని ఉపయోగిస్తుంటే, వారు తమ స్వంత ఫంక్షన్ను అందిస్తారు, ST దూరం భౌగోళిక డేటా రకాన్ని ఉపయోగించి రెండు పాయింట్ల మధ్య దూరాన్ని లెక్కించడానికి.
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);
మనష్ సాహూ, VP మరియు ఆర్కిటెక్ట్కి టోపీ చిట్కా Highbridge.
భాగస్వామ్యం చేసినందుకు చాలా ధన్యవాదాలు. ఇది సులభమైన కాపీ మరియు పేస్ట్ ఉద్యోగం మరియు గొప్పగా పనిచేస్తుంది. మీరు నాకు చాలా సమయం ఆదా చేసారు.
C కి పోర్టింగ్ చేసే ఎవరికైనా FYI:
డబుల్ డెగ్ 2 రాడ్ (డబుల్ డిగ్రీ) {రిటర్న్ డిగ్ * (3.14159265358979323846 / 180.0); }
చాలా మంచి పోస్టింగ్ - చాలా బాగుంది - నేను లాట్-లాంగ్ కలిగి ఉన్న టేబుల్ పేరును మాత్రమే మార్చాల్సి వచ్చింది. ఇది చాలా వేగంగా పనిచేస్తుంది .. నాకు చాలా తక్కువ సంఖ్యలో లాట్-లాంగ్స్ (<400) ఉన్నాయి, కానీ ఇది చక్కగా స్కేల్ అవుతుందని నేను భావిస్తున్నాను. మంచి సైట్ కూడా - నేను దీన్ని నా del.icio.us ఖాతాకు జోడించాను మరియు క్రమం తప్పకుండా తనిఖీ చేస్తాను.
చాలా ధన్యవాదాలు పీటర్ మరియు కెర్రీ! మీరు GIS ప్రాజెక్టులలో పనిచేయాలనుకుంటే, నేను సిఫార్సు చేస్తున్నాను:
చాలా ధన్యవాదాలు…
నేను దూర గణనల కోసం రోజంతా శోధించాను మరియు హార్వర్సిన్ అల్గోరిథంను కనుగొన్నాను, దానిని SQL స్టేట్మెంట్లో ఎలా ఉంచాలో ఉదాహరణ ఇచ్చినందుకు మీకు ధన్యవాదాలు. ధన్యవాదాలు మరియు శుభాకాంక్షలు, డేనియల్
సహాయం చేసినందుకు సంతోషం, పట్టాలు మిత్రమా!
ఇప్పుడు నేను 'పాలిగాన్' PHP ఫంక్షన్ కోసం అన్వేషిస్తున్నాను, అది వరుస అక్షాంశం మరియు రేఖాంశ కోఆర్డినేట్ల శ్రేణిని తీసుకుంటుంది మరియు మరొక పాయింట్ బహుభుజి లోపల లేదా వెలుపల ఉందో లేదో గుర్తించండి.
నేను కనుగొన్నాను బహుభుజిలో ఒక బిందువు ఉంటే గుర్తించడానికి సమీకరణం!
మీ SQL కి స్టేట్మెంట్ అవసరమని నేను అనుకుంటున్నాను.
WHERE దూరం <= $ దూరానికి బదులుగా మీకు అవసరం కావచ్చు
దూరం <= $ దూరం ఉపయోగించండి
లేకపోతే నాకు సమయం మరియు శక్తిని ఆదా చేసినందుకు ధన్యవాదాలు.
హాయ్ డేవిడ్,
మీరు ఏ రకమైన GROUP BY స్టేట్మెంట్ చేస్తున్నా, మీకు HAVING అవసరం. పై ఉదాహరణలో నేను అలా చేయడం లేదు.
డౌ
MySQL 5.x నాటికి, మీరు ఎక్కడ ఒక నిబంధనలో అలియాస్ ఉపయోగించలేరు http://dev.mysql.com/doc/refman/5.0/en/problems-with-alias.html
పై ప్రశ్నలలో WHERE కి బదులుగా HAVING ఉపయోగించండి
మీకు చాలా కృతజ్ఞతలు. మీరు గొప్ప పని చేసారు, నేను నిజంగా కోరుకునేది అదే. చాలా ధన్యవాదాలు.
ఈ కోడ్ను భాగస్వామ్యం చేసినందుకు చాలా ధన్యవాదాలు. ఇది నాకు చాలా అభివృద్ధి సమయాన్ని ఆదా చేసింది. అలాగే, MySQL 5.x కోసం HAVING స్టేట్మెంట్ అవసరమని ఎత్తి చూపినందుకు మీ పాఠకులకు ధన్యవాదాలు. చాలా ఉపయోగకరం.
నాకన్నా తెలివిగా పాఠకులను కలిగి ఉండటం నాకు ఆశీర్వాదం!
🙂
పై ఫార్ములా నాకు చాలా సమయం ఆదా చేస్తుంది. మీకు చాలా కృతజ్ఞతలు.
నేను NMEA ఫార్మాట్ మరియు డిగ్రీల మధ్య కూడా మారాలి. నేను ఈ URL వద్ద పేజీ దిగువన ఒక సూత్రాన్ని కనుగొన్నాను. http://www.errorforum.com/knowledge-base/16273-converting-nmea-sentence-latitude-longitude-decimal-degrees.html
దీన్ని ఎలా ధృవీకరించాలో ఎవరికైనా తెలుసా?
ధన్యవాదాలు!
హ్యారీ
హలో,
మరో ప్రశ్న. క్రింద ఉన్న విధంగా NMEA తీగలకు సూత్రం ఉందా?
1342.7500, ఎన్, 10052.2287, ఇ
$GPRMC,032731.000,A,1342.7500,N,10052.2287,E,0.40,106.01,101106,,*0B
ధన్యవాదాలు,
హ్యారీ
WHERE నాకు పని చేయలేదని కూడా నేను కనుగొన్నాను. దీన్ని HAVING గా మార్చారు మరియు ప్రతిదీ ఖచ్చితంగా పనిచేస్తుంది. మొదట నేను వ్యాఖ్యలను చదవలేదు మరియు సమూహ ఎంపికను ఉపయోగించి తిరిగి వ్రాసాను. రెండూ బాగా పనిచేస్తాయి.
MySQL లో వ్రాసిన స్క్రిప్ట్కు చాలా ధన్యవాదాలు, కొన్ని చిన్న సర్దుబాట్లు చేయవలసి వచ్చింది (HAVING)
గ్రేట్ ఉద్యోగం
నమ్మశక్యం కాని సహాయకారి, చాలా ధన్యవాదాలు! నేను “WHERE” కాకుండా క్రొత్త “HAVING” తో కొన్ని సమస్యలను ఎదుర్కొన్నాను, కాని ఒకసారి నేను ఇక్కడ వ్యాఖ్యలను చదివాను (నిరాశతో = P లో నా దంతాలు రుబ్బుకున్న అరగంట తరువాత), నేను చక్కగా పని చేస్తున్నాను. ధన్యవాదాలు ^ _ ^
ధన్యవాదాలు చాలా బాగుంది
అలాంటి ఎంచుకున్న ప్రకటన చాలా గణనపరంగా తీవ్రంగా ఉంటుంది మరియు అందువల్ల నెమ్మదిగా ఉంటుందని గుర్తుంచుకోండి. మీకు ఆ ప్రశ్నలు చాలా ఉంటే, అది చాలా త్వరగా విషయాలను తగ్గించగలదు.
లెక్కించిన దూరం ద్వారా నిర్వచించబడిన SQUARE ప్రాంతాన్ని ఉపయోగించి మొదటి (ముడి) ఎంపికను నడపడం చాలా తక్కువ తీవ్రమైన విధానం, అనగా "పట్టిక పేరు నుండి" ఎంచుకోండి * ఇక్కడ లాట్ 1 మరియు లాట్ 2 మధ్య అక్షాంశం మరియు లోన్ 1 మరియు లోన్ 2 మధ్య రేఖాంశం ". lat1 = targetlatitude - latdiff, lat2 = targetlatitude + latdiff, lon తో సమానంగా ఉంటుంది. 111 డిగ్రీ అక్షాంశం ~ 69 కిమీ (లాటిఫ్ ~ = దూరం / 1 (కిమీ కోసం), లేదా మైళ్ళకు దూరం / 111 (భూమి కొద్దిగా అండాకారంగా ఉన్నందున స్వల్ప వైవిధ్యం, కానీ ఈ ప్రయోజనం కోసం సరిపోతుంది). londiff = distance / (abs (cos (deg2rad (అక్షాంశం)) * 111%) - లేదా 69 మైళ్ళకు (వైవిధ్యాలను లెక్కించడానికి మీరు కొంచెం పెద్ద చదరపు తీసుకోవచ్చు). అప్పుడు దాని ఫలితాన్ని తీసుకొని రేడియల్ సెలక్ట్ లోకి ఫీడ్ చేయండి. వెలుపల ఉన్న కోఆర్డినేట్ల కోసం లెక్కించడం మర్చిపోవద్దు - అనగా ఆమోదయోగ్యమైన రేఖాంశం యొక్క పరిధి -180 నుండి +180 మరియు ఆమోదయోగ్యమైన అక్షాంశ పరిధి -90 నుండి +90 వరకు ఉంటే - మీ లాడిఫ్ లేదా లాండిఫ్ ఈ పరిధికి వెలుపల నడుస్తే . చాలా సందర్భాల్లో ఇది వర్తించదు, ఎందుకంటే ఇది పసిఫిక్ మహాసముద్రం నుండి ధ్రువం నుండి ధ్రువం వరకు ఒక రేఖపై ఉన్న గణనలను మాత్రమే ప్రభావితం చేస్తుంది, అయినప్పటికీ ఇది చుకోట్కాలో కొంత భాగాన్ని మరియు అలాస్కాలో కొంత భాగాన్ని కలుస్తుంది.
దీని ద్వారా మేము సాధించేది ఏమిటంటే, మీరు ఈ గణన చేసే పాయింట్ల సంఖ్యలో గణనీయమైన తగ్గింపు. డేటాబేస్లో మీకు మిలియన్ గ్లోబల్ పాయింట్లు సమానంగా పంపిణీ చేయబడితే మరియు మీరు 100 కి.మీ.లోపు శోధించాలనుకుంటే, మీ మొదటి (వేగవంతమైన) శోధన 10000 చదరపు కిలోమీటర్ల విస్తీర్ణంలో ఉంటుంది మరియు బహుశా 20 ఫలితాలను ఇస్తుంది (a కంటే ఎక్కువ పంపిణీ ఆధారంగా) సుమారు 500M చదరపు కిలోమీటర్ల ఉపరితల వైశాల్యం), అంటే మీరు ఈ ప్రశ్న కోసం సంక్లిష్ట దూర గణనను మిలియన్ సార్లు కాకుండా 20 సార్లు అమలు చేస్తారు.
ఉదాహరణలో చిన్న పొరపాటు… అది మన… చదరపు “వ్యాసార్థం” వైపు చూస్తున్నందున అది 50 కిమీ (100 కాదు) లో ఉంటుంది.
అద్భుతమైన సలహా! లోపలి చతురస్రాన్ని లాగిన ఒక ఫంక్షన్ను వ్రాసిన డెవలపర్తో నేను పనిచేశాను, ఆపై మిగిలిన పాయింట్లను చేర్చడానికి మరియు మినహాయించటానికి చుట్టుకొలత చుట్టూ 'చతురస్రాలు' చేసిన పునరావృత ఫంక్షన్. ఫలితం చాలా వేగంగా ఫలితం - అతను మైక్రోసెకన్లలో మిలియన్ల పాయింట్లను అంచనా వేయగలడు.
పైన నా విధానం ఖచ్చితంగా 'ముడి' కానీ సామర్థ్యం కలిగి ఉంటుంది. మళ్ళీ ధన్యవాదాలు!
డగ్,
లాట్ లాంగ్ పాయింట్ బహుభుజిలో ఉందో లేదో అంచనా వేయడానికి నేను మైస్క్ల్ మరియు పిహెచ్పిని ఉపయోగించడానికి ప్రయత్నిస్తున్నాను. ఈ పనిని ఎలా సాధించాలో మీ డెవలపర్ స్నేహితుడు ఏదైనా ఉదాహరణలను ప్రచురించారో మీకు తెలుసా. లేదా మీకు మంచి ఉదాహరణలు ఏమైనా తెలుసా. ముందుగానే ధన్యవాదాలు.
హాయ్ అందరికీ ఇది నా పరీక్ష SQL స్టేట్మెంట్:
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
మరియు మైస్క్ల్ నాకు దూరం చెబుతోంది, కాలమ్ వలె లేదు, నేను ఆర్డర్ను ఉపయోగించగలను, నేను ఎక్కడ లేకుండా చేయగలను, మరియు అది పనిచేస్తుంది, కానీ దానితో కాదు…
“WHERE దూరం” ను “దూరం” తో భర్తీ చేయండి.
మనోజ్ఞతను పనిచేస్తుంది, ధన్యవాదాలు, డగ్లస్!
ఇది చాలా బాగుంది, అయితే పక్షులు ఎగిరినట్లే. గూగుల్ మ్యాప్స్ API ని దీనికి ఎలాగైనా ప్రయత్నించడం మరియు చేర్చడం చాలా బాగుంది (రోడ్లు వాడటం మొదలైనవి) వేరే విధమైన రవాణాను ఉపయోగించి ఒక ఆలోచన ఇవ్వడానికి. ట్రావెలింగ్ సేల్స్ మాన్ సమస్యకు సమర్థవంతమైన పరిష్కారాన్ని అందించగలిగే PHP లో అనుకరణ ఎనియలింగ్ ఫంక్షన్ను నేను ఇంకా చేయలేదు. కానీ నేను మీ కోడ్లో కొన్నింటిని తిరిగి ఉపయోగించుకోగలనని అనుకుంటున్నాను.
హాయ్ డగ్లస్,
ఈ వ్యాసానికి చాలా ధన్యవాదాలు - మీరు నాకు చాలా సమయం ఆదా చేసారు.
జాగ్రత్త,
నిమ్రోడ్ s ఇస్రాయెల్
మంచి వ్యాసం! రెండు పాయింట్ల మధ్య దూరాన్ని ఎలా లెక్కించాలో వివరించే చాలా కథనాలను నేను కనుగొన్నాను, కాని నేను నిజంగా SQL స్నిప్పెట్ కోసం చూస్తున్నాను.
ధన్యవాదాలు చాలా బాగుంది
ఈ ఫార్ములాకు చాలా ధన్యవాదాలు. ఇది నా వద్ద తినే స్టోర్ లొకేషన్ ప్రాజెక్ట్లో కొంత సమయం గుండు చేసింది.
ధన్యవాదాలు ఒక కట్ట. కోడ్ యొక్క ఈ చిన్న పంక్తి స్టోర్ లొకేషన్ ప్రాజెక్ట్లో నాకు కొంత సమయం ఆదా చేసింది!
# 1054 - 'ఎక్కడ నిబంధన' లో తెలియని కాలమ్ 'దూరం'
ఆమోదించడానికి
ఇక్కడ కుడా అంతే! సమస్య ఏమిటి :-/? “దూరం” - కాలమ్ సమస్యను ఎలా పరిష్కరించాలి? మాకు సహాయం చెయ్యండి, దయచేసి !! 🙂
WHERE కు బదులుగా HAVING ను ఉపయోగించడానికి ప్రయత్నించండి
చివరకు నా సమస్యను పరిష్కరించే ఈ పేజీని కనుగొనడానికి 2 రోజుల పరిశోధన. నేను నా వోల్ఫ్రామ్ ఆల్ఫాను బాగా విడదీసి, నా గణితంలో బ్రష్ చేసినట్లు కనిపిస్తోంది. WHERE నుండి HAVING కు మార్పు నా స్క్రిప్ట్ను పని క్రమంలో కలిగి ఉంది. ధన్యవాదాలు
WHERE నిబంధన వాడకానికి బదులుగా:
దూరం <50
ధన్యవాదాలు జార్జి. నేను కాలమ్ 'దూరం' దొరకలేదు. ఒకసారి నేను WHERE ని కలిగి ఉన్నాను అది మనోజ్ఞతను కలిగి ఉంది!
నేను దీనిపై కనుగొన్న మొదటి పేజీ ఇదే అని నేను కోరుకుంటున్నాను. అనేక విభిన్న ఆదేశాలను ప్రయత్నించిన తరువాత ఇది సరిగ్గా పనిచేయడం మరియు నా స్వంత డేటాబేస్కు సరిపోయేలా కనీస మార్పులతో అవసరం.
చాలా ధన్యవాదాలు!
నేను దీనిపై కనుగొన్న మొదటి పేజీ ఇదే అని నేను కోరుకుంటున్నాను. అనేక విభిన్న ఆదేశాలను ప్రయత్నించిన తరువాత ఇది సరిగ్గా పనిచేయడం మరియు నా స్వంత డేటాబేస్కు సరిపోయేలా కనీస మార్పులతో అవసరం.
చాలా ధన్యవాదాలు!
చాలా ధన్యవాదాలు!
చాలా ధన్యవాదాలు!
కోడ్ ఇకపై కనబడుతుందని నేను అనుకోను. బహుశా ఇది ఫైర్ఫాక్స్?
నేను ఫైర్ఫాక్స్ మరియు క్రోమ్లో రెండింటినీ పరీక్షించాను మరియు అది కనిపిస్తోంది. మళ్ళీ ప్రయత్నించాలా?
హాయ్. చాలా ధన్యవాదాలు. ఇది మనోజ్ఞతను కలిగిస్తుంది.
చాలా ధన్యవాదాలు డగ్లస్. ఇది ఖచ్చితంగా పనిచేస్తోంది.
ఈ ఫార్ములా పనిచేస్తుందని నాకు తెలుసు, కాని భూమి యొక్క వ్యాసార్థం ఎక్కడ పరిగణనలోకి తీసుకోబడిందో నేను చూడలేను. దయచేసి ఎవరైనా నాకు జ్ఞానోదయం చేయగలరా?
టిమ్, హేవర్సిన్ ఫార్ములా యొక్క పూర్తి వివరణ కోసం (అది కోడ్ కాదు), వికీపీడియా యొక్క కథనాన్ని చూడండి: http://en.wikipedia.org/wiki/Haversine_formula
అందమైన! ఇది నాకు ఎంతో సహాయపడింది!
గొప్ప విషయం డగ్లస్. రెండు పాయింట్ల లాంగ్ / లాట్ / బేరింగ్ ఇచ్చిన ఖండన పాయింట్ పొందడానికి మీరు ప్రయత్నించారా?
ఇంకా చేయలేదు, ఖాన్హ్!
ధన్యవాదాలు డగ్లస్, SQL ప్రశ్న నాకు అవసరమైనది, మరియు నేను దానిని రాయాలని అనుకున్నాను. మీరు అక్షాంశ రేఖాంశ అభ్యాస వక్రరేఖ నుండి నన్ను రక్షించారు!
నేను లోపం సందేశాన్ని పొందుతూనే ఉన్నాను: MySQL ప్రశ్నలో 'ఎక్కడ నిబంధన' లో తెలియని కాలమ్ 'దూరం'.
పీటర్, దయచేసి ఇతర వ్యాఖ్యల ద్వారా చదవండి. కొంతమంది వ్యక్తులు WHERE / HAVING కోసం వేరే వాక్యనిర్మాణాన్ని ఉపయోగించాల్సి ఉందని తెలుస్తుంది.
ఈ గొప్ప కథనానికి ధన్యవాదాలు! నా DB లో కోడ్ను పరీక్షించి గొప్పగా పనిచేశాను!
డగ్లస్, ఈ అద్భుతమైన కోడ్కు ధన్యవాదాలు. నా GPS కమ్యూనిటీ పోర్టల్లో దీన్ని ఎలా చేయాలో నా తల పగులగొట్టింది. మీరు నాకు గంటలు ఆదా చేసారు.
వినడానికి చాలా బాగుంది, ఐష్!
ఈ ఉపయోగకరమైన కథనాన్ని పోస్ట్ చేసినందుకు ధన్యవాదాలు,
కానీ కొన్ని కారణాల వల్ల నేను అడగాలనుకుంటున్నాను
MySQL db లోపల తీగలకు మరియు వినియోగదారు ద్వారా php కి చొప్పించిన తీగలకు మధ్య దూరాన్ని ఎలా పొందాలి?
మరింత స్పష్టంగా వివరించడానికి:
1. యూజర్ db మరియు యూజర్ యొక్క తీగలు నుండి పేర్కొన్న డేటాను ఎంచుకోవడానికి [id] ను చొప్పించాలి
2. php ఫైల్ [id] ను ఉపయోగించి లక్ష్య డేటాను (కోడ్లు) పొందుతుంది, ఆపై వినియోగదారు మరియు లక్ష్య బిందువు మధ్య దూరాన్ని లెక్కించండి
లేదా దిగువ కోడ్ నుండి దూరం పొందగలరా?
. $ అక్షాంశం. ))) * 180 / pi ()) * 180 * 180 * 180) `MyTable` WHERE దూరం> =“. $ దూరం. >>>> నేను ఇక్కడ నుండి దూరాన్ని “తీయగలనా”?
మళ్ళీ ధన్యవాదాలు,
టిమ్మి ఎస్
ఫర్వాలేదు, నేను php లో “ఫంక్షన్” ఎలా పనిచేస్తుందో గుర్తించాను
$ dis = getDistanceBetweenPointsNew ($ userLati, $ userLongi, $ lati, $ longi, $ unit = 'Km')
చాలా ధన్యవాదాలు!!
సరే, నేను ప్రయత్నించిన ప్రతిదీ పనిచేయడం లేదు. నా ఉద్దేశ్యం, నా దగ్గర ఏమి ఉంది, కానీ దూరాలు దూరంగా ఉన్నాయి.
ఈ కోడ్లో తప్పు ఏమిటో ఎవరైనా చూడగలరా?
if (isset ($ _ POST ['సమర్పించిన'])) {$ z = $ _POST ['జిప్కోడ్']; $ r = $ _POST ['వ్యాసార్థం']; ప్రతిధ్వని “ఫలితాలు“. $ z; . నగరం, z1.state FROM mrk m, zip z1, zip z1 WHERE m.zipcode = z2.zipcode AND z1.zipcode = $ z AND (1 * acos (కత్తిరించు (పాపం (z1.lat / 2) * పాపం (m. y1 / 2) + cos (z3963.lat / 2) * cos (m.y57.2958 / 1) * cos (m.x57.2958 / 2 - z57.2958.lon / 1), 57.2958%)) <= $ r ") లేదా చనిపోతారు (mysql_error ()); అయితే ($ row = mysql_fetch_array ($ sql)) {$ store1 = $ row ['MktName']. "”; $ store = $ row ['LocAddSt']. ””; $ store. = $ row ['LocAddCity']. ”,“. $ row ['LocAddState']. ” “. $ అడ్డు వరుస ['జిప్కోడ్']; $ అక్షాంశం 57.2958 = $ వరుస ['లాట్']; $ longitude2 = $ row ['lon']; $ అక్షాంశం 57.2958 = $ వరుస ['y8']; $ longitude1 = $ row ['x1']; $ city = $ row ['city']; $ state = $ row ['state']; $ dis = getnew ($ latitude1, $ longitude2, $ latitude1, $ longitude2, $ unit = 'Mi'); // $ dis = దూరం ($ lat1, $ lon1, $ lat1, $ lon2); $ ధృవీకరించబడింది = $ అడ్డు వరుస ['ధృవీకరించబడింది']; if ($ ధృవీకరించబడింది == '2') {echo “”; ఎకో “”. $ స్టోర్. ””; echo $ dis. " మైళ్ళ దూరం"; ఎకో “”; } else {echo “”. $ store. ””; echo $ dis. " మైళ్ళ దూరం"; ఎకో “”; }}}
నా functions.php కోడ్
ఫంక్షన్ getnew ($ అక్షాంశం 1, $ రేఖాంశం 1, $ అక్షాంశం 2, $ రేఖాంశం 2, $ యూనిట్ = 'మి') {$ తీటా = $ రేఖాంశం 1 - $ రేఖాంశం 2; $ దూరం = (పాపం (deg2rad ($ అక్షాంశం 1)) * పాపం (deg2rad ($ అక్షాంశం 2))) + (cos (deg2rad ($ latitude1)) * cos (deg2rad ($ latitude2)) * cos (deg2rad ($ theta)) ); $ దూరం = అకోస్ ($ దూరం); $ దూరం = రాడ్ 2 దేగ్ ($ దూరం); $ దూరం = $ దూరం * 60 * 1.1515; స్విచ్ ($ యూనిట్) {కేసు 'మి': బ్రేక్; కేసు 'కి.మీ': $ దూరం = $ దూరం * 1.609344; } తిరిగి (రౌండ్ ($ దూరం, 2 శాతం); }
ముందుగానే ధన్యవాదాలు
ఈ వ్యాసానికి ధన్యవాదాలు. నా కోడ్తో బాగా పనిచేస్తోంది. 🙂
హే డగ్లస్, గొప్ప వ్యాసం. భౌగోళిక భావనలు మరియు కోడ్ గురించి మీ వివరణ నిజంగా ఆసక్తికరంగా ఉందని నేను కనుగొన్నాను. నా ఏకైక సలహా స్థలం మరియు ప్రదర్శన కోసం కోడ్ను ఇండెంట్ చేయండి (ఉదాహరణకు స్టాక్ఓవర్ ఫ్లో వంటివి). మీరు స్థలాన్ని పరిరక్షించాలనుకుంటున్నారని నేను అర్థం చేసుకున్నాను, కాని సాంప్రదాయిక కోడ్ అంతరం / ఇండెంటేషన్ ప్రోగ్రామర్గా నాకు చదవడం మరియు విడదీయడం చాలా సులభం చేస్తుంది. ఏమైనా, అది ఒక చిన్న విషయం. గొప్ప పనిని కొనసాగించండి.
ధన్యవాదాలు! నేను పోస్ట్ను కొద్దిగా సవరించాను… కాని సమీకరణాలు చాలా గదిని తీసుకుంటాయి మరియు చాలా పొడవుగా ఉన్నాయి, ఇది చాలా సహాయపడుతుందని నాకు తెలియదు.
చాలా ధన్యవాదాలు.
ఇక్కడ ఫంక్షన్తో ఉపయోగిస్తున్నప్పుడు మనం ఒక రకమైన దూరాన్ని పొందుతున్నాము..అంతేకాక దాని రాబోయే ఇతర రకాల దూరాన్ని ప్రశ్నను ఉపయోగిస్తున్నాము
నేను రెండు రాష్ట్రాల మధ్య దూరాన్ని లెక్కించను
ముచాస్ గ్రేసియాస్ పోర్ టాన్ హెర్మోసో కోడిగో…
ఇది మంచి కాసినస్ విధులు. నాకు గణితం తెలియదు, కానీ ధన్యవాదాలు!
గొప్ప ఉద్యోగం… 🙂 (y)
ఎంచుకున్న చోట రెండుసార్లు సూత్రాన్ని ఉపయోగించడం వేగంగా (mysql 5.9) అనిపిస్తుంది మరియు ఎక్కడ:
$ ఫార్ములా = “(((అకోస్ (పాపం ((“. $ అక్షాంశం. ”* పై () / 180)) * పాపం ((` అక్షాంశం` * పై () / 180)) + కాస్ ((“. $ అక్షాంశం. ”* పై () / 180)) * కాస్ ((` అక్షాంశం` * పై () / 180)) * కాస్ (((“. $ రేఖాంశం.” - `రేఖాంశం`) * పై () / 180 శాతం))) * 180 / పై ()) * 60 * 1.1515 * 1.609344) ”;
$ sql = 'SELECT *,'. $ సూత్రం. ' పట్టిక నుండి దూరం '.. $ ఫార్ములా.' <= '. $ దూరం;
ధన్యవాదాలు…
ఉంటే పని చేయడం లేదు
“ఎక్కడ దూరం”
ఉంటే పని
“దూరం”
ఈ వ్యాసాన్ని కోసినందుకు చాలా ధన్యవాదాలు. ఇది చాలా సహాయకారిగా ఉంది.
PHP మొదట “పర్సనల్ హోమ్ పేజ్” అనే సాధారణ స్క్రిప్టింగ్ ప్లాట్ఫామ్గా సృష్టించబడింది. ఈ రోజుల్లో మైక్రోసాఫ్ట్ యొక్క యాక్టివ్ సర్వర్ పేజెస్ (ASP) టెక్నాలజీకి ప్రత్యామ్నాయం PHP (హైపర్టెక్స్ట్ ప్రిప్రాసెసర్ కోసం చిన్నది).
PHP అనేది ఓపెన్ సోర్స్ సర్వర్-సైడ్ లాంగ్వేజ్, ఇది డైనమిక్ వెబ్ పేజీలను సృష్టించడానికి ఉపయోగించబడుతుంది. దీన్ని HTML లో పొందుపరచవచ్చు. PHP సాధారణంగా Linux / UNIX వెబ్ సర్వర్లలోని MySQL డేటాబేస్ తో కలిపి ఉపయోగించబడుతుంది. ఇది బహుశా అత్యంత ప్రాచుర్యం పొందిన స్క్రిప్టింగ్ భాష.
పైన పరిష్కారం సరిగా పనిచేయడం లేదని నేను కనుగొన్నాను.
నేను దీనికి మార్చాలి:
$ qqq = “SELECT *, ((acos (sin ((“. $ latitude. ”* pi () / 180%)) * sin ((` latt` * pi () / 180%)) + cos ((”). $ అక్షాంశం. “* పై () / 180)) * కాస్ ((` లాట్` * పై () / 180)) * కాస్ (((”. $ రేఖాంశం.“ - `లాంగ్ట్`) * పై () / 180) ))) * 180 / pi ()) * 60 * 1.1515) `రిజిస్టర్` నుండి దూరం;
ధన్యవాదాలు కుపేంద్ర!
ధన్యవాదాలు సార్ సంపూర్ణంగా వ్రోకింగ్ .. కానీ నేను దశాంశ బిందువు లేకుండా అవుట్పుట్ చేయాలనుకుంటే నాకు ఒక ప్రశ్న ఉంది, అప్పుడు నేను ఏమి చేయగలను ..?
ముందుగానే ధన్యవాదాలు.
హలో, దయచేసి దీనిపై మీ సహాయం నాకు నిజంగా అవసరం.
నేను నా వెబ్ సర్వర్కు గెట్ రిక్వెస్ట్ చేసాను http://localhost:8000/users/findusers/53.47792/-2.23389/20/
53.47792 = $ అక్షాంశం
-2.23389 = $ రేఖాంశం
మరియు 20 = నేను తిరిగి పొందాలనుకునే దూరం
అయితే మీరు ఫార్ములా ఉపయోగించి, ఇది నా db లోని అన్ని అడ్డు వరుసలను తిరిగి పొందుతుంది
$ ఫలితాలు = DB :: ఎంచుకోండి (DB :: raw (“SELECT *, ((acos (sin ((“. $ latitude. ”* pi () / 180%)) * sin ((lat * pi () / 180 )) + cos ((“. $ అక్షాంశం.” * pi () / 180)) * cos ((lat * pi () / 180)) * cos (((“. $ రేఖాంశం.” - lng) * pi ( ) / 180%)))) * 180 / pi ()) * 60 * 1.1515 * 1.609344) దూరం నుండి గుర్తులు దూరం> = “. $ దూరం));
[{“ఐడి”: 1, ”పేరు”: ”ఫ్రాంకీ జానీ & లుయిగో టూ”, ”చిరునామా”: ”939 W ఎల్ కామినో రియల్, మౌంటెన్ వ్యూ, CA”, ”లాట్”: 37.386337280273, ”lng”: - 122.08582305908, ”దూరం”: 16079.294719663}, {“id”: 2, ”పేరు”: ”అమిసి యొక్క ఈస్ట్ కోస్ట్ పిజ్జేరియా”, ”చిరునామా”: ”790 కాస్ట్రో సెయింట్, మౌంటెన్ వ్యూ, CA”, ”లాట్”: 37.387138366699, ”lng”: -122.08323669434, ”దూరం”: 16079.175940152}, {“id”: 3, ”పేరు”: ”కాప్స్ పిజ్జా బార్ & గ్రిల్”, ”చిరునామా”: ”191 కాస్ట్రో సెయింట్, మౌంటెన్ వ్యూ, CA”, ”లాట్”: 37.393886566162, . ”లాట్”: 122.07891845703, ”lng”: - 16078.381373826, ”దూరం”: 4}, {“id”: 570, ”name”: ”టోనీ & ఆల్బా పిజ్జా & పాస్తా”, ”చిరునామా”: ”37.402652740479 ఎస్క్యులా ఏవ్, మౌంటైన్ చూడండి, CA ”,” lat ”: 122.07935333252,” lng ”: - 16077.420540582,” దూరం ”: 5}, {“ id ”: 619,” name ”:” Oregano's Wood-Fired Pizza ”,” address ”:” 37.394012451172 ఎల్ కామినో రియల్, లాస్ ఆల్టోస్, సిఎ ”,” లాట్ ”: 122.09552764893,” lng ”: - 16078.563225154,” దూరం ”: 6}, {“ id ”: 4546,” name ”:” ది బార్స్ అండ్ గ్రిల్స్ ”,” చిరునామా ”:” 37.401725769043 వైట్లీ స్ట్రీట్, మాంచెస్టర్ ”,” లాట్ ”: 122.11464691162,” lng ”: - 16077.937560795,” దూరం ”: 7}]
నేను 20 మైళ్ళతో అడ్డు వరుసలను తిరిగి పొందాలనుకుంటున్నాను, కానీ ఇది అన్ని అడ్డు వరుసలను తెస్తుంది. దయచేసి నేను ఏమి తప్పు చేస్తున్నాను
నేను ఇదే ప్రశ్న కోసం చూస్తున్నాను కానీ కొంచెం ముందుకు వచ్చాను - సంక్షిప్తంగా ఇది ప్రతి కోఆర్డినేట్కి 2 మైళ్ల దూరంలో ఉన్న అన్ని కోఆర్డినేట్లను గ్రూప్ చేయడం మరియు ఆపై ప్రతి గ్రూపులో ఎన్ని కోఆర్డినేట్లను లెక్కించడం మరియు ఎక్కువ కోఆర్డినేట్లు ఉన్న ఒక గ్రూప్ని మాత్రమే అవుట్పుట్ చేయడం అత్యధిక సంఖ్యలో కోఆర్డినేట్లను కలిగి ఉన్న సమూహాలలో మీకు ఒకటి కంటే ఎక్కువ సమూహాలు ఉన్నాయి - ఒకే అతిపెద్ద సంఖ్య కలిగిన సమూహాల నుండి యాదృచ్ఛిక సమూహాన్ని అవుట్పుట్ చేయండి -