如何使用 GPS 速度在 React Native 事故检测算法中过滤加速度数据中的噪声？

问：

我正在研究一个反应本机应用程序上的事故检测算法。 我使用以下两个因素进行预测：

• 使用传感器进行加速度（100 毫秒间隔平均超过 1 秒，用于数据存储限制和降噪）
• 使用 gps 的速度（1 秒间隔）

然而，从传感器获得的加速度充满了噪音，因为当我们用手机做非常简单的事情时，比如拿起或放下手机，会记录很多需要过滤掉的加速度。

我还想知道，在我的用例中，上述每个传感器的最佳间隔是考虑电池使用和准确性。

我尝试通过首先通过计算最终速度和初始速度之间的差异并除以时间戳的变化来预测加速度来过滤加速度。然后，将该预测加速度与观察到的加速度进行比较。

const filterAccelerationNoise = (acceleration, speed) => {
    const ACCELERATION_THRESHOLD = 10;

    //filter acceleration data to remove noise
    let noiseIndex = [];
    for (let i = 0; i < acceleration.length; i++) {
        let ts = acceleration[i].timestamp;
        let acc = acceleration[i].value;


        //find the closest data point in speed array
        // can apply tenary search here
        let { closestIdx, closestTs, closestSpd } = { closestIdx: -1, closestTs: Number.MAX_SAFE_INTEGER, closestSpd: null };
        for (let j = 0; j < speed.length; j++) {
            let diff = Math.abs(speed[j].timestamp - ts);
            if (diff < Math.abs(closestTs - ts)) {
                closestIdx = j;
                closestTs = speed[j].timestamp;
                closestSpd = speed[j].value;
            }
        }
        console.log(closestIdx, closestTs, closestSpd);
        if (closestIdx === -1) {
            noiseIndex.push(i);
            continue;
        }
        if (!nearby(ts, closestTs)) {
            closestSpd = 0;
        }
        let initialSpeed, finalSpeed, finalTs, initialTs;
        if (ts > closestTs) {
            initialSpeed = closestSpd;
            if (closestIdx + 1 >= speed.length) {
                finalSpeed = 0;
                finalTs = ts;
            } else {
                finalSpeed = speed[closestIdx + 1].value;
                if (!nearby(speed[closestIdx + 1].timestamp, ts)) {
                    finalSpeed = 0;
                }
                finalTs = speed[closestIdx + 1].timestamp;
            }
            initialTs = closestTs;
        }
        else {
            finalSpeed = closestSpd;
            if (closestIdx - 1 < 0) {
                initialSpeed = 0;
                initialTs = ts;
            } else {
                initialSpeed = speed[closestIdx - 1].value;
                if (!nearby(speed[closestIdx - 1].timestamp, ts)) {
                    initialSpeed = 0;
                }
                initialTs = speed[closestIdx - 1].timestamp;
            }
            finalTs = closestTs;
        }
        //compare acceleration with estimated acceleration
        let estimatedAcc = (finalSpeed - initialSpeed) / (finalTs - initialTs);
        if (Math.abs(estimatedAcc - acc) < ACCELERATION_THRESHOLD) {
            noiseIndex.push(i);
        }
    }
    for (let i = noiseIndex.length - 1; i >= 0; i--) {
        acceleration.splice(noiseIndex[i], 1);
    }
};