曲线的平滑平滑处理

最近在写一些数据处理的程序。经常需要对数据进行平滑处理。直接用FIR滤波器或IIR滤波器都有一个启动问题,滤波完成后总要对数据掐头去尾。因此去找了些简单的数据平滑处理的方法。

在一本老版本的《数学手册》中找到了几个基于最小二乘法的数据平滑算法。将其写成了C 代码,测试了一下,效果还可以。这里简单的记录一下,算是给自己做个笔记。

算法的原理很简单,以五点三次平滑为例。取相邻的5个数据点,可以拟合出一条3次曲线来,然后用3次曲线上相应的位置的数据值作为滤波后结果。简单的说就是 Savitzky-Golay 滤波器 。只不过Savitzky-Golay 滤波器并不特殊考虑边界的几个数据点,而这个算法还特意把边上的几个点的数据拟合结果给推导了出来。

不多说了,下面贴代码。首先是线性拟合平滑处理的代码. 分别为三点线性平滑、五点线性平滑和七点线性平滑。

  1

  2

  3

  4

  5

  6

  7

  8

  9

 10

 11

 12

 13

 14

 15

 16

 17

 18

 19

 20

 21

 22

 23

 24

 25

 26

 27

 28

 29

 30

 31

 32

 33

 34

 35

 36

 37

 38

 39

 40

 41

 42

 43

 44

 45

 46

 47

 48

 49

 50

 51

 52

 53

 54

 55

 56

 57

 58

 59

 60

 61

 62

 63

 64

 65

 66

 67

 68

 69

 70

 71

 72

 73

 74

 75

 76

 77

 78

 79

 80

 81

 82

voidlinearSmooth3 ( double in[], double out[], int N )

{

    int i;

    if ( N < 3 )

    {

        for ( i = 0; i <= N - 1; i++ )

        {

            out[i] = in[i];

        }

    }

    else

    {

        out[0] = ( 5.0 * in[0] + 2.0 * in[1] - in[2] ) / 6.0;

 

        for ( i = 1; i <= N - 2; i++ )

        {

            out[i] = ( in[i - 1] + in[i] + in[i + 1] ) / 3.0;

        }

 

        out[N - 1] = ( 5.0 * in[N - 1] + 2.0 * in[N - 2] - in[N - 3] ) / 6.0;

    }

}

 

voidlinearSmooth5 ( double in[], double out[], int N )

{

    int i;

    if ( N < 5 )

    {

        for ( i = 0; i <= N - 1; i++ )

        {

            out[i] = in[i];

        }

    }

    else

    {

        out[0] = ( 3.0 * in[0] + 2.0 * in[1] + in[2] - in[4] ) / 5.0;

        out[1] = ( 4.0 * in[0] + 3.0 * in[1] + 2 * in[2] + in[3] ) / 10.0;

        for ( i = 2; i <= N - 3; i++ )

        {

            out[i] = ( in[i - 2] + in[i - 1] + in[i] + in[i + 1] + in[i + 2] ) / 5.0;

        }

        out[N - 2] = ( 4.0 * in[N - 1] + 3.0 * in[N - 2] + 2 * in[N - 3] + in[N - 4] ) / 10.0;

        out[N - 1] = ( 3.0 * in[N - 1] + 2.0 * in[N - 2] + in[N - 3] - in[N - 5] ) / 5.0;

    }

}

 

voidlinearSmooth7 ( double in[], double out[], int N )

{

    int i;

    if ( N < 7 )

    {

        for ( i = 0; i <= N - 1; i++ )

        {

            out[i] = in[i];

        }

    }

    else

    {

        out[0] = ( 13.0 * in[0] + 10.0 * in[1] + 7.0 * in[2] + 4.0 * in[3] +

                  in[4] - 2.0 * in[5] - 5.0 * in[6] ) / 28.0;

 

        out[1] = ( 5.0 * in[0] + 4.0 * in[1] + 3 * in[2] + 2 * in[3] +

                  in[4] - in[5] ) / 14.0;

 

        out[2] = ( 7.0 * in[0] + 6.0 * in [1] + 5.0 * in[2] + 4.0 * in[3] +

                  3.0 * in[4] + 2.0 * in[5] + in[6] ) / 28.0;

 

        for ( i = 3; i <= N - 4; i++ )

        {

            out[i] = ( in[i - 3] + in[i - 2] + in[i - 1] + in[i] + in[i + 1] + in[i + 2] + in[i + 3] ) / 7.0;

        }

 

        out[N - 3] = ( 7.0 * in[N - 1] + 6.0 * in [N - 2] + 5.0 * in[N - 3] +

                      4.0 * in[N - 4] + 3.0 * in[N - 5] + 2.0 * in[N - 6] + in[N - 7] ) / 28.0;

 

        out[N - 2] = ( 5.0 * in[N - 1] + 4.0 * in[N - 2] + 3.0 * in[N - 3] +

                      2.0 * in[N - 4] + in[N - 5] - in[N - 6] ) / 14.0;

 

        out[N - 1] = ( 13.0 * in[N - 1] + 10.0 * in[N - 2] + 7.0 * in[N - 3] +

                      4 * in[N - 4] + in[N - 5] - 2 * in[N - 6] - 5 * in[N - 7] ) / 28.0;

    }

}

