N通道Float 差值算法

1，本文主要是对N 通道的Float 类型的一种比较好的差值算法

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include "math_ext.h"
#if 1
//纵向差值
/* src 输入图片数据指针 
    des 输出图片的数据指针
    srcW 输入图片的宽
    srcH 输入图片的高
    desH 输出图片的高 */
int BilinearInterpolationCol(float * src, float * des, int srcW, int srcH, int desH, int channel)
{
    float scale = (float)desH / (float)srcH;
    float invscale = (float)srcH / (float)desH;
    int i, j, z, n;
    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));
    memset(des, 0, desH * srcW * sizeof(float) * channel);
    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 ++)
        {

            for(z = 0; z < skip; z ++)
            {
                srcIndex[z] = min(srcIndex[z], (srcH - 1));
                for(n = 0; n < channel; n ++)
                {
                    des[(i * srcW + j) * channel + n] += (src[(srcIndex[z] * srcW + j) * channel + n]) * 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, int channel)
{
    float scale = (float)desW / (float)srcW;
    float invscale = (float)srcW / (float)desW;
    int i, j, z, n;
    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));
    memset(des, 0, desW * srcH * sizeof(float) * channel);
    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 ++)
        {
            for(z = 0; z < skip; z ++)
            {
                srcIndex[z] = min(srcIndex[z], (srcW -1));
                for(n = 0; n < channel; n ++)
                {
                    des[(i * desW + j) * channel + n] += (src[(i * srcW + srcIndex[z]) * channel + n]) * weight[z];
                }

            }

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

}
/* 对外提供的接口
    对N通道float 类型的数据进行的降采样差值
    src 输入图片数据指针 
    des 输出图片的数据指针
    srcW 输入图片的宽
    srcW 输出图片宽
    srcH 输入图片的高
    channel 通道数

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