如何消除速度测量过程中出现的不可预测速度峰值？

嘿，针对你用Core Location开发速度追踪服务时遇到的不可预测速度峰值问题，我结合你的代码场景，整理了几个实用的解决方案，你可以根据自己的业务需求来选择：

1. 滑动窗口平均法（最易实现的平滑方案） #

这个方法的核心是保存最近N个有效速度值，每次计算时取它们的平均值，能有效抹平偶然出现的峰值。你可以在类里添加一个数组来存储历史速度：

// 类属性：保存最近5个有效速度值（数量可根据需求调整）
private var recentSpeeds: [Double] = []
private let maxRecentSpeedCount = 5

然后修改你的processLocation方法：

private func processLocation(_ current: CLLocation) {
    guard let lastLocation = lastLocation else {
        self.lastLocation = current
        speed.value = 0
        return
    }
    
    var calculatedSpeed: Double
    if current.speed > 0 {
        calculatedSpeed = current.speed
    } else {
        let distance = lastLocation.distance(from: current)
        let timeInterval = current.timestamp.timeIntervalSince(lastLocation.timestamp)
        // 避免除以0的情况
        guard timeInterval > 0 else {
            speed.value = speed.value // 保持当前值
            return
        }
        calculatedSpeed = distance / timeInterval
    }
    
    // 加入滑动窗口处理
    recentSpeeds.append(calculatedSpeed)
    if recentSpeeds.count > maxRecentSpeedCount {
        recentSpeeds.removeFirst()
    }
    
    // 计算平均值作为最终速度
    let averageSpeed = recentSpeeds.reduce(0, +) / Double(recentSpeeds.count)
    speed.value = averageSpeed
    
    self.lastLocation = current
}

2. 阈值过滤法（直接拦截不合理峰值） #

根据你的使用场景设定一个合理的最大速度阈值（比如步行场景设10m/s，城市驾车设25m/s），当计算出的速度超过阈值时，直接丢弃该值，改用之前的有效速度或者窗口平均值：

// 类属性：根据场景调整阈值，这里以城市道路为例
private let maxAllowedSpeed: Double = 25.0 // 单位：m/s

private func processLocation(_ current: CLLocation) {
    guard let lastLocation = lastLocation else {
        self.lastLocation = current
        speed.value = 0
        return
    }
    
    var calculatedSpeed: Double
    if current.speed > 0 {
        calculatedSpeed = current.speed
    } else {
        let distance = lastLocation.distance(from: current)
        let timeInterval = current.timestamp.timeIntervalSince(lastLocation.timestamp)
        guard timeInterval > 0 else {
            speed.value = speed.value
            return
        }
        calculatedSpeed = distance / timeInterval
    }
    
    // 阈值过滤
    if calculatedSpeed > maxAllowedSpeed {
        // 可以选择用之前的速度，或者滑动窗口平均值
        calculatedSpeed = speed.value
    }
    
    speed.value = calculatedSpeed
    self.lastLocation = current
}

3. 卡尔曼滤波（高精度场景首选） #

如果你的场景对速度精度要求很高，卡尔曼滤波是个不错的选择，它能基于历史数据预测当前速度，再结合测量值修正，有效过滤噪声。这里给你一个简化的实现：

// 类属性：卡尔曼滤波相关参数
private var kalmanGain: Double = 0.0
private var estimateError: Double = 1.0
private var measurementError: Double = 0.5

private func applyKalmanFilter(measurement: Double) -> Double {
    // 更新卡尔曼增益
    kalmanGain = estimateError / (estimateError + measurementError)
    // 修正估计值
    let estimatedSpeed = speed.value + kalmanGain * (measurement - speed.value)
    // 更新估计误差
    estimateError = (1 - kalmanGain) * estimateError
    return estimatedSpeed
}

// 在processLocation中调用
private func processLocation(_ current: CLLocation) {
    guard let lastLocation = lastLocation else {
        self.lastLocation = current
        speed.value = 0
        return
    }
    
    var calculatedSpeed: Double
    if current.speed > 0 {
        calculatedSpeed = current.speed
    } else {
        let distance = lastLocation.distance(from: current)
        let timeInterval = current.timestamp.timeIntervalSince(lastLocation.timestamp)
        guard timeInterval > 0 else {
            speed.value = speed.value
            return
        }
        calculatedSpeed = distance / timeInterval
    }
    
    // 应用卡尔曼滤波
    speed.value = applyKalmanFilter(measurement: calculatedSpeed)
    self.lastLocation = current
}

额外小技巧：位置合理性校验 #

有时候峰值是因为Core Location返回了异常的位置点（比如GPS漂移），你可以先校验两个位置之间的距离是否合理，比如短时间内出现几公里的位移，直接忽略该位置：

private func processLocation(_ current: CLLocation) {
    guard let lastLocation = lastLocation else {
        self.lastLocation = current
        speed.value = 0
        return
    }
    
    let distance = lastLocation.distance(from: current)
    let timeInterval = current.timestamp.timeIntervalSince(lastLocation.timestamp)
    
    // 校验位移合理性：比如1秒内位移不超过50米（根据场景调整）
    guard timeInterval > 0 && distance / timeInterval <= 50 else {
        speed.value = speed.value
        return
    }
    
    var calculatedSpeed: Double
    if current.speed > 0 {
        calculatedSpeed = current.speed
    } else {
        calculatedSpeed = distance / timeInterval
    }
    
    speed.value = calculatedSpeed
    self.lastLocation = current
}

你可以单独用某一种方法，也可以组合使用（比如先阈值过滤，再滑动窗口平均），效果会更好。

内容的提问来源于stack exchange，提问作者Oleg Gordiichuk