然后是利用二次函数拟合平滑。

  1

  2

  3

  4

  5

  6

  7

  8

  9

 10

 11

 12

 13

 14

 15

 16

 17

 18

 19

 20

 21

 22

 23

 24

 25

 26

 27

 28

 29

 30

 31

 32

 33

 34

 35

 36

 37

 38

 39

 40

 41

 42

 43

 44

 45

 46

 47

 48

 49

 50

 51

 52

 53

 54

 55

 56

 57

 58

 59

 60

 61

voidquadraticSmooth5(double in[], double out[], int N)

{

    int i;

    if ( N < 5 )

    {

        for ( i = 0; i <= N - 1; i++ )

        {

            out[i] = in[i];

        }

    }

    else

    {

        out[0] = ( 31.0 * in[0] + 9.0 * in[1] - 3.0 * in[2] - 5.0 * in[3] + 3.0 * in[4] ) / 35.0;

        out[1] = ( 9.0 * in[0] + 13.0 * in[1] + 12 * in[2] + 6.0 * in[3] - 5.0 *in[4]) / 35.0;

        for ( i = 2; i <= N - 3; i++ )

        {

            out[i] = ( - 3.0 * (in[i - 2] + in[i + 2]) +

                      12.0 * (in[i - 1] + in[i + 1]) + 17 * in[i] ) / 35.0;

        }

        out[N - 2] = ( 9.0 * in[N - 1] + 13.0 * in[N - 2] + 12.0 * in[N - 3] + 6.0 * in[N - 4] - 5.0 * in[N - 5] ) / 35.0;

        out[N - 1] = ( 31.0 * in[N - 1] + 9.0 * in[N - 2] - 3.0 * in[N - 3] - 5.0 * in[N - 4] + 3.0 * in[N - 5]) / 35.0;

    }

}

 

 

voidquadraticSmooth7(double in[], double out[], int N)

{

    int i;

    if ( N < 7 )

    {

        for ( i = 0; i <= N - 1; i++ )

        {

            out[i] = in[i];

        }

    }

    else

    {

        out[0] = ( 5.0 * in[0] + 15.0 * in[1] + 3.0 * in[2] - 4.0 * in[3] -

                  6.0 * in[4] - 3.0 * in[5] + 5.0 * in[6] ) / 42.0;

 

        out[1] = ( 5.0 * in[0] + 4.0 * in[1] + 3.0 * in[2] + 2.0 * in[3] +

                  in[4] - in[5] ) / 14.0;

 

        out[2] = ( 1.0 * in[0] + 3.0 * in [1] + 4.0 * in[2] + 4.0 * in[3] +

                  3.0 * in[4] + 1.0 * in[5] - 2.0 * in[6] ) / 14.0;

        for ( i = 3; i <= N - 4; i++ )

        {

            out[i] = ( -2.0 * (in[i - 3] + in[i + 3]) +

                       3.0 * (in[i - 2] + in[i + 2]) +

                      6.0 * (in[i - 1] + in[i + 1]) + 7.0 * in[i] ) / 21.0;

        }

        out[N - 3] = ( 1.0 * in[N - 1] + 3.0 * in [N - 2] + 4.0 * in[N - 3] +

                      4.0 * in[N - 4] + 3.0 * in[N - 5] + 1.0 * in[N - 6] - 2.0 * in[N - 7] ) / 14.0;

 

        out[N - 2] = ( 5.0 * in[N - 1] + 4.0 * in[N - 2] + 3.0 * in[N - 3] +

                      2.0 * in[N - 4] + in[N - 5] - in[N - 6] ) / 14.0;

 

        out[N - 1] = ( 32.0 * in[N - 1] + 15.0 * in[N - 2] + 3.0 * in[N - 3] -

                      4.0 * in[N - 4] - 6.0 * in[N - 5] - 3.0 * in[N - 6] + 5.0 * in[N - 7] ) / 42.0;

    }

}

