float类型图片降采样差值方法

1，本文代码主要是对float类型的图片进行的降采样的差值方法
2， 对外的函数接口只有一个
对单通道float 类型的数据进行的降采样差值 （在opencv 中是Mat 类型是CV_32FC1）
src 输入图片数据指针 （如果是Mat类型，实参为(float)Mat.data)
des 输出图片的数据指针（如果是Mat类型，实参为(float)Mat.data)
srcW 输入图片的宽
srcW 输出图片宽
srcH 输入图片的高
int ImageResize(float * src, float * des, int srcW, int srcH, int desW, int desH)；

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
//纵向差值
/* src 输入图片数据指针 
 des 输出图片的数据指针
 srcW 输入图片的宽
 srcH 输入图片的高
 desH 输出图片的高 */
int BilinearInterpolationCol(float * src, float * des, int srcW, int srcH, int desH)
{
float scale = (float)desH / (float)srcH;
float invscale = (float)srcH / (float)desH;
int i, j, z;
float fsy1;
float fsy2;
int sy1;
int sy2;
int k = 0;
int m = 0;
int skip = (int)(ceil(invscale) + 1.0f);
float * weight = (float *)malloc(skip * sizeof(float));
int * srcIndex = (int *)malloc(skip * sizeof(int));

for(i = 0; i < desH; i ++)
    {
memset(weight, 0, sizeof(float) * skip);
memset(srcIndex, 0, sizeof(int) * skip);
        k = 0;
        m = 0;
        fsy1 = (float) i * invscale;
        fsy2 = fsy1 + invscale;

        sy1 = (int)ceil(fsy1);

        sy2 = (int)floor(fsy2);

if((float)sy1 - fsy1 > 0.001f)
        {
            srcIndex[k] = (sy1 - 1);
            weight[k] = ((float)sy1 - fsy1) * scale;
            k ++;
        }
for(m = sy1; m < sy2; m ++)
        {
            srcIndex[k] = m;
            weight[k] = scale;
            k ++;
        }
if(fsy2 - (float)(sy2) > 0.001f)
        {
            srcIndex[k] = sy2;
            weight[k] = (fsy2 - (float)(sy2)) * scale;
            k ++;
        }
for(j = 0; j < srcW; j ++)
        {
            des[(i * srcW + j)] = 0.0f;
for(z = 0; z < skip; z ++)
            {
                srcIndex[z] = min(srcIndex[z], (srcH - 1));
                des[(i * srcW + j)] += (src[(srcIndex[z] * srcW + j)]) * weight[z];
            }
        }
    }
free(weight);
free(srcIndex);
return 0;

}
/* 横向插值
 src 输入图片数据指针 
 des 输出图片的数据指针
 srcW 输入图片的宽
 srcH 输入图片的高
 desW 输出图片的宽 */
int BilinearInterpolationRow(float * src, float * des, int srcW, int srcH, int desW)
{
float scale = (float)desW / (float)srcW;
float invscale = (float)srcW / (float)desW;
int i, j, z;
float fsx1;
float fsx2;
int sx1;
int sx2;
int k = 0;
int m = 0;
int skip = (int)(ceil(invscale) + 1.0f);
float * weight = (float *)malloc(skip * sizeof(float));
int * srcIndex = (int *)malloc(skip * sizeof(int));


for(j = 0; j < desW; j ++)
    {

memset(weight, 0, sizeof(float) * skip);
memset(srcIndex, 0, sizeof(int) * skip);

            k = 0;
            m = 0;
            fsx1 = (float) j * invscale;
            fsx2 = fsx1 + invscale;

            sx1 = (int)ceil(fsx1);
            sx2 = (int)floor(fsx2);

if((float)sx1 - fsx1 > 0.001f)
            {
                srcIndex[k] = (sx1 - 1);
                weight[k] = ((float)sx1 - fsx1) * scale;
                k ++;
            }
for(m = sx1; m < sx2; m ++)
            {
                srcIndex[k] = m;
                weight[k] = scale;
                k ++;
            }
if(fsx2 - (float)(sx2) > 0.001f)
            {
                srcIndex[k] = sx2;
                weight[k] = (fsx2 - (float)(sx2)) * scale;
                k ++;
            }

for(i = 0; i < srcH; i ++)
        {
            des[(i * desW + j)] = 0.0f;

for(z = 0; z < skip; z ++)
            {
                srcIndex[z] = min(srcIndex[z], (srcW -1));

                des[(i * desW + j)] += (src[(i * srcW + srcIndex[z])]) * weight[z];
            }

        }
    }
free(weight);
free(srcIndex);
return 0;

}
/* 对外提供的接口
 对单通道float 类型的数据进行的降采样差值 （在opencv 中是Mat 类型是CV_32FC1）
 src 输入图片数据指针 （如果是Mat类型，实参为(float)Mat.data)
 des 输出图片的数据指针（如果是Mat类型，实参为(float)Mat.data)
 srcW 输入图片的宽
 srcW 输出图片宽
 srcH 输入图片的高

 */
int ImageResize(float * src, float * des, int srcW, int srcH, int desW, int desH)
{
// 纵向差值
float * temp = (float *)malloc(srcW * desH * sizeof(float) * 4);
    BilinearInterpolationCol(src, temp, srcW, srcH, desH);
//横向差值
    BilinearInterpolationRow(temp, des, srcW, desH, desW);
free(temp);
return 0;
}