హేవర్సిన్ ఫార్ములా (PHP, JavaScript, Java, Python, MySQL, MSSQL ఉదాహరణలు) ఉపయోగించి అక్షాంశం మరియు రేఖాంశాల మధ్య గ్రేట్ సర్కిల్ దూరాన్ని లెక్కించండి లేదా ప్రశ్నించండి
ఈ నెల, నేను 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 పాయింట్ల మధ్య దూరాన్ని లెక్కించండి
public static double getDistanceBetweenPointsNew(double latitude1, double longitude1, double latitude2, double longitude2, String unit) {
double theta = longitude1 - longitude2;
double distance = 60 * 1.1515 * (180/Math.PI) * Math.acos(
Math.sin(latitude1 * (Math.PI/180)) * Math.sin(latitude2 * (Math.PI/180)) +
Math.cos(latitude1 * (Math.PI/180)) * Math.cos(latitude2 * (Math.PI/180)) * Math.cos(theta * (Math.PI/180))
);
if (unit.equals("miles")) {
return Math.round(distance, 2);
} else if (unit.equals("kilometers")) {
return Math.round(distance * 1.609344, 2);
} else {
return 0;
}
}
వేరియబుల్స్:
- అక్షాంశం1 – మీ మొదటి స్థానం యొక్క అక్షాంశం కోసం వేరియబుల్.
- రేఖాంశం1 – మీ మొదటి స్థానం యొక్క రేఖాంశం కోసం వేరియబుల్
- అక్షాంశం2 – మీ రెండవ స్థానం యొక్క అక్షాంశం కోసం వేరియబుల్.
- రేఖాంశం2 – మీ రెండవ స్థానం యొక్క రేఖాంశం కోసం వేరియబుల్.
- యూనిట్ - డిఫాల్ట్ జీవి వేల. దీన్ని ఇలా అప్డేట్ చేయవచ్చు లేదా పాస్ చేయవచ్చు కిలోమీటర్ల.
జావాస్క్రిప్ట్: అక్షాంశం మరియు రేఖాంశం యొక్క 2 పాయింట్ల మధ్య దూరాన్ని లెక్కించండి
function getDistanceBetweenPoints(latitude1, longitude1, latitude2, longitude2, unit = 'miles') {
let theta = longitude1 - longitude2;
let distance = 60 * 1.1515 * (180/Math.PI) * Math.acos(
Math.sin(latitude1 * (Math.PI/180)) * Math.sin(latitude2 * (Math.PI/180)) +
Math.cos(latitude1 * (Math.PI/180)) * Math.cos(latitude2 * (Math.PI/180)) * Math.cos(theta * (Math.PI/180))
);
if (unit == 'miles') {
return Math.round(distance, 2);
} else if (unit == 'kilometers') {
return Math.round(distance * 1.609344, 2);
}
}
వేరియబుల్స్:
- అక్షాంశం1 – మీ మొదటి స్థానం యొక్క అక్షాంశం కోసం వేరియబుల్.
- రేఖాంశం1 – మీ మొదటి స్థానం యొక్క రేఖాంశం కోసం వేరియబుల్
- అక్షాంశం2 – మీ రెండవ స్థానం యొక్క అక్షాంశం కోసం వేరియబుల్.
- రేఖాంశం2 – మీ రెండవ స్థానం యొక్క రేఖాంశం కోసం వేరియబుల్.
- యూనిట్ - డిఫాల్ట్ జీవి వేల. దీన్ని ఇలా అప్డేట్ చేయవచ్చు లేదా పాస్ చేయవచ్చు కిలోమీటర్ల.
పైథాన్: అక్షాంశం మరియు రేఖాంశం యొక్క 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: అక్షాంశం మరియు రేఖాంశాన్ని ఉపయోగించి మైళ్లలో దూరాన్ని లెక్కించడం ద్వారా ఒక పరిధిలో అన్ని రికార్డులను తిరిగి పొందడం
MySQLలో ప్రాదేశిక డేటా రకాలను ఉపయోగించడం అనేది పాయింట్ల మధ్య దూరాలను లెక్కించడంతోపాటు భౌగోళిక డేటాతో పని చేయడానికి మరింత సమర్థవంతమైన మరియు అనుకూలమైన మార్గం. MySQL వంటి ప్రాదేశిక డేటా రకాలకు మద్దతు ఇస్తుంది POINT
, LINESTRING
మరియు POLYGON
, వంటి ప్రాదేశిక విధులతో పాటు ST_Distance
.
మీరు ఉపయోగించినప్పుడు ST_Distance
భౌగోళిక డేటాతో MySQLలో ఫంక్షన్ సూచించబడుతుంది POINT
కోఆర్డినేట్స్, ఇది భూమి యొక్క ఉపరితలం యొక్క వక్రతను పరిగణనలోకి తీసుకుంటుంది. ఉపయోగించిన గోళాకార నమూనా ST_Distance
Haversine సూత్రాన్ని ఉపయోగిస్తుంది. ఈ ఉజ్జాయింపు చాలా ఆచరణాత్మక ప్రయోజనాల కోసం అనుకూలంగా ఉంటుంది, కానీ చాలా దూరాలకు కొంచెం సరికాని వాటిని పరిచయం చేయవచ్చు.
ప్రాదేశిక డేటా రకాలను ఉపయోగించి మీరు రెండు పాయింట్ల మధ్య దూరాలను ఎలా లెక్కించవచ్చో ఇక్కడ ఉంది:
- ప్రాదేశిక డేటా రకంతో పట్టికను సృష్టించండి: ముందుగా, a తో పట్టికను సృష్టించండి
POINT
భౌగోళిక పాయింట్లను నిల్వ చేయడానికి కాలమ్. ఉదాహరణకి:
CREATE TABLE locations (
id INT AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(255),
coordinates POINT
);
ఉపయోగించి ఈ పట్టికలో మీ భౌగోళిక పాయింట్లను చొప్పించండి POINT
కన్స్ట్రక్టర్:
INSERT INTO locations (name, coordinates)
VALUES
('Point A', POINT(40.7128, -74.0060)), -- New York City
('Point B', POINT(34.0522, -118.2437)); -- Los Angeles
- ST_Distanceని ఉపయోగించి దూరాన్ని లెక్కించండి: మీరు ఉపయోగించి రెండు పాయింట్ల మధ్య దూరాన్ని లెక్కించవచ్చు
ST_Distance
ఫంక్షన్. రెండు పాయింట్ల మధ్య దూరాన్ని లెక్కించడానికి ఇక్కడ ఒక ఉదాహరణ ప్రశ్న ఉంది:
SELECT
id1,
id2,
(ST_Distance(coordinates1, coordinates2) / 1609.344) AS distance_in_miles
FROM (
SELECT
l1.id AS id1,
l2.id AS id2,
l1.coordinates AS coordinates1,
l2.coordinates AS coordinates2
FROM
locations l1,
locations l2
WHERE
l1.id = 1 AND l2.id = 2
) AS distances;
పునఃస్థాపించుము 1
మరియు 2
రెండు పాయింట్ల IDలతో మీరు మధ్య దూరాన్ని లెక్కించాలనుకుంటున్నారు.
- ఫలితం: ప్రశ్న రెండు పాయింట్ల మధ్య దూరాన్ని మైళ్లలో చూపుతుంది.
ప్రాదేశిక డేటా రకాలను ఉపయోగించడం మరియు ST_Distance
MySQLలో భౌగోళిక డేటాతో పని చేయడానికి ఫంక్షన్ మరింత సమర్థవంతమైన మరియు ఖచ్చితమైన మార్గాన్ని అందిస్తుంది. ఇది పాయింట్ల మధ్య దూరాలను గణించడాన్ని కూడా సులభతరం చేస్తుంది, మీ డేటాను నిర్వహించడం మరియు ప్రశ్నించడం సులభం చేస్తుంది.
MySQL: అక్షాంశం మరియు రేఖాంశాన్ని ఉపయోగించి కిలోమీటర్లలో దూరాన్ని లెక్కించడం ద్వారా ఒక పరిధిలో అన్ని రికార్డులను తిరిగి పొందడం
అప్రమేయంగా ST_Distance
దూరాన్ని మీటర్లలో అందిస్తుంది, కాబట్టి మీరు కేవలం కిలోమీటర్ల కోసం ప్రశ్నను నవీకరించాలి:
SELECT
id1,
id2,
(ST_Distance(coordinates1, coordinates2) / 1000) AS distance_in_kilometers
FROM (
SELECT
l1.id AS id1,
l2.id AS id2,
l1.coordinates AS coordinates1,
l2.coordinates AS coordinates2
FROM
locations l1,
locations l2
WHERE
l1.id = 1 AND l2.id = 2
) AS distances;
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);
వద్ద వ్యవస్థాపకుడు మరియు సీనియర్ ఆర్కిటెక్ట్ అయిన మనష్ సాహూకి టోపీ చిట్కా అయాన్ మూడు.