最后是三次函数拟合平滑。

  1

  2

  3

  4

  5

  6

  7

  8

  9

 10

 11

 12

 13

 14

 15

 16

 17

 18

 19

 20

 21

 22

 23

 24

 25

 26

 27

 28

 29

 30

 31

 32

 33

 34

 35

 36

 37

 38

 39

 40

 41

 42

 43

 44

 45

 46

 47

 48

 49

 50

 51

 52

 53

 54

 55

 56

 57

 58

 59

 60

/**

 * 五点三次平滑

 *

 */

voidcubicSmooth5 ( double in[], double out[], int N )

{

 

    int i;

    if ( N < 5 )

    {

        for ( i = 0; i <= N - 1; i++ )

            out[i] = in[i];

    }

 

    else

    {

        out[0] = (69.0 * in[0] + 4.0 * in[1] - 6.0 * in[2] + 4.0 * in[3] - in[4]) / 70.0;

        out[1] = (2.0 * in[0] + 27.0 * in[1] + 12.0 * in[2] - 8.0 * in[3] + 2.0 * in[4]) / 35.0;

        for ( i = 2; i <= N - 3; i++ )

        {

            out[i] = (-3.0 * (in[i - 2] + in[i + 2])+ 12.0 * (in[i - 1] + in[i + 1]) + 17.0 * in[i] ) / 35.0;

        }

        out[N - 2] = (2.0 * in[N - 5] - 8.0 * in[N - 4] + 12.0 * in[N - 3] + 27.0 * in[N - 2] + 2.0 * in[N - 1]) / 35.0;

        out[N - 1] = (- in[N - 5] + 4.0 * in[N - 4] - 6.0 * in[N - 3] + 4.0 * in[N - 2] + 69.0 * in[N - 1]) / 70.0;

    }

    return;

}

 

voidcubicSmooth7(double in[], double out[], int N)

{

    int i;

    if ( N < 7 )

    {

        for ( i = 0; i <= N - 1; i++ )

        {

            out[i] = in[i];

        }

    }

    else

    {

        out[0] = ( 39.0 * in[0] + 8.0 * in[1] - 4.0 * in[2] - 4.0 * in[3] +

                  1.0 * in[4] + 4.0 * in[5] - 2.0 * in[6] ) / 42.0;

        out[1] = ( 8.0 * in[0] + 19.0 * in[1] + 16.0 * in[2] + 6.0 * in[3] -

                  4.0 * in[4] - 7.0* in[5] + 4.0 * in[6] ) / 42.0;

        out[2] = ( -4.0 * in[0] + 16.0 * in [1] + 19.0 * in[2] + 12.0 * in[3] +

                  2.0 * in[4] - 4.0 * in[5] + 1.0 * in[6] ) / 42.0;

        for ( i = 3; i <= N - 4; i++ )

        {

            out[i] = ( -2.0 * (in[i - 3] + in[i + 3]) +

                       3.0 * (in[i - 2] + in[i + 2]) +

                      6.0 * (in[i - 1] + in[i + 1]) + 7.0 * in[i] ) / 21.0;

        }

        out[N - 3] = ( -4.0 * in[N - 1] + 16.0 * in [N - 2] + 19.0 * in[N - 3] +

                      12.0 * in[N - 4] + 2.0 * in[N - 5] - 4.0 * in[N - 6] + 1.0 * in[N - 7] ) / 42.0;

        out[N - 2] = ( 8.0 * in[N - 1] + 19.0 * in[N - 2] + 16.0 * in[N - 3] +

                      6.0 * in[N - 4] - 4.0 * in[N - 5] - 7.0 * in[N - 6] + 4.0 * in[N - 7] ) / 42.0;

        out[N - 1] = ( 39.0 * in[N - 1] + 8.0 * in[N - 2] - 4.0 * in[N - 3] -

                      4.0 * in[N - 4] + 1.0 * in[N - 5] + 4.0 * in[N - 6] - 2.0 * in[N - 7] ) / 42.0;

    }

}

 


你可能感兴趣的:(c++,qt,c,数据,算法)