ಹ್ಯಾವರ್ಸೈನ್ ಫಾರ್ಮುಲಾವನ್ನು ಬಳಸಿಕೊಂಡು ಅಕ್ಷಾಂಶ ಮತ್ತು ರೇಖಾಂಶದ ಬಿಂದುಗಳ ನಡುವಿನ ಗ್ರೇಟ್ ಸರ್ಕಲ್ ದೂರವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಿ ಅಥವಾ ಪ್ರಶ್ನಿಸಿ (PHP, JavaScript, Java, Python, MySQL, MSSQL ಉದಾಹರಣೆಗಳು)
ಈ ತಿಂಗಳು, ನಾನು GIS ಗಾಗಿ PHP ಮತ್ತು MySQL ನಲ್ಲಿ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಮಾಡುತ್ತಿದ್ದೇನೆ. ವಿಷಯವನ್ನು ಸಂಶೋಧಿಸುವಾಗ, ನನಗೆ ಹುಡುಕಲು ಕಷ್ಟವಾಯಿತು ಭೌಗೋಳಿಕ ಲೆಕ್ಕಾಚಾರಗಳು ಎರಡು ಸ್ಥಳಗಳ ನಡುವಿನ ಅಂತರವನ್ನು ಕಂಡುಹಿಡಿಯಲು, ನಾನು ಅವುಗಳನ್ನು ಇಲ್ಲಿ ಹಂಚಿಕೊಳ್ಳಲು ಬಯಸುತ್ತೇನೆ.
ಎರಡು ಬಿಂದುಗಳ ನಡುವಿನ ಅಂತರವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವ ಸರಳ ಮಾರ್ಗವೆಂದರೆ ತ್ರಿಕೋನದ (A² + B² = C²) ಹೈಪೋಟೆನ್ಯೂಸ್ ಅನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ಪೈಥಾಗರಿಯನ್ ಸೂತ್ರವನ್ನು ಬಳಸುವುದು. ಇದನ್ನು ದಿ ಯೂಕ್ಲಿಡಿಯನ್ ದೂರ.
ಇದು ಆಸಕ್ತಿದಾಯಕ ಆರಂಭವಾಗಿದೆ, ಆದರೆ ಇದು ಭೌಗೋಳಿಕತೆಗೆ ಅನ್ವಯಿಸುವುದಿಲ್ಲ ಏಕೆಂದರೆ ಅಕ್ಷಾಂಶ ಮತ್ತು ರೇಖಾಂಶದ ರೇಖೆಗಳ ನಡುವಿನ ಅಂತರ ಸಮಾನ ಅಂತರವಲ್ಲ. ನೀವು ಸಮಭಾಜಕಕ್ಕೆ ಹತ್ತಿರವಾಗುತ್ತಿದ್ದಂತೆ, ಅಕ್ಷಾಂಶದ ರೇಖೆಗಳು ಮತ್ತಷ್ಟು ದೂರವಾಗುತ್ತವೆ. ನೀವು ಸರಳ ತ್ರಿಕೋನ ಸಮೀಕರಣವನ್ನು ಬಳಸಿದರೆ, ಭೂಮಿಯ ವಕ್ರತೆಯ ಕಾರಣದಿಂದಾಗಿ ಅದು ಒಂದು ಸ್ಥಳದಲ್ಲಿ ನಿಖರವಾಗಿ ದೂರವನ್ನು ಅಳೆಯಬಹುದು ಮತ್ತು ಇನ್ನೊಂದು ಸ್ಥಳದಲ್ಲಿ ತಪ್ಪಾಗಬಹುದು.
ದೊಡ್ಡ ವೃತ್ತದ ದೂರ
ಭೂಮಿಯ ಸುತ್ತ ಬಹಳ ದೂರ ಪ್ರಯಾಣಿಸುವ ಮಾರ್ಗಗಳನ್ನು ಗ್ರೇಟ್ ಸರ್ಕಲ್ ಡಿಸ್ಟನ್ಸ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ಅಂದರೆ... ಗೋಳದ ಮೇಲಿನ ಎರಡು ಬಿಂದುಗಳ ನಡುವಿನ ಕಡಿಮೆ ಅಂತರವು ಸಮತಟ್ಟಾದ ನಕ್ಷೆಯಲ್ಲಿರುವ ಬಿಂದುಗಳಿಗಿಂತ ಭಿನ್ನವಾಗಿರುತ್ತದೆ. ಅಕ್ಷಾಂಶ ಮತ್ತು ರೇಖಾಂಶದ ರೇಖೆಗಳು ಸಮಾನ ದೂರದಲ್ಲಿಲ್ಲ ಎಂಬ ಅಂಶದೊಂದಿಗೆ ಅದನ್ನು ಸಂಯೋಜಿಸಿ… ಮತ್ತು ನೀವು ಕಷ್ಟಕರವಾದ ಲೆಕ್ಕಾಚಾರವನ್ನು ಪಡೆದುಕೊಂಡಿದ್ದೀರಿ.
ಗ್ರೇಟ್ ವಲಯಗಳು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಎಂಬುದರ ಅದ್ಭುತ ವೀಡಿಯೊ ವಿವರಣೆ ಇಲ್ಲಿದೆ.
ಹ್ಯಾವರ್ಸಿನ್ ಫಾರ್ಮುಲಾ
ಭೂಮಿಯ ವಕ್ರತೆಯನ್ನು ಬಳಸುವ ದೂರವನ್ನು ಹ್ಯಾವರ್ಸೈನ್ ಸೂತ್ರದಲ್ಲಿ ಅಳವಡಿಸಲಾಗಿದೆ, ಇದು ಭೂಮಿಯ ವಕ್ರತೆಯನ್ನು ಅನುಮತಿಸಲು ತ್ರಿಕೋನಮಿತಿಯನ್ನು ಬಳಸುತ್ತದೆ. ಭೂಮಿಯ ಮೇಲಿನ 2 ಸ್ಥಳಗಳ ನಡುವಿನ ಅಂತರವನ್ನು ನೀವು ಕಂಡುಕೊಂಡಾಗ (ಕಾಗೆ ಹಾರುವಂತೆ), ಸರಳ ರೇಖೆಯು ವಾಸ್ತವವಾಗಿ ಒಂದು ಚಾಪವಾಗಿದೆ.
ಇದು ಏರ್ ಫ್ಲೈಟ್ನಲ್ಲಿ ಅನ್ವಯಿಸುತ್ತದೆ - ನೀವು ಎಂದಾದರೂ ವಿಮಾನಗಳ ನಿಜವಾದ ನಕ್ಷೆಯನ್ನು ನೋಡಿದ್ದೀರಾ ಮತ್ತು ಅವುಗಳು ಕಮಾನುಗಳಾಗಿರುವುದನ್ನು ಗಮನಿಸಿದ್ದೀರಾ? ಏಕೆಂದರೆ ಎರಡು ಬಿಂದುಗಳ ನಡುವೆ ಕಮಾನುಗಳಲ್ಲಿ ಹಾರುವುದು ನೇರವಾಗಿ ಸ್ಥಳಕ್ಕಿಂತ ಚಿಕ್ಕದಾಗಿದೆ.
ಪಿಎಚ್ಪಿ: ಅಕ್ಷಾಂಶ ಮತ್ತು ರೇಖಾಂಶದ 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 - ನಿಮ್ಮ ಮೊದಲ ಸ್ಥಳದ ಅಕ್ಷಾಂಶಕ್ಕಾಗಿ ವೇರಿಯಬಲ್.
- $ರೇಖಾಂಶ1 - ನಿಮ್ಮ ಮೊದಲ ಸ್ಥಳದ ರೇಖಾಂಶಕ್ಕಾಗಿ ವೇರಿಯಬಲ್
- $Latitude2 - ನಿಮ್ಮ ಎರಡನೇ ಸ್ಥಳದ ಅಕ್ಷಾಂಶಕ್ಕಾಗಿ ವೇರಿಯಬಲ್.
- $ರೇಖಾಂಶ2 - ನಿಮ್ಮ ಎರಡನೇ ಸ್ಥಾನದ ರೇಖಾಂಶಕ್ಕಾಗಿ ವೇರಿಯೇಬಲ್.
- $ಘಟಕ - ಡೀಫಾಲ್ಟ್ ಜೀವಿ ಸಾವಿರಾರು. ಇದನ್ನು ನವೀಕರಿಸಬಹುದು ಅಥವಾ ಹೀಗೆ ರವಾನಿಸಬಹುದು ಕಿಲೋಮೀಟರ್.
ಜಾವಾ: ಅಕ್ಷಾಂಶ ಮತ್ತು ರೇಖಾಂಶದ 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
ಹ್ಯಾವರ್ಸಿನ್ ಸೂತ್ರವನ್ನು ಬಳಸುತ್ತದೆ. ಈ ಅಂದಾಜು ಹೆಚ್ಚಿನ ಪ್ರಾಯೋಗಿಕ ಉದ್ದೇಶಗಳಿಗೆ ಸೂಕ್ತವಾಗಿದೆ ಆದರೆ ಬಹಳ ದೂರದವರೆಗೆ ಸ್ವಲ್ಪ ತಪ್ಪುಗಳನ್ನು ಪರಿಚಯಿಸಬಹುದು.
ಪ್ರಾದೇಶಿಕ ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಎರಡು ಬಿಂದುಗಳ ನಡುವಿನ ಅಂತರವನ್ನು ನೀವು ಹೇಗೆ ಲೆಕ್ಕ ಹಾಕಬಹುದು ಎಂಬುದು ಇಲ್ಲಿದೆ:
- ಪ್ರಾದೇಶಿಕ ಡೇಟಾ ಪ್ರಕಾರದೊಂದಿಗೆ ಟೇಬಲ್ ರಚಿಸಿ: ಮೊದಲಿಗೆ, ಒಂದು ಟೇಬಲ್ ಅನ್ನು ರಚಿಸಿ
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;
ಮೈಕ್ರೋಸಾಫ್ಟ್ SQL ಸರ್ವರ್ ಭೌಗೋಳಿಕ ದೂರ: STDistance
ನೀವು ಮೈಕ್ರೋಸಾಫ್ಟ್ SQL ಸರ್ವರ್ ಅನ್ನು ಬಳಸುತ್ತಿದ್ದರೆ, ಅವರು ತಮ್ಮದೇ ಆದ ಕಾರ್ಯವನ್ನು ನೀಡುತ್ತಾರೆ, ಎಸ್ಟಿಡಿಸ್ಟನ್ಸ್ ಭೌಗೋಳಿಕ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ಬಳಸಿಕೊಂಡು ಎರಡು ಬಿಂದುಗಳ ನಡುವಿನ ಅಂತರವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು.
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);
ಸ್ಥಾಪಕ ಮತ್ತು ಹಿರಿಯ ವಾಸ್ತುಶಿಲ್ಪಿ ಮನಶ್ ಸಾಹೂ ಅವರಿಗೆ ಹ್ಯಾಟ್ ಟಿಪ್ ಅಯಾನ್ ಮೂರು.