दिलचस्प पोस्ट
क्वेरी स्ट्रिंग पैरामीटर के जावा यूआरएल एन्कोडिंग Java.Util.Scanner के साथ NoSuchElementException java.net.UnknownHostException: सर्वर के लिए अमान्य होस्टनाम: स्थानीय जावास्क्रिप्ट बंद कैसे काम करता है? जावा में SIGINT कैप्चर करें कैसे अक्षम कॉपी, कट, चुनें, सभी का चयन करें UITextView में मैं कैसे दो divs रखता हूँ जो एक ही ऊंचाई से एक तरफ है? JQGrid: संपादित करने के बाद मैं एक ड्रॉपडाउन कैसे रिफ्रेश कर सकता हूँ? Mysql स्थानीयहोस्ट! = 127.0.0.1? एक शेल अगर कथन में कई स्थितियों का प्रतिनिधित्व कैसे करें? ActiveMq मिडलवेयर एकीकरण के साथ जर्सी आराम वेब सेवा रन-टाइम में अनुदान अनुमतियों की जांच कैसे करें? allowDefinition = 'MachineToApplication' त्रुटि जब VS2010 से प्रकाशित होता है (लेकिन केवल पिछले बिल्ड के बाद) भावना विश्लेषण के लिए nltk NaiveBayes क्लासीफायर प्रशिक्षण MATLAB में अनुलग्नक मैट्रिक्स का निर्माण

गणना असर w / Haversine फ़ंक्शन के लिए CLLocation श्रेणी

मैं CLLocation के लिए एक श्रेणी लिखने की कोशिश कर रहा हूं और इसे असर किसी अन्य CLLocation में वापस करने की कोशिश कर रहा हूं।

मेरा मानना ​​है कि मैं सूत्र के साथ कुछ गलत कर रहा हूं (गणक मेरे मजबूत सूट नहीं है)। लौटे हुए असर हमेशा बंद रहता है

मैं इस प्रश्न को देख रहा हूं और उन बदलावों को लागू करने की कोशिश कर रहा हूं जिन्हें एक सही जवाब और वेबपेज के संदर्भ में स्वीकार किया गया था:

दो CLLocationCoordinate2D के बीच असर की गणना करना

http://www.movable-type.co.uk/scripts/latlong.html

किसी भी संकेत के लिए धन्यवाद मैंने उस अन्य प्रश्न से प्रतिक्रिया को शामिल करने की कोशिश की और मुझे अभी भी कुछ नहीं मिल रहा है

धन्यवाद

यहां मेरी श्रेणी है –

—– CLLocation + Bearing.h

#import <Foundation/Foundation.h> #import <CoreLocation/CoreLocation.h> @interface CLLocation (Bearing) -(double) bearingToLocation:(CLLocation *) destinationLocation; -(NSString *) compassOrdinalToLocation:(CLLocation *) nwEndPoint; @end 

——— CLLocation + Bearing.m

 #import "CLLocation+Bearing.h" double DegreesToRadians(double degrees) {return degrees * M_PI / 180;}; double RadiansToDegrees(double radians) {return radians * 180/M_PI;}; @implementation CLLocation (Bearing) -(double) bearingToLocation:(CLLocation *) destinationLocation { double lat1 = DegreesToRadians(self.coordinate.latitude); double lon1 = DegreesToRadians(self.coordinate.longitude); double lat2 = DegreesToRadians(destinationLocation.coordinate.latitude); double lon2 = DegreesToRadians(destinationLocation.coordinate.longitude); double dLon = lon2 - lon1; double y = sin(dLon) * cos(lat2); double x = cos(lat1) * sin(lat2) - sin(lat1) * cos(lat2) * cos(dLon); double radiansBearing = atan2(y, x); return RadiansToDegrees(radiansBearing); } 

वेब के समाधान से एकत्रित समाधान "गणना असर w / Haversine फ़ंक्शन के लिए CLLocation श्रेणी"

आपका कोड मेरे लिए अच्छा लगता है गणना के साथ कुछ भी गलत नहीं आप निर्दिष्ट नहीं करते कि आपके परिणाम कितनी दूर हैं, लेकिन आप अपने रेडियन / डिग्री कन्वर्टर्स को यह करने की कोशिश कर सकते हैं:

 double DegreesToRadians(double degrees) {return degrees * M_PI / 180.0;}; double RadiansToDegrees(double radians) {return radians * 180.0/M_PI;}; 

यदि आप नकारात्मक बीयरिंग प्राप्त कर रहे हैं, तो अंतिम 2*M_PI को अंतिम परिणाम में जोड़ें] या (यदि आप इसे डिग्री में परिवर्तित करने के बाद करते हैं) -M_PI रिजल्ट में रेंज -M_PI को M_PI (-180 से 180 डिग्री) देता है, ताकि आप इसे कम्पास बीयरिंग में कन्वर्ट करना चाहें, जैसा कि निम्न कोड जैसा कुछ है

 if(radiansBearing < 0.0) radiansBearing += 2*M_PI; 

