28

I have a 3D sensor which measures v(x,y,z) data. I'm only using the x and y data. Smoothing only x and y would be enough.

If I use a log to show the data, it shows me something like this: (time) 0.1 ... (Data log) x = 1.1234566667 (time) 0.2 ... (Data log) x = 1.1245655666 (time) 0.3 ... (data log) x = 1.2344445555

Well the data is more exact actually, but I want to smooth between the 1.1234 value and the 1.2344 value, because for me it's the same, I can use integers to, showing only "x= 1" but I need the decimals too, then, I need to show a sort of "smoothed" value here.

Anyone has any idea? I'm programming in c# but not all the functions are working, so I need to build my own function.

4

6 回答 6

66

最简单的方法是对数据进行移动平均。也就是说，保持一系列传感器数据读数并对其进行平均。像这样的东西（伪代码）：

  data_X = [0,0,0,0,0];

  function read_X () {
      data_X.delete_first_element();
      data_X.push(get_sensor_data_X());
      return average(data_X);
   }

这样做时需要权衡取舍。您使用的数组越大，结果越平滑，但结果与实际读数之间的滞后越大。例如：

                           /\_/\
                        /\/     \_/\
  Sensor reading:  __/\/            \/\
                                       \/\  _/\___________
                                          \/
                              _
                           __/ \_
                       ___/      \__
  Small array:     ___/             \_/\_       _
                                         \   __/ \________
                                          \_/

                                 ____
                              __/    \__
                           __/           \__
  Large array:     _______/                 \__      __
                                               \_   /  \__
                                                 \_/


(forgive my ASCII-ART but I'm hoping it's good enough for illustration).

如果您想要快速响应但无论如何都需要良好的平滑度，那么您将使用数组的加权平均值。这基本上是数字信号处理（带有大写的 DSP），与其名称相反，它与模拟设计更密切相关。这是一篇关于它的简短维基百科文章（如果你想走这条路，你应该阅读好的外部链接）：http ://en.wikipedia.org/wiki/Digital_filter

以下是来自 SO 的一些关于可能满足您需求的低通滤波器的代码：低通滤波器软件？. 请注意，在该答案的代码中，他使用了一个大小为 4 的数组（或信号处理术语中的 4 阶，因为这样的滤波器称为四阶滤波器，它实际上可以通过四阶多项式方程建模：ax^4 + bx ^3 + cx^2 + dx)。

于 2011-01-06T04:35:36.193 回答
26

所以我来这里是为了解决同样的问题（Android 中的传感器输入平滑），这就是我想出的：

/*
 * time smoothing constant for low-pass filter
 * 0 ≤ α ≤ 1 ; a smaller value basically means more smoothing
 * See: http://en.wikipedia.org/wiki/Low-pass_filter#Discrete-time_realization
 */
static final float ALPHA = 0.2f;

protected float[] accelVals;

public void onSensorChanged(SensorEvent event) {
    if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER)
        accelVals = lowPass( event.values, accelVals );

    // use smoothed accelVals here; see this link for a simple compass example:
    // http://www.codingforandroid.com/2011/01/using-orientation-sensors-simple.html
}

/**
 * @see http://en.wikipedia.org/wiki/Low-pass_filter#Algorithmic_implementation
 * @see http://en.wikipedia.org/wiki/Low-pass_filter#Simple_infinite_impulse_response_filter
 */
protected float[] lowPass( float[] input, float[] output ) {
    if ( output == null ) return input;

    for ( int i=0; i<input.length; i++ ) {
        output[i] = output[i] + ALPHA * (input[i] - output[i]);
    }
    return output;
}

感谢@slebetman 将我指向 Wikipedia 链接，经过一番阅读后，该链接将我吸引到了 wikipedia Low-pass filter 文章中的算法。我不会发誓我拥有最好的算法（甚至是正确的！），但轶事证据似乎表明它正在发挥作用。

于 2011-04-25T16:30:06.720 回答
8

好吧，有很多方法可以平滑传感器数据，这取决于它是什么类型的传感器以及适合什么类比。我在我的项目中使用了这些算法：

  1. 高通滤波器 [HPF] 和低通滤波器 [LPF] - 如所选答案所示。
  2. 移动平均算法-MAA
  3. Gaely 算法mm[MAA 的更好版本]
  4. 快速傅里叶变换

代码：

HPF-高通滤波器

