यहां एक साधारण कलमान फ़िल्टर है जिसका उपयोग इस स्थिति के लिए किया जा सकता है। यह एंड्रॉइड उपकरणों पर किए गए कुछ कामों से आया था।
सामान्य कलामैन फ़िल्टर सिद्धांत वैक्टरस मैट्रिस द्वारा प्रतिनिधित्व अनुमानों की सटीकता के साथ वैक्टरों के अनुमानों के बारे में है। हालांकि, एंड्रॉइड उपकरणों पर स्थान का आकलन करने के लिए सामान्य सिद्धांत एक बहुत ही साधारण मामले में कम हो जाता है। एंड्रॉइड लोकेशन प्रदाता एक अक्षांश और देशांतर के रूप में स्थान देते हैं, साथ ही सटीकता के साथ जो मीटर में मापा गया एकल संख्या के रूप में निर्दिष्ट किया जाता है। इसका मतलब है कि एक कॉन्वर्स मैट्रिक्स की बजाय, कलमैन फ़िल्टर में सटीकता को एक ही संख्या से मापा जा सकता है, भले ही कलमान फ़िल्टर में स्थान दो संख्याओं से मापा जाता है। यह भी तथ्य कि अक्षांश, देशांतर और मीटर प्रभावी रूप से सभी अलग-अलग इकाइयों को अनदेखा किया जा सकता है, क्योंकि यदि आप कलमैन फ़िल्टर में स्केलिंग कारकों को सभी इकाइयों में परिवर्तित करने के लिए डालते हैं, तो परिणाम स्केल करने के बाद उन स्केलिंग कारकों को रद्द करना समाप्त हो जाता है मूल इकाइयों में वापस।
कोड को बेहतर किया जा सकता है, क्योंकि यह मानता है कि वर्तमान स्थान का सबसे अच्छा अनुमान अंतिम ज्ञात स्थान है, और यदि कोई आगे बढ़ रहा है तो बेहतर अनुमान लगाने के लिए एंड्रॉइड के सेंसर का उपयोग करना संभव होना चाहिए। कोड में एक सिंगल फ्री पैरामीटर क्यू है, प्रति सेकेंड मीटर में व्यक्त किया गया है, जो वर्णन करता है कि किसी भी नए स्थान अनुमानों की अनुपस्थिति में सटीकता कितनी जल्दी समाप्त होती है। एक उच्च क्यू पैरामीटर का मतलब है कि सटीकता तेजी से क्षय हो जाती है। काल्मैन फ़िल्टर आम तौर पर बेहतर काम करते हैं जब शुद्धता एक से अधिक तेज हो सकती है, इसलिए एक एंड्रॉइड फोन के साथ घूमने के लिए मुझे लगता है कि क्यू = 3 मीटर प्रति सेकेंड ठीक काम करता है, भले ही मैं आम तौर पर उससे धीमा चलता हूं। लेकिन अगर एक तेज कार में यात्रा करना बहुत अधिक संख्या का उपयोग किया जाना चाहिए।
public class KalmanLatLong {
private final float MinAccuracy = 1;
private float Q_metres_per_second;
private long TimeStamp_milliseconds;
private double lat;
private double lng;
private float variance; // P matrix. Negative means object uninitialised. NB: units irrelevant, as long as same units used throughout
public KalmanLatLong(float Q_metres_per_second) { this.Q_metres_per_second = Q_metres_per_second; variance = -1; }
public long get_TimeStamp() { return TimeStamp_milliseconds; }
public double get_lat() { return lat; }
public double get_lng() { return lng; }
public float get_accuracy() { return (float)Math.sqrt(variance); }
public void SetState(double lat, double lng, float accuracy, long TimeStamp_milliseconds) {
this.lat=lat; this.lng=lng; variance = accuracy * accuracy; this.TimeStamp_milliseconds=TimeStamp_milliseconds;
}
/// <summary>
/// Kalman filter processing for lattitude and longitude
/// </summary>
/// <param name="lat_measurement_degrees">new measurement of lattidude</param>
/// <param name="lng_measurement">new measurement of longitude</param>
/// <param name="accuracy">measurement of 1 standard deviation error in metres</param>
/// <param name="TimeStamp_milliseconds">time of measurement</param>
/// <returns>new state</returns>
public void Process(double lat_measurement, double lng_measurement, float accuracy, long TimeStamp_milliseconds) {
if (accuracy < MinAccuracy) accuracy = MinAccuracy;
if (variance < 0) {
// if variance < 0, object is unitialised, so initialise with current values
this.TimeStamp_milliseconds = TimeStamp_milliseconds;
lat=lat_measurement; lng = lng_measurement; variance = accuracy*accuracy;
} else {
// else apply Kalman filter methodology
long TimeInc_milliseconds = TimeStamp_milliseconds - this.TimeStamp_milliseconds;
if (TimeInc_milliseconds > 0) {
// time has moved on, so the uncertainty in the current position increases
variance += TimeInc_milliseconds * Q_metres_per_second * Q_metres_per_second/1000;
this.TimeStamp_milliseconds = TimeStamp_milliseconds;
// TO DO: USE VELOCITY INFORMATION HERE TO GET A BETTER ESTIMATE OF CURRENT POSITION
}
// Kalman gain matrix K = Covarariance * Inverse(Covariance + MeasurementVariance)
// NB: because K is dimensionless, it doesn't matter that variance has different units to lat and lng
float K = variance/(variance + accuracy * accuracy);
// apply K
lat += K * (lat_measurement - lat);
lng += K * (lng_measurement - lng);
// new Covarariance matrix is (IdentityMatrix - K) * Covarariance
variance = (1 - K) * variance;
}
}
}
मैं "जीपीएस शोर 'के बुरे प्रभावों को लगता है जब जुड़े (व्युत्पन्न) जो (के बाद से समय पूर्णांक है विशेष रूप से उच्च नमूना दर tracklogs के लिए बहुत असंतत हैं की गति और ढाल की तरह मान, गणना करने के लिए कोशिश कर रहा है [एक सेकंड] संकल्प)। – heltonbiker
(यदि आप मुख्य सड़कों के माध्यम से नेविगेट कर रहे हैं, तो भी आप "सड़कों पर स्नैप" एल्गोरिदम का उपयोग कर सकते हैं बशर्ते आपके पास एक अच्छा [सही, सटीक] रोडमैप डेटासेट हो। बस एक विचार) – heltonbiker
मुझे सर्वश्रेष्ठ सटीकता के लिए भी इस समस्या का सामना करना पड़ रहा है। – ViruMax