C语言平滑曲线函数

最新推荐文章于 2023-10-03 15:33:43 发布

chaoge131

最新推荐文章于 2023-10-03 15:33:43 发布

阅读量6.7k

点赞数 8

本文链接：https://blog.csdn.net/chaoge131/article/details/91512519

版权

///线性3点拟合平滑
void linearSmooth3 ( u8 in[], u8 out[], int N )
{
int i;
if ( N < 3 )
{
for ( i = 0; i <= N - 1; i++ )
{
out[i] = in[i];
}
}
else
{
out[0] = ( 5 * in[0] + 2 * in[1] - in[2] ) / 6;

for ( i = 1; i <= N - 2; i++ )
{
out[i] = ( in[i - 1] + in[i] + in[i + 1] ) / 3;
}

out[N - 1] = ( 5 * in[N - 1] + 2 * in[N - 2] - in[N - 3] ) / 6;
}
}

//5点平滑

void linearSmooth5 ( u8 in[], u8 out[], int N )
{
int i;
if ( N < 5 )
{
for ( i = 0; i <= N - 1; i++ )
{
out[i] = in[i];
}
}
else
{
out[0] = ( 3 * in[0] + 2 * in[1] + in[2] - in[4] ) / 5;
out[1] = ( 4 * in[0] + 3 * in[1] + 2 * in[2] + in[3] ) / 10;
for ( i = 2; i <= N - 3; i++ )
{
out[i] = ( in[i - 2] + in[i - 1] + in[i] + in[i + 1] + in[i + 2] ) / 5;
}
out[N - 2] = ( 4 * in[N - 1] + 3 * in[N - 2] + 2 * in[N - 3] + in[N - 4] ) / 10;
out[N - 1] = ( 3 * in[N - 1] + 2 * in[N - 2] + in[N - 3] - in[N - 5] ) / 5;
}
}

//7点平滑

void linearSmooth7 ( u8 in[], u8 out[], int N )
{
int i;
if ( N < 7 )
{
for ( i = 0; i <= N - 1; i++ )
{
out[i] = in[i];
}
}
else
{
out[0] = ( 13 * in[0] + 10 * in[1] + 7 * in[2] + 4 * in[3] +
in[4] - 2 * in[5] - 5 * in[6] ) / 28;

out[1] = ( 5 * in[0] + 4 * in[1] + 3 * in[2] + 2 * in[3] +
in[4] - in[6] ) / 14;

out[2] = ( 7 * in[0] + 6 * in [1] + 5 * in[2] + 4 * in[3] +
3 * in[4] + 2 * in[5] + in[6] ) / 28;

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

out[N - 3] = ( 7 * in[N - 1] + 6 * in [N - 2] + 5 * in[N - 3] +
4 * in[N - 4] + 3 * in[N - 5] + 2 * in[N - 6] + in[N - 7] ) / 28;

out[N - 2] = ( 5 * in[N - 1] + 4 * in[N - 2] + 3 * in[N - 3] +
2 * in[N - 4] + in[N - 5] - in[N - 7] ) / 14;

out[N - 1] = ( 13 * in[N - 1] + 10 * in[N - 2] + 7 * in[N - 3] +
4 * in[N - 4] + in[N - 5] - 2 * in[N - 6] - 5 * in[N - 7] ) / 28;
}
}

/二次函数5点拟合平滑
void quadraticSmooth5(u8 in[], u8 out[], int N)
{
int i;
if ( N < 5 )
{
for ( i = 0; i <= N - 1; i++ )
{
out[i] = in[i];
}
}
else
{
out[0] = ( 31 * in[0] + 9 * in[1] - 3 * in[2] - 5 * in[3] + 3 * in[4] ) / 35;
out[1] = ( 9 * in[0] + 13 * in[1] + 12 * in[2] + 6 * in[3] - 5 *in[4]) / 35;
for ( i = 2; i <= N - 3; i++ )
{
out[i] = ( - 3 * (in[i - 2] + in[i + 2]) +
12 * (in[i - 1] + in[i + 1]) + 17 * in[i] ) / 35;
}
out[N - 2] = ( 9 * in[N - 1] + 13 * in[N - 2] + 12 * in[N - 3] + 6 * in[N - 4] - 5 * in[N - 5] ) / 35;
out[N - 1] = ( 31 * in[N - 1] + 9 * in[N - 2] - 3 * in[N - 3] - 5 * in[N - 4] + 3 * in[N - 5]) / 35;
}
}

