我正在使用GPS数据,每秒获取值并在地图上显示当前位置。问题在于,有时(特别是在精度较低的情况下)值会变化很大,从而使当前位置在地图上的远点之间“跳转”。
我想知道一种避免这种情况的足够简单的方法。作为第一个想法,我考虑过丢弃精度超过特定阈值的值,但是我猜想还有其他更好的方法。程序执行此操作的通常方式是什么?
我正在使用GPS数据,每秒获取值并在地图上显示当前位置。问题在于,有时(特别是在精度较低的情况下)值会变化很大,从而使当前位置在地图上的远点之间“跳转”。
我想知道一种避免这种情况的足够简单的方法。作为第一个想法,我考虑过丢弃精度超过特定阈值的值,但是我猜想还有其他更好的方法。程序执行此操作的通常方式是什么?
Answers:
这是一个简单的卡尔曼滤波器,可以用于这种情况。它来自我在Android设备上所做的一些工作。
一般的卡尔曼滤波理论都是关于向量的估计,其估计的准确性由协方差矩阵表示。但是,为了估计Android设备上的位置,一般理论简化为一个非常简单的情况。Android位置提供程序将位置表示为纬度和经度,以及指定为以米为单位的单个数字的精度。这意味着,可以用一个数字来测量卡尔曼滤波器中的精度,而不用协方差矩阵,即使卡尔曼滤波器中的位置可以用两个数字来衡量。同样,纬度,经度和米实际上都是所有不同单位的事实也可以忽略不计,因为如果您将比例因子放入卡尔曼滤波器中,以将它们全部转换为相同单位,
该代码可以进行改进,因为它假定当前位置的最佳估计是最后一个已知位置,并且如果有人在移动,则应该可以使用Android的传感器来产生更好的估计。该代码具有单个自由参数Q,以米/秒表示,描述了在没有任何新位置估计的情况下精度下降的速度。Q参数越高,意味着精度下降得越快。当精度下降的速度比人们预期的快一点时,卡尔曼滤波器通常会更好地工作,因此,对于Android手机,我发现Q = 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;
}
}
}
Q_metres_per_second
对应sigma
于该Wikipedia文章“相关过程”部分中的变量。 Q_metres_per_second
是标准偏差,以米为单位,因此以米而非米/秒为单位。1秒钟后,它对应于分布的标准偏差。
您正在寻找的是所谓的卡尔曼滤波器。它通常用于平滑导航数据。它不一定很琐碎,可以进行很多调整,但这是一种非常标准的方法,效果很好。有一个KFilter库是C ++实现的。
我的下一个后退将是最小二乘拟合。卡尔曼滤波器将考虑速度将数据平滑化,而最小二乘拟合法将仅使用位置信息。尽管如此,实现和理解绝对更简单。看起来GNU科学图书馆可能已经实现了。
这可能会晚一点...
我写了这个适用于Android的KalmanLocationManager,它包装了两个最常见的位置提供程序,即网络和GPS,对数据进行了kalman过滤,然后将更新提供给LocationListener
(如两个“真实”提供程序)。
我主要使用它在读数之间“插值”-例如,每100毫秒接收更新(位置预测)(而不是一秒钟的最大gps速率),这使我的位置动画时具有更好的帧速率。
实际上,它对每个维度使用三个卡尔曼滤波器:纬度,经度和海拔高度。无论如何,它们都是独立的。
这使矩阵数学更容易:我使用3个不同的2x2矩阵,而不是使用一个6x6状态转换矩阵。实际上,在代码中,我根本不使用矩阵。解决所有方程式,所有值均为基元(双精度)。
源代码正在运行,并且有一个演示活动。很抱歉在某些地方缺少javadoc,我会跟上。
您不应根据每次的位置变化来计算速度。GPS的位置可能不准确,但速度准确(高于5 km / h)。因此,请使用GPS位置标记中的速度。而且,尽管它在大多数情况下都是可行的,但您当然不应这样做。
交付的GPS位置已经经过卡尔曼滤波,您可能无法改善,在后处理中,您通常没有与GPS芯片相同的信息。
您可以使其平滑,但这也会引入错误。
只要确保您在设备静止不动时移开位置,即可移开跳跃位置,并且某些设备/配置不会移开。
我通常使用加速度计。在短时间内突然改变位置意味着高加速度。如果加速度计遥测中没有反映出这一点,那几乎可以肯定是由于用于计算位置的“最佳三颗”卫星的变化(我将其称为GPS远距传输)。
当资产处于静止状态并由于GPS传送而跳来跳去时,如果逐步计算质心,则实际上是在与越来越多的壳体相交,从而提高了精度。
为此,当资产处于静止状态时,您必须根据速度,航向以及线性和旋转(如果有陀螺仪)加速度数据估算其可能的下一个位置和方向。这或多或少是著名的K滤波器所做的。您可以在AHRS上以约$ 150的价格在硬件中获得整个东西,其中包含GPS模块以外的所有东西,并带有用于连接一个人的插孔。板载自己的CPU和卡尔曼滤波功能。结果稳定并且相当不错。惯性制导具有很高的抗抖动能力,但会随时间漂移。GPS容易抖动,但不会随时间漂移,实际上是使GPS相互补偿。
一种使用较少数学/理论的方法是一次采样2、5、7或10个数据点,然后确定那些异常值。与卡尔曼滤波器相比,离群值的准确度较低是使用以下算法来获取点之间的所有成对距离,并抛出距离其他点最远的点。通常,这些值将替换为最接近要替换的外围值的值
例如
在五个采样点A,B,C,D,E进行平滑
ATOTAL =距离的总和AB AC AD AE
BTOTAL =距离总和AB BC BD BE
CTOTAL =距离总和AC BC CD CE
DTOTAL =距离的总和DA DB DC DE
ETOTAL =距离总和EA EB EC DE
如果BTOTAL最大,则在BD = min {AB,BC,BD,BE}的情况下,将B点替换为D点
此平滑确定异常值,可以通过使用BD的中点而不是D点来进行平滑以增强位置线。您的里程可能会有所不同,并且存在数学上更严格的解决方案。
您也可以使用样条曲线。输入您拥有的值并在已知点之间插入点。将其与最小二乘拟合,移动平均或卡尔曼滤波器(如其他答案所述)链接在一起,即可计算出“已知”点之间的点。
能够在您的已知值之间进行插值,可以使您获得一个很好的平滑过渡,并且如果您具有更高的保真度,则可以合理/近似地显示出哪些数据。http://en.wikipedia.org/wiki/Spline_interpolation
不同的样条具有不同的特性。我见过的最常用的是Akima和Cubic样条曲线。
另一个要考虑的算法是Ramer-Douglas-Peucker线简化算法,它在GPS数据简化中非常常用。(http://en.wikipedia.org/wiki/Ramer-Douglas-Peucker_algorithm)
回到Kalman过滤器...我在这里找到了GPS数据的Kalman过滤器的C实现:http : //github.com/lacker/ikalman我还没有尝试过,但是看起来很有希望。
如果有人感兴趣,则映射到CoffeeScript。**编辑->对不起,也使用主干,但是您明白了。
稍加修改以接受带有attribs的信标
{纬度:item.lat,经度:item.lng,日期:新的Date(item.effective_at),精度:item.gps_accuracy}
MIN_ACCURACY = 1
# mapped from http://stackoverflow.com/questions/1134579/smooth-gps-data
class v.Map.BeaconFilter
constructor: ->
_.extend(this, Backbone.Events)
process: (decay,beacon) ->
accuracy = Math.max beacon.accuracy, MIN_ACCURACY
unless @variance?
# if variance nil, inititalise some values
@variance = accuracy * accuracy
@timestamp_ms = beacon.date.getTime();
@lat = beacon.latitude
@lng = beacon.longitude
else
@timestamp_ms = beacon.date.getTime() - @timestamp_ms
if @timestamp_ms > 0
# time has moved on, so the uncertainty in the current position increases
@variance += @timestamp_ms * decay * decay / 1000;
@timestamp_ms = beacon.date.getTime();
# 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
_k = @variance / (@variance + accuracy * accuracy)
@lat = _k * (beacon.latitude - @lat)
@lng = _k * (beacon.longitude - @lng)
@variance = (1 - _k) * @variance
[@lat,@lng]
@lat
和@lng
设置的最后几行中有一个错字。应该+=
而不是=
我已经将Java代码从@Stochastically转换为Kotlin
class KalmanLatLong
{
private val MinAccuracy: Float = 1f
private var Q_metres_per_second: Float = 0f
private var TimeStamp_milliseconds: Long = 0
private var lat: Double = 0.toDouble()
private var lng: Double = 0.toDouble()
private var variance: Float =
0.toFloat() // P matrix. Negative means object uninitialised. NB: units irrelevant, as long as same units used throughout
fun KalmanLatLong(Q_metres_per_second: Float)
{
this.Q_metres_per_second = Q_metres_per_second
variance = -1f
}
fun get_TimeStamp(): Long { return TimeStamp_milliseconds }
fun get_lat(): Double { return lat }
fun get_lng(): Double { return lng }
fun get_accuracy(): Float { return Math.sqrt(variance.toDouble()).toFloat() }
fun SetState(lat: Double, lng: Double, accuracy: Float, TimeStamp_milliseconds: Long)
{
this.lat = lat
this.lng = lng
variance = accuracy * accuracy
this.TimeStamp_milliseconds = TimeStamp_milliseconds
}
/// <summary>
/// Kalman filter processing for lattitude and longitude
/// /programming/1134579/smooth-gps-data/15657798#15657798
/// </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>
fun Process(lat_measurement: Double, lng_measurement: Double, accuracy: Float, TimeStamp_milliseconds: Long)
{
var accuracy = accuracy
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
val 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.toFloat() * 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
val 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
}
}
}
这是@Stochastically为需要的人提供的Java实现的Javascript实现:
class GPSKalmanFilter {
constructor (decay = 3) {
this.decay = decay
this.variance = -1
this.minAccuracy = 1
}
process (lat, lng, accuracy, timestampInMs) {
if (accuracy < this.minAccuracy) accuracy = this.minAccuracy
if (this.variance < 0) {
this.timestampInMs = timestampInMs
this.lat = lat
this.lng = lng
this.variance = accuracy * accuracy
} else {
const timeIncMs = timestampInMs - this.timestampInMs
if (timeIncMs > 0) {
this.variance += (timeIncMs * this.decay * this.decay) / 1000
this.timestampInMs = timestampInMs
}
const _k = this.variance / (this.variance + (accuracy * accuracy))
this.lat += _k * (lat - this.lat)
this.lng += _k * (lng - this.lng)
this.variance = (1 - _k) * this.variance
}
return [this.lng, this.lat]
}
}
用法示例:
const kalmanFilter = new GPSKalmanFilter()
const updatedCoords = []
for (let index = 0; index < coords.length; index++) {
const { lat, lng, accuracy, timestampInMs } = coords[index]
updatedCoords[index] = kalmanFilter.process(lat, lng, accuracy, timestampInMs)
}