private float[] highPass(float x, float y, float z) {
    float[] filteredValues = new float[3];
    gravity[0] = ALPHA * gravity[0] + (1 – ALPHA) * x;
    gravity[1] = ALPHA * gravity[1] + (1 – ALPHA) * y;
    gravity[2] = ALPHA * gravity[2] + (1 – ALPHA) * z;
    filteredValues[0] = x – gravity[0];
    filteredValues[1] = y – gravity[1];
    filteredValues[2] = z – gravity[2];
    return filteredValues;   
    }

LPF-低通滤波器

private float[] lowPass(float x, float y, float z) {
    float[] filteredValues = new float[3];
    filteredValues[0] = x * a + filteredValues[0] * (1.0f – a);
    filteredValues[1] = y * a + filteredValues[1] * (1.0f – a);
    filteredValues[2] = z * a + filteredValues[2] * (1.0f – a);
    return filteredValues;
    }

MAA-移动平均线

     private final int SMOOTH_FACTOR_MAA = 2;//increase for better results   but hits cpu bad

     public ArrayList<Float> processWithMovingAverageGravity(ArrayList<Float> list, ArrayList<Float> gList) {
            int listSize = list.size();//input list
            int iterations = listSize / SMOOTH_FACTOR_MAA;
            if (!AppUtility.isNullOrEmpty(gList)) {
                gList.clear();
            }
            for (int i = 0, node = 0; i < iterations; i++) {
                float num = 0;
                for (int k = node; k < node + SMOOTH_FACTOR_MAA; k++) {
                    num = num + list.get(k);
                }
                node = node + SMOOTH_FACTOR_MAA;
                num = num / SMOOTH_FACTOR_MAA;
                gList.add(num);//out put list
            }
            return gList;
        }
于 2016-04-29T08:24:31.160 回答
2

这是一个基于iOS事件处理指南的 MotionEvents 部分中的逻辑的示例。

float ALPHA = 0.1;

protected float[] lowPass( float[] input, float[] output ) {
    if ( output == null ) return input;

    for ( int i=0; i<input.length; i++ ) {
        output[i] = (input[i] * ALPHA) + (ouptut[i] * (1.0 - ALPHA));
    }
    return output;
}
于 2012-12-18T21:09:43.930 回答
1

@thom_nic 的低通滤波器代码中有一个小但非常重要的错字，这种实现的结果有很大不同。

protected float[] lowPass( float[] input, float[] output ) {
    if ( output == null ) return input;

    for ( int i=0; i<input.length; i++ ) {
        output[i] = output[i] + ALPHA * (input[i] - output[i]); // ERROR HERE
    }
    return output;
}

根据我的数据，此代码的结果（橙色线）将是： 糟糕的低通实现

你可以在这里找到正确的代码wikipedia Low-pass_filter，C 代码是这样的：

protected float[] lowPass( float[] input, float[] output ) {
    if ( output == null ) return input;

    output[0] = input[0];
    for (int i=1; i<input.length; i++) {
        output[i] = output[i-1] + ALPHA * (input[i] - output[i-1]);
    }
    return output;
}

请注意替换的索引 (i -> i-1)。

在相同的数据和相同的 ALPHA 上，此代码生成： 在此处输入图像描述

于 2021-08-12T21:14:21.913 回答
0

在这里挖掘一个老问题，但如果你在 .NET 领域，你可以使用 RX 为你做这件事。

例如，将 RX 与 WebClient.DownloadFileAsync 结合使用来计算“平滑”的下载速度：

double interval = 2.0; // 2 seconds
long bytesReceivedSplit = 0;

WebClient wc = new WebClient();
var downloadProgress = Observable.FromEventPattern<
    DownloadProgressChangedEventHandler, DownloadProgressChangedEventArgs>(
    h => wc.DownloadProgressChanged += h,
    h => wc.DownloadProgressChanged -= h)
    .Select(x => x.EventArgs);

downloadProgress.Sample(TimeSpan.FromSeconds(interval)).Subscribe(x =>
    {
        Console.WriteLine((x.BytesReceived - bytesReceivedSplit) / interval);
        bytesReceivedSplit = x.BytesReceived;
    });

Uri source = new Uri("http://someaddress.com/somefile.zip");
wc.DownloadFileAsync(source, @"C:\temp\somefile.zip");

显然，间隔时间越长，平滑度越大，但您等待初始读数的时间也就越长。

于 2012-05-22T13:50:47.477 回答