Згладжуючий фільтр Savitzky-Golay для не однаково розташованих даних

У мене є сигнал, який вимірюється 100 ГГц, і мені потрібно застосувати фільтр згладжування Савіцького-Голая до цього сигналу. Однак при більш детальному огляді мій сигнал не вимірюється з абсолютно постійною швидкістю, дельта між вимірюваннями становить від 9,7 до 10,3 мс.

Чи є спосіб використовувати фільтр Савіцького-Голая для не однаково розташованих даних? Чи існують інші методи, які я можу застосувати?

Одним із методів було б переупорядкувати свої дані, щоб вони були однаково розташовані, тоді ви можете робити будь-яку обробку, яка вам подобається. Діапазонне перекомплектування з використанням лінійної фільтрації не буде найкращим варіантом, оскільки дані не є рівномірно розташованими, тому ви можете використовувати якусь локальну поліноміальну інтерполяцію (наприклад, кубічні сплайни), щоб оцінити, які значення базового сигналу є "точними". 10-мілісекундні інтервали.

Через те, як виходить фільтр Савіцького-Голая (тобто, як локальний мінімум квадратів прилягає), існує природне узагальнення для неоднорідного відбору проб - це просто набагато дорожче обчислювально.

Фільтри Савіцького-Голая взагалі

Для стандартного фільтра ідея полягає в тому, щоб поліном підходити до локального набору зразків [з використанням найменших квадратів], а потім замінювати центральний зразок значенням полінома на центральний показник (тобто на 0). Це означає, що стандартні коефіцієнти фільтру SG можуть бути створені шляхом інвертування матриці Вандермондта зразкових показників. Наприклад, для створення локального параболічного пристосування через п’ять зразків (з локальними показниками -2, -1,0,1,2) система проектних рівнянь A c = y була б такою:$y_0\dots y_4$$Ac = y$

$$\begin{bmatrix}-2^0 & -2^1 & -2^2 \\ -1^0 & -1^1 & -1^2 \\ 0^0 & 0^1 & 0^2 \\ 1^0 & 1^1 & 1^2 \\ 2^0 & 2^1 & 2^2 \end{bmatrix} \begin{bmatrix} c_0 \\ c_1 \\ c_2 \end{bmatrix} = \begin{bmatrix} y_0 \\ y_1 \\ y_2 \\ y_3 \\ y_4 \end{bmatrix}.$$

$c_0 \dots c_2$$c_0 + c_1x + c_2x^2$$x = 0$$c_0$$c = (A^TA)^{-1}A^T y\space$

$$\begin{bmatrix}c_0 \\ c_1 \\ c_2 \end{bmatrix} = \begin{bmatrix} -3 & 12 & 17 & 12 & -3 \\ -7 & -4 & 0 & 4 & 7 \\ 5 & -3 & -5 & -3 & 5 \\ \end{bmatrix} \begin{bmatrix} y_0 \\ y_1 \\ y_2 \\ y_3 \\ y_4 \end{bmatrix}.$$

$c_0 + c_1x + c_2x^2$$c_1 + 2c_2x$$c_1$

Неоднорідний відбір проб

$x_n$$t_n$$0$

$$\begin{align} t_{-2} & = x_{-2} - x_0 \\ t_{-1} & = x_{-1} - x_0 \\ t_0 & = x_0 - x_0 \\ t_1 & = x_1 - x_0 \\ t_2 & = x_2 - x_0 \end{align}$$

то кожна матриця проектування буде мати таку форму:

$$A = \begin{bmatrix} t_{-2}^0 & t_{-2}^1 & t_{-2}^2 \\ t_{-1}^0 & t_{-1}^1 & t_{-1}^2 \\ t_0^0 & t_0^1 & t_0^2 \\ t_1^0 & t_1^1 & t_1^2 \\ t_2^0 & t_2^1 & t_2^2 \end{bmatrix} = \begin{bmatrix} 1 & t_{-2} & t_{-2}^2 \\ 1 & t_{-1} & t_{-1}^2 \\ 1 & 0 & 0 \\ 1 & t_1 & t_1^2 \\ 1 & t_2 & t_2^2 \end{bmatrix}.$$