//7点
void quadraticSmooth7(u8 in[], u8 out[], int N)
{
int i;
if ( N < 7 )
{
for ( i = 0; i <= N - 1; i++ )
{
out[i] = in[i];
}
}
else
{
out[0] = ( 32 * in[0] + 15 * in[1] + 3 * in[2] - 4 * in[3] -
6 * in[4] - 3 * in[5] + 5 * in[6] ) / 42;

out[1] = ( 5 * in[0] + 4 * in[1] + 3 * in[2] + 2 * in[3] +
in[4] - in[6] ) / 14;

out[2] = ( 1 * in[0] + 3 * in [1] + 4 * in[2] + 4 * in[3] +
3 * in[4] + 1 * in[5] - 2 * in[6] ) / 14;
for ( i = 3; i <= N - 4; i++ )
{
out[i] = ( -2 * (in[i - 3] + in[i + 3]) + 3 * (in[i - 2] + in[i + 2]) + 6 * (in[i - 1] + in[i + 1]) + 7 * in[i] ) / 21;
}
out[N - 3] = ( 1 * in[N - 1] + 3 * in [N - 2] + 4 * in[N - 3] + 4 * in[N - 4] + 3 * in[N - 5] + 1 * in[N - 6] - 2 * in[N - 7] ) / 14;

out[N - 2] = ( 5 * in[N - 1] + 4 * in[N - 2] + 3 * in[N - 3] +2 * in[N - 4] + in[N - 5] - in[N - 7] ) / 14;

out[N - 1] = ( 32 * in[N - 1] + 15 * in[N - 2] + 3 * in[N - 3] -4 * in[N - 4] - 6 * in[N - 5] - 3 * in[N - 6] + 5 * in[N - 7] ) / 42;
}
}

/**三次函数拟合平滑 */
void cubicSmooth5 ( u8 in[], u8 out[], int N )
{

int i;
if ( N < 5 )
{
for ( i = 0; i <= N - 1; i++ )
out[i] = in[i];
}

else
{
out[0] = (69 * in[0] + 4 * in[1] - 6 * in[2] + 4 * in[3] - in[4]) / 70;
out[1] = (2 * in[0] + 27 * in[1] + 12 * in[2] - 8 * in[3] + 2 * in[4]) / 35;
for ( i = 2; i <= N - 3; i++ )
{
out[i] = (-3 * (in[i - 2] + in[i + 2])+ 12 * (in[i - 1] + in[i + 1]) + 17 * in[i] ) / 35;
}
out[N - 2] = (2 * in[N - 5] - 8 * in[N - 4] + 12 * in[N - 3] + 27 * in[N - 2] + 2 * in[N - 1]) / 35;
out[N - 1] = (- in[N - 5] + 4 * in[N - 4] - 6 * in[N - 3] + 4 * in[N - 2] + 69 * in[N - 1]) / 70;
}
return;
}

void cubicSmooth7(u8 in[], u8 out[], int N)
{
int i;
if ( N < 7 )
{
for ( i = 0; i <= N - 1; i++ )
{
out[i] = in[i];
}
}
else
{
out[0] = ( 39 * in[0] + 8 * in[1] - 4 * in[2] - 4 * in[3] +1 * in[4] + 4 * in[5] - 2 * in[6] ) / 42;
out[1] = ( 8 * in[0] + 19 * in[1] + 16 * in[2] + 6 * in[3] -4 * in[4] - 7* in[5] + 4 * in[6] ) / 42;
out[2] = ( -4 * in[0] + 16 * in [1] + 19 * in[2] + 12 * in[3] + 2 * in[4] - 4 * in[5] + 1 * in[6] ) / 42;
for ( i = 3; i <= N - 4; i++ )
{
out[i] = ( -2* (in[i - 3] + in[i + 3]) +3* (in[i - 2] + in[i + 2]) +6* (in[i - 1] + in[i + 1]) + 7* in[i] ) / 21;
}
out[N - 3] = ( -4* in[N - 1] + 16* in [N - 2] + 19* in[N - 3] +12* in[N - 4] + 2* in[N - 5] - 4* in[N - 6] + 1* in[N - 7] ) / 42;
out[N - 2] = ( 8* in[N - 1] + 19* in[N - 2] + 16* in[N - 3] + 6* in[N - 4] - 4* in[N - 5] - 7* in[N - 6] + 4* in[N - 7] ) / 42;
out[N - 1] = ( 39* in[N - 1] + 8* in[N - 2] - 4* in[N - 3] -4* in[N - 4] + 1* in[N - 5] + 4* in[N - 6] - 2* in[N - 7] ) / 42;
}
}