मुझे एक महान सर्कल दूरी बनाने के लिए अजगर का उपयोग करने की आवश्यकता है - दोनों एक संख्या, और अधिमानतः कुछ प्रकार के 'वक्र' जो मैं क्लाइंट-साइड मैप में आकर्षित करने के लिए उपयोग कर सकता हूं। मैं वक्र के प्रारूप के बारे में परवाह नहीं करता - चाहे वह डब्ल्यूकेटी हो, या निर्देशांक के जोड़े का एक सेट - लेकिन बस डेटा बाहर निकालना चाहता हूं।
वहाँ क्या उपकरण हैं? मुझे क्या उपयोग करना चाहिए?
जवाबों:
यहां कुछ लिंक दिए गए हैं जो मदद कर सकते हैं:
http://www.koders.com/python/fid0A930D7924AE856342437CA1F5A9A3EC0CAEACE2.aspx http://code.activestate.com/recipes/393241-calculating-the-distance-between-zip-codes/कोड
दूसरों द्वारा प्रदान किए गए उत्तर थोड़े अधिक सुरुचिपूर्ण हैं, लेकिन यहां एक अल्टिमिम्पल, कुछ हद तक अप्रभावी, थोड़ा पायथन है जो मूल बातें प्रदान करता है। फ़ंक्शन दो समन्वित जोड़े और एक उपयोगकर्ता-निर्दिष्ट सेगमेंट लेता है। यह एक महान सर्कल पथ के साथ मध्यवर्ती बिंदुओं का एक सेट देता है। आउटपुट: KML के रूप में लिखने के लिए तैयार पाठ। कैविट्स: कोड एंटीपोड्स पर विचार नहीं करता है, और एक गोलाकार पृथ्वी मानता है।
एलन ग्लेनॉन द्वारा कोड http://enj.com जुलाई 2010 (लेखक इस कोड को सार्वजनिक डोमेन में रखता है। अपने जोखिम पर उपयोग करें)।
-
डीआईएन ट्विनेस (देशांतर 1, अक्षांश 1, देशांतर 2, अक्षांश 2, संख्या_अंकांश):
import math
ptlon1 = longitude1
ptlat1 = latitude1
ptlon2 = longitude2
ptlat2 = latitude2
numberofsegments = num_of_segments
onelessthansegments = numberofsegments - 1
fractionalincrement = (1.0/onelessthansegments)
ptlon1_radians = math.radians(ptlon1)
ptlat1_radians = math.radians(ptlat1)
ptlon2_radians = math.radians(ptlon2)
ptlat2_radians = math.radians(ptlat2)
distance_radians=2*math.asin(math.sqrt(math.pow((math.sin((ptlat1_radians-ptlat2_radians)/2)),2) + math.cos(ptlat1_radians)*math.cos(ptlat2_radians)*math.pow((math.sin((ptlon1_radians-ptlon2_radians)/2)),2)))
# 6371.009 represents the mean radius of the earth
# shortest path distance
distance_km = 6371.009 * distance_radians
mylats = []
mylons = []
# write the starting coordinates
mylats.append([])
mylons.append([])
mylats[0] = ptlat1
mylons[0] = ptlon1
f = fractionalincrement
icounter = 1
while (icounter < onelessthansegments):
icountmin1 = icounter - 1
mylats.append([])
mylons.append([])
# f is expressed as a fraction along the route from point 1 to point 2
A=math.sin((1-f)*distance_radians)/math.sin(distance_radians)
B=math.sin(f*distance_radians)/math.sin(distance_radians)
x = A*math.cos(ptlat1_radians)*math.cos(ptlon1_radians) + B*math.cos(ptlat2_radians)*math.cos(ptlon2_radians)
y = A*math.cos(ptlat1_radians)*math.sin(ptlon1_radians) + B*math.cos(ptlat2_radians)*math.sin(ptlon2_radians)
z = A*math.sin(ptlat1_radians) + B*math.sin(ptlat2_radians)
newlat=math.atan2(z,math.sqrt(math.pow(x,2)+math.pow(y,2)))
newlon=math.atan2(y,x)
newlat_degrees = math.degrees(newlat)
newlon_degrees = math.degrees(newlon)
mylats[icounter] = newlat_degrees
mylons[icounter] = newlon_degrees
icounter += 1
f = f + fractionalincrement
# write the ending coordinates
mylats.append([])
mylons.append([])
mylats[onelessthansegments] = ptlat2
mylons[onelessthansegments] = ptlon2
# Now, the array mylats[] and mylons[] have the coordinate pairs for intermediate points along the geodesic
# My mylat[0],mylat[0] and mylat[num_of_segments-1],mylat[num_of_segments-1] are the geodesic end points
# write a kml of the results
zipcounter = 0
kmlheader = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><kml xmlns=\"http://www.opengis.net/kml/2.2\"><Document><name>LineString.kml</name><open>1</open><Placemark><name>unextruded</name><LineString><extrude>1</extrude><tessellate>1</tessellate><coordinates>"
print kmlheader
while (zipcounter < numberofsegments):
outputstuff = repr(mylons[zipcounter]) + "," + repr(mylats[zipcounter]) + ",0 "
print outputstuff
zipcounter += 1
kmlfooter = "</coordinates></LineString></Placemark></Document></kml>"
print kmlfooter
जियोग्राफिकलिब में एक अजगर इंटरफ़ेस है :
यह एक दीर्घवृत्त पर कंप्यूटर जियोडेसिक्स कर सकता है (महान मंडलियों को प्राप्त करने के लिए शून्य को समतल करता है) और एक जियोडेसिक पर मध्यवर्ती बिंदु उत्पन्न कर सकता है (नमूने में "रेखा" कमांड देखें)।
यहाँ JFK से चांगी हवाई अड्डे (सिंगापुर) तक की जियोडेसिक लाइन पर अंक कैसे प्रिंट करें:
from geographiclib.geodesic import Geodesic
geod = Geodesic.WGS84
g = geod.Inverse(40.6, -73.8, 1.4, 104)
l = geod.Line(g['lat1'], g['lon1'], g['azi1'])
num = 15 # 15 intermediate steps
for i in range(num+1):
pos = l.Position(i * g['s12'] / num)
print(pos['lat2'], pos['lon2'])
->
(40.60, -73.8)
(49.78, -72.99)
(58.95, -71.81)
(68.09, -69.76)
(77.15, -65.01)
(85.76, -40.31)
(83.77, 80.76)
(74.92, 94.85)
...pyproj में Geod.npts फ़ंक्शन है जो पथ के साथ बिंदुओं की एक सरणी लौटाएगा। ध्यान दें कि इसमें सरणी में टर्मिनल बिंदु शामिल नहीं हैं, इसलिए आपको उन्हें ध्यान में रखना होगा:
import pyproj
# calculate distance between points
g = pyproj.Geod(ellps='WGS84')
(az12, az21, dist) = g.inv(startlong, startlat, endlong, endlat)
# calculate line string along path with segments <= 1 km
lonlats = g.npts(startlong, startlat, endlong, endlat,
1 + int(dist / 1000))
# npts doesn't include start/end points, so prepend/append them
lonlats.insert(0, (startlong, startlat))
lonlats.append((endlong, endlat))पाइथन के लिए जियोकोडिंग टूलबॉक्स जियोफाई
http://code.google.com/p/geopy/wiki/GettingStarted#Calculating_distances
मैंने इस पैकेज का उपयोग नहीं किया है, लेकिन यह दिलचस्प लगता है, और एक संभावित समाधान: http://trac.gispython.org/lab/wiki/Shapely
Shapely is a Python package for set-theoretic analysis and manipulation of **planar** features