शुरुआत में श्रेणी की स्विफ्ट में यह एक पोर्टिंग है:

 import Foundation import CoreLocation public extension CLLocation{ func DegreesToRadians(_ degrees: Double ) -> Double { return degrees * M_PI / 180 } func RadiansToDegrees(_ radians: Double) -> Double { return radians * 180 / M_PI } func bearingToLocationRadian(_ destinationLocation:CLLocation) -> Double { let lat1 = DegreesToRadians(self.coordinate.latitude) let lon1 = DegreesToRadians(self.coordinate.longitude) let lat2 = DegreesToRadians(destinationLocation.coordinate.latitude); let lon2 = DegreesToRadians(destinationLocation.coordinate.longitude); let dLon = lon2 - lon1 let y = sin(dLon) * cos(lat2); let x = cos(lat1) * sin(lat2) - sin(lat1) * cos(lat2) * cos(dLon); let radiansBearing = atan2(y, x) return radiansBearing } func bearingToLocationDegrees(destinationLocation:CLLocation) -> Double{ return RadiansToDegrees(bearingToLocationRadian(destinationLocation)) } } 

यहाँ एक और कार्यान्वयन है

 public func bearingBetweenTwoPoints(#lat1 : Double, #lon1 : Double, #lat2 : Double, #lon2: Double) -> Double { func DegreesToRadians (value:Double) -> Double { return value * M_PI / 180.0 } func RadiansToDegrees (value:Double) -> Double { return value * 180.0 / M_PI } let y = sin(lon2-lon1) * cos(lat2) let x = (cos(lat1) * sin(lat2)) - (sin(lat1) * cos(lat2) * cos(lat2-lon1)) let degrees = RadiansToDegrees(atan2(y,x)) let ret = (degrees + 360) % 360 return ret; } 

मैं स्विफ्ट में कोजिन के कानून का उपयोग करता हूं यह हार्वेसिन की तुलना में तेज़ी से चलाता है और उसका परिणाम बहुत ही समान है। विशाल दूरी पर 1 मीटर के अंतर।

मैं कोज़िन के कानून का उपयोग क्यों करूं?

  • तेजी से भागो (क्योंकि कोई भी sqrt फ़ंक्शन नहीं है)
  • पर्याप्त सटीक जब तक आप कुछ खगोल विज्ञान करते हैं
  • एक पृष्ठभूमि कार्य के लिए बिल्कुल सही
 func calculateDistance(from: CLLocationCoordinate2D, to: CLLocationCoordinate2D) -> Double { let π = M_PI let degToRad: Double = π/180 let earthRadius: Double = 6372797.560856 // Law of Cosines formula // d = r . arc cos (sin 𝜑A sin 𝜑B + cos 𝜑A cos 𝜑B cos(𝜆B - 𝜆A) ) let 𝜑A = from.latitude * degToRad let 𝜑B = to.latitude * degToRad let 𝜆A = from.longitude * degToRad let 𝜆B = to.longitude * degToRad let angularDistance = acos(sin(𝜑A) * sin(𝜑B) + cos(𝜑A) * cos(𝜑B) * cos(𝜆B - 𝜆A) ) let distance = earthRadius * angularDistance return distance } 

काम स्विफ्ट 3 और 4

कई संस्करणों की कोशिश की और यह अंत में सही मूल्य देता है!

 extension CLLocation { func getRadiansFrom(degrees: Double ) -> Double { return degrees * .pi / 180 } func getDegreesFrom(radians: Double) -> Double { return radians * 180 / .pi } func bearingRadianTo(location: CLLocation) -> Double { let lat1 = self.getRadiansFrom(degrees: self.coordinate.latitude) let lon1 = self.getRadiansFrom(degrees: self.coordinate.longitude) let lat2 = self.getRadiansFrom(degrees: location.coordinate.latitude) let lon2 = self.getRadiansFrom(degrees: location.coordinate.longitude) let dLon = lon2 - lon1 let y = sin(dLon) * cos(lat2) let x = cos(lat1) * sin(lat2) - sin(lat1) * cos(lat2) * cos(dLon) var radiansBearing = atan2(y, x) if radiansBearing < 0.0 { radiansBearing += 2 * .pi } return radiansBearing } func bearingDegreesTo(location: CLLocation) -> Double { return self.getDegreesFrom(radians: self.bearingRadianTo(location: location)) } } 

उपयोग:

 let degrees = location1.bearingDegreesTo(location: location2) 

यह एक अन्य CLLocation एक्सटेंशन स्विफ्ट 3 और स्विफ्ट 4 में उपयोग किया जा सकता है

 public extension CLLocation { func degreesToRadians(degrees: Double) -> Double { return degrees * .pi / 180.0 } func radiansToDegrees(radians: Double) -> Double { return radians * 180.0 / .pi } func getBearingBetweenTwoPoints(point1: CLLocation, point2: CLLocation) -> Double { let lat1 = degreesToRadians(degrees: point1.coordinate.latitude) let lon1 = degreesToRadians(degrees: point1.coordinate.longitude) let lat2 = degreesToRadians(degrees: point2.coordinate.latitude) let lon2 = degreesToRadians(degrees: point2.coordinate.longitude) let dLon = lon2 - lon1 let y = sin(dLon) * cos(lat2) let x = cos(lat1) * sin(lat2) - sin(lat1) * cos(lat2) * cos(dLon) let radiansBearing = atan2(y, x) return radiansToDegrees(radians: radiansBearing) } }