Сглаживание данных с датчика

Question

У меня есть 3D-датчик, который измеряет данные v (x, y, z).Я использую только данные x и y.Было бы достаточно сглаживания только x и y.

Если я использую журнал для отображения данных, он показывает мне что-то вроде этого: (время) 0,1 ... (журнал данных) x = 1.1234566667 (время) 0,2... (журнал данных) x = 1.1245655666 (время) 0.3 ... (журнал данных) x = 1.2344445555

На самом деле данные более точны, но я хочу сгладить значение 1.1234 и значение 1.2344значение, потому что для меня это то же самое, я могу использовать целые числа, показывая только «x = 1», но мне также нужны десятичные дроби, тогда мне нужно показать своего рода «сглаженное» значение здесь.

У кого-нибудь есть идеи?Я программирую на C #, но не все функции работают, поэтому мне нужно создать свою собственную функцию.

Answer 1

Самое простое - это скользящее среднее ваших данных. То есть хранить массив данных датчиков и усреднять их. Примерно так (псевдокод):

  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).

Если вам нужен быстрый отклик, но хорошее сглаживание в любом случае, тогда вам нужно использовать средневзвешенное значение массива. Это в основном цифровая обработка сигналов (с большой буквы), которая, в отличие от названия, более тесно связана с аналоговым дизайном. Вот короткая статья в Википедии об этом (с хорошими внешними ссылками, которую вы должны прочитать, если хотите пойти по этому пути): http://en.wikipedia.org/wiki/Digital_filter

Вот некоторый код из SO о фильтре нижних частот, который может удовлетворить ваши потребности: Программное обеспечение фильтра нижних частот? . Обратите внимание, что в коде в этом ответе он использует массив размером 4 (или порядка 4 в терминологии обработки сигналов, поскольку такие фильтры называются фильтрами четвертого порядка, на самом деле он может моделироваться полиномиальным уравнением 4-го порядка: 4 + bx ^ 3 + cx ^ 2 + dx) .

Answer 2

Итак, я пришел сюда, чтобы решить ту же проблему (сглаживание входного сигнала датчика в 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 за указание на ссылку в Википедии, котораяпосле небольшого прочтения обратил меня к алгоритму в википедии статья фильтра нижних частот.Я не буду клясться, что у меня есть лучший алгоритм (или даже правильный!), Но неподтвержденные данные, кажется, указывают, что он добился цели.

Answer 3

Ну, есть много способов сгладить данные датчика, зависит от того, какой это датчик и какая аналогия подойдет. Я использовал эти алгоритмы в своих проектах:

1. Фильтр верхних частот [HPF] и Фильтры нижних частот [LPF] - как указано в выбранном ответе.
2. алгоритм скользящего среднего -MAA
3. Алгоритм Гаэли [Лучшая версия для МАА]
4. Быстрое преобразование Фурье -FFT

Код:

Фильтр высоких частот 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;
        }

Answer 4

Вот пример, основанный на логике в разделе MotionEvents Руководства по обработке событий для iOS.

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;
}

Answer 5

Здесь можно найти старый вопрос, но если вы находитесь на земле .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");

Очевидно, что чем больше интервал, тем больше будет сглаживание, но такжетем дольше вам придется ждать начального чтения.