$A$ $c_0$

$f$$N$$\sqrt{N/2}$
$\qquad -$

(виведення когось?)

$\pm N/2$$t$$t$
$t_i \to i$

Я з'ясував, що в Matlab існує два способи використання алгоритму savitzky-golay. Один раз як фільтр і раз як функція згладжування, але в основному вони повинні робити те саме.

1. yy = sgolayfilt (y, k, f): Тут вважаються, що значення y = y (x) однаково розташовані в x.
2. yy = гладкий (x, y, span, 'sgolay', градус): Тут ви можете мати x як додатковий вхід, а звернення до довідки Matlab x не повинно бути однаково розташоване!

Якщо це допоможе, я здійснив C-метод, описаний datageist. Безкоштовно користуватися на власний ризик.

/**
 * @brief smooth_nonuniform
 * Implements the method described in  /signals/1676/savitzky-golay-smoothing-filter-for-not-equally-spaced-data
 * free to use at the user's risk
 * @param n the half size of the smoothing sample, e.g. n=2 for smoothing over 5 points
 * @param the degree of the local polynomial fit, e.g. deg=2 for a parabolic fit
 */
bool smooth_nonuniform(uint deg, uint n, std::vector<double>const &x, std::vector<double> const &y, std::vector<double>&ysm)
{
    if(x.size()!=y.size()) return false; // don't even try
    if(x.size()<=2*n)      return false; // not enough data to start the smoothing process
//    if(2*n+1<=deg+1)       return false; // need at least deg+1 points to make the polynomial

    int m = 2*n+1; // the size of the filter window
    int o = deg+1; // the smoothing order

    std::vector<double> A(m*o);         memset(A.data(),   0, m*o*sizeof(double));
    std::vector<double> tA(m*o);        memset(tA.data(),  0, m*o*sizeof(double));
    std::vector<double> tAA(o*o);       memset(tAA.data(), 0, o*o*sizeof(double));

    std::vector<double> t(m);           memset(t.data(),   0, m*  sizeof(double));
    std::vector<double> c(o);           memset(c.data(),   0, o*  sizeof(double));

    // do not smooth start and end data
    int sz = y.size();
    ysm.resize(sz);           memset(ysm.data(), 0,sz*sizeof(double));
    for(uint i=0; i<n; i++)
    {
        ysm[i]=y[i];
        ysm[sz-i-1] = y[sz-i-1];
    }

    // start smoothing
    for(uint i=n; i<x.size()-n; i++)
    {
        // make A and tA
        for(int j=0; j<m; j++)
        {
            t[j] = x[i+j-n] - x[i];
        }
        for(int j=0; j<m; j++)
        {
            double r = 1.0;
            for(int k=0; k<o; k++)
            {
                A[j*o+k] = r;
                tA[k*m+j] = r;
                r *= t[j];
            }
        }

        // make tA.A
        matMult(tA.data(), A.data(), tAA.data(), o, m, o);

        // make (tA.A)-¹ in place
        if (o==3)
        {
            if(!invert33(tAA.data())) return false;
        }
        else if(o==4)
        {
            if(!invert44(tAA.data())) return false;
        }
        else
        {
            if(!inverseMatrixLapack(o, tAA.data())) return false;
        }

        // make (tA.A)-¹.tA
        matMult(tAA.data(), tA.data(), A.data(), o, o, m); // re-uses memory allocated for matrix A

        // compute the polynomial's value at the center of the sample
        ysm[i] = 0.0;
        for(int j=0; j<m; j++)
        {
            ysm[i] += A[j]*y[i+j-n];
        }
    }

    std::cout << "      x       y       y_smoothed" << std::endl;
    for(uint i=0; i<x.size(); i++) std::cout << "   " << x[i] << "   " << y[i]  << "   "<< ysm[i] << std::endl;

    return true;
}