高质量的快速的图像缩放 之 近邻取样插值和其速度优化

最新推荐文章于 2023-10-17 00:53:46 发布
最新推荐文章于 2023-10-17 00:53:46 发布
阅读量1.5k 收藏
点赞数
分类专栏： 图像处理与分析 文章标签： 优化 dst 测试 table 编译器 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Redeom/article/details/5938830
版权

图形图像处理－之－高质量的快速的图像缩放 上篇 近邻取样插值和其速度优化
                     HouSisong@263.net   2006.11.22
(2007.01.02更新)


tag:图像缩放、速度优化、定点数优化、近邻取样插值、二次线性插值、三次线性插值、
   MipMap链、三次卷积插值、MMX/SSE优化、CPU缓存优化

摘要:首先给出一个基本的图像缩放算法，然后一步一步的优化其速度和缩放质量；

高质量的快速的图像缩放 全文 分为:
     上篇 近邻取样插值和其速度优化
     中篇 二次线性插值和三次卷积插值
     下篇 三次线性插值和MipMap链

正文： 

  为了便于讨论，这里只处理32bit的ARGB颜色；
  代码使用C++;涉及到汇编优化的时候假定为x86平台;使用的编译器为vc6;
  为了代码的可读性,没有加入异常处理代码;
   测试使用的CPU为赛扬2G;


速度测试说明:
  只测试内存数据到内存数据的缩放
  测试图片都是800*600缩放到1024*768; fps表示每秒钟的帧数,值越大表示函数越快


//Windows GDI相关函数参考速度:
//==============================================================================
// BitBlt               245 fps  //is copy 800*600 to 800*600
// BitBlt               159 fps  //is copy 1024*768 to 1024*768
// StretchBlt           169 fps  //is zoom 800*600 to 1024*768


A: 首先定义图像数据结构:


#define asm __asm

typedef unsigned char TUInt8; // [0..255]
struct TARGB32      //32 bit color
{
    TUInt8  B,G,R,A;          // A is alpha
};

struct TPicRegion  //一块颜色数据区的描述，便于参数传递
{
    TARGB32*    pdata;         //颜色数据首地址
    long        byte_width;    //一行数据的物理宽度(字节宽度)；
                //abs(byte_width)有可能大于等于width*sizeof(TARGB32);
    long        width;         //像素宽度
    long        height;        //像素高度
};

//那么访问一个点的函数可以写为：
inline TARGB32& Pixels(const TPicRegion& pic,const long x,const long y)
{
    return ( (TARGB32*)((TUInt8*)pic.pdata+pic.byte_width*y) )[x];
}
 


 B: 缩放原理和公式图示:

 

    缩放后图片             原图片
   (宽DW,高DH)          (宽SW,高SH)

  (Sx-0)/(SW-0)=(Dx-0)/(DW-0)   (Sy-0)/(SH-0)=(Dy-0)/(DH-0)
 =>   Sx=Dx*SW/DW                    Sy=Dy*SH/DH

 

C: 缩放算法的一个参考实现

//给出一个最简单的缩放函数(插值方式为近邻取样,而且我“尽力”把它写得慢一些了:D)
//Src.PColorData指向源数据区,Dst.PColorData指向目的数据区
//函数将大小为Src.Width*Src.Height的图片缩放到Dst.Width*Dst.Height的区域中


 

void PicZoom0(const TPicRegion& Dst,const TPicRegion& Src)
{
    if (  (0==Dst.width)||(0==Dst.height)
        ||(0==Src.width)||(0==Src.height)) return;
    for (long x=0;x<Dst.width;++x)
    {
        for (long y=0;y<Dst.height;++y)
        {
            long srcx=(x*Src.width/Dst.width);
            long srcy=(y*Src.height/Dst.height);
            Pixels(Dst,x,y)=Pixels(Src,srcx,srcy);
        }
    }
}
//速度测试:
//==============================================================================
// PicZoom0               6 fps


D: 优化PicZoom0函数

   a.PicZoom0函数并没有按照颜色数据在内存中的排列顺序读写(内部循环递增y行
索引)，将造成CPU缓存预读失败和内存颠簸导致巨大的性能损失,(很多硬件都有这种特性,
包括缓存、内存、显存、硬盘等,优化顺序访问，随机访问时会造成巨大的性能损失)
所以先交换x,y循环的顺序:

void PicZoom1(const TPicRegion& Dst,const TPicRegion& Src)
{
    if (  (0==Dst.width)||(0==Dst.height)
        ||(0==Src.width)||(0==Src.height)) return;
    for (long y=0;y<Dst.height;++y)
    {
        for (long x=0;x<Dst.width;++x)
        {
            long srcx=(x*Src.width/Dst.width);
            long srcy=(y*Src.height/Dst.height);
            Pixels(Dst,x,y)=Pixels(Src,srcx,srcy);
        }
    }
}
//速度测试:
//==============================================================================
// PicZoom1              23 fps

  b.“(x*Src.Width/Dst.Width)”表达式中有一个除法运算，它属于很慢的操作(比一般
的加减运算慢几十倍!),使用定点数的方法来优化它；

void PicZoom2(const TPicRegion& Dst,const TPicRegion& Src)
{
    if (  (0==Dst.width)||(0==Dst.height)
        ||(0==Src.width)||(0==Src.height)) return;
    //函数能够处理的最大图片尺寸65536*65536
    unsigned long xrIntFloat_16=(Src.width<<16)/Dst.width+1; //16.16格式定点数
    unsigned long yrIntFloat_16=(Src.height<<16)/Dst.height+1; //16.16格式定点数
    //可证明: (Dst.width-1)*xrIntFloat_16<Src.width成立
    for (unsigned long y=0;y<Dst.height;++y)
    {
        for (unsigned long x=0;x<Dst.width;++x)
        {
            unsigned long srcx=(x*xrIntFloat_16)>>16;
            unsigned long srcy=(y*yrIntFloat_16)>>16;
            Pixels(Dst,x,y)=Pixels(Src,srcx,srcy);
        }
    }
}
//速度测试:
//==============================================================================
// PicZoom2              86 fps

  c.  在x的循环中y一直不变，那么可以提前计算与y相关的值; 1.可以发现srcy的值和x变量无关，可以提前到x轴循环之前；2.展开Pixels函数，优化与y相关的指针计算；

 

void PicZoom3(const TPicRegion& Dst,const TPicRegion& Src)
{
    if (  (0==Dst.width)||(0==Dst.height)
        ||(0==Src.width)||(0==Src.height)) return;
    unsigned long xrIntFloat_16=(Src.width<<16)/Dst.width+1;
    unsigned long yrIntFloat_16=(Src.height<<16)/Dst.height+1;
    unsigned long dst_width=Dst.width;
    TARGB32* pDstLine=Dst.pdata;
    unsigned long srcy_16=0;
    for (unsigned long y=0;y<Dst.height;++y)
    {
        TARGB32* pSrcLine=((TARGB32*)((TUInt8*)Src.pdata+Src.byte_width*(srcy_16>>16)));
        unsigned long srcx_16=0;
        for (unsigned long x=0;x<dst_width;++x)
        {
            pDstLine[x]=pSrcLine[srcx_16>>16];
            srcx_16+=xrIntFloat_16;
        }
        srcy_16+=yrIntFloat_16;
        ((TUInt8*&)pDstLine)+=Dst.byte_width;
    }
}
//速度测试:
//==============================================================================
// PicZoom3             183 fps

  d.定点数优化使函数能够处理的最大图片尺寸和缩放结果(肉眼不可察觉的误差)受到了一
定的影响,这里给出一个使用浮点运算的版本,可以在有这种需求的场合使用:


void PicZoom3_float(const TPicRegion& Dst,const TPicRegion& Src)
{
    //注意: 该函数需要FPU支持
    if (  (0==Dst.width)||(0==Dst.height)
        ||(0==Src.width)||(0==Src.height)) return;
    double xrFloat=1.000000001/((double)Dst.width/Src.width);
    double yrFloat=1.000000001/((double)Dst.height/Src.height);

    unsigned short RC_Old;
    unsigned short RC_Edit;
    asm  //设置FPU的取整方式  为了直接使用fist浮点指令
    {
        FNSTCW  RC_Old             // 保存协处理器控制字,用来恢复
        FNSTCW  RC_Edit            // 保存协处理器控制字,用来修改
        FWAIT
        OR      RC_Edit, 0x0F00    // 改为 RC=11  使FPU向零取整    
        FLDCW   RC_Edit            // 载入协处理器控制字,RC场已经修改
    }

    unsigned long dst_width=Dst.width;
    TARGB32* pDstLine=Dst.pdata;
    double srcy=0;
    for (unsigned long y=0;y<Dst.height;++y)
    {
        TARGB32* pSrcLine=((TARGB32*)((TUInt8*)Src.pdata+Src.byte_width*((long)srcy)));
        /**//*
        double srcx=0;
        for (unsigned long x=0;x<dst_width;++x)
        {
            pDstLine[x]=pSrcLine[(unsigned long)srcx];//因为默认的浮点取整是一个很慢
                                     //的操作! 所以才使用了直接操作FPU的内联汇编代码。
            srcx+=xrFloat;
        }*/
        asm fld       xrFloat            //st0==xrFloat
        asm fldz                         //st0==0   st1==xrFloat
        unsigned long srcx=0;
        for (long x=0;x<dst_width;++x)
        {
            asm fist dword ptr srcx      //srcx=(long)st0
            pDstLine[x]=pSrcLine[srcx];
            asm fadd  st,st(1)           //st0+=st1   st1==xrFloat
        }
        asm fstp      st
        asm fstp      st

        srcy+=yrFloat;
        ((TUInt8*&)pDstLine)+=Dst.byte_width;
    }

    asm  //恢复FPU的取整方式
    {
        FWAIT
        FLDCW   RC_Old
    }
}
//速度测试:
//==============================================================================
// PicZoom3_float       178 fps


  e.注意到这样一个事实:每一行的缩放比例是固定的;那么可以预先建立一个缩放映射表格
  来处理缩放映射算法(PicZoom3_Table和PicZoom3_float的实现等价);

 

void PicZoom3_Table(const TPicRegion& Dst,const TPicRegion& Src)
{
    if (  (0==Dst.width)||(0==Dst.height)
        ||(0==Src.width)||(0==Src.height)) return;
    unsigned long dst_width=Dst.width;
    unsigned long* SrcX_Table = new unsigned long[dst_width];
    for (unsigned long x=0;x<dst_width;++x)//生成表 SrcX_Table
    {
        SrcX_Table[x]=(x*Src.width/Dst.width);
    }

    TARGB32* pDstLine=Dst.pdata;
    for (unsigned long y=0;y<Dst.height;++y)
    {
        unsigned long srcy=(y*Src.height/Dst.height);
        TARGB32* pSrcLine=((TARGB32*)((TUInt8*)Src.pdata+Src.byte_width*srcy));
        for (unsigned long x=0;x<dst_width;++x)
            pDstLine[x]=pSrcLine[SrcX_Table[x]];
        ((TUInt8*&)pDstLine)+=Dst.byte_width;
    }

    delete [] SrcX_Table;
}
//速度测试:
//==============================================================================
// PicZoom3_Table       180 fps

  f.为了加快缩放，可以采用根据缩放比例动态生成函数的方式来得到更快的缩放函数；这
  有点像编译器的工作原理；要实现它需要的工作量比较大(或比较晦涩)就不再实现了；
  (动态生成是一种不错的思路，但个人觉得对于缩放，实现它的必要性不大)

   g.现代CPU中，在读取数据和写入数据时，都有自动的缓存机制；很容易知道，算法中生
  成的数据不会很快再次使用，所以不需要写入缓存的帮助；在SSE指令集中增加了movntq
  等指令来完成这个功能；
  (尝试过利用CPU显式prefetcht0、prefetchnta预读指令或直接的mov读取指令等速度反
   而略有下降:(   但预读在copy算法中速度优化效果很明显 )

void PicZoom3_SSE(const TPicRegion& Dst,const TPicRegion& Src)
{
    //警告: 函数需要CPU支持MMX和movntq指令
    if (  (0==Dst.width)||(0==Dst.height)
        ||(0==Src.width)||(0==Src.height)) return;
    unsigned long xrIntFloat_16=(Src.width<<16)/Dst.width+1;
    unsigned long yrIntFloat_16=(Src.height<<16)/Dst.height+1;

    unsigned long dst_width=Dst.width;
    TARGB32* pDstLine=Dst.pdata;
    unsigned long srcy_16=0;
    for (unsigned long y=0;y<Dst.height;++y)
    {
        TARGB32* pSrcLine=((TARGB32*)((TUInt8*)Src.pdata+Src.byte_width*(srcy_16>>16)));

        asm
        {
            push      ebp
            mov       esi,pSrcLine
            mov       edi,pDstLine
            mov       edx,xrIntFloat_16
            mov       ecx,dst_width
            xor       ebp,ebp           //srcx_16=0

            and    ecx, (not 3)    //循环4次展开
            TEST   ECX,ECX   //nop
            jle    EndWriteLoop

            lea       edi,[edi+ecx*4]
            neg       ecx

              //todo: 预读

                WriteLoop:
                        mov       eax,ebp
                        shr       eax,16            //srcx_16>>16
                        lea       ebx,[ebp+edx]
                        movd      mm0,[esi+eax*4]
                        shr       ebx,16            //srcx_16>>16
                        PUNPCKlDQ mm0,[esi+ebx*4]
                        lea       ebp,[ebp+edx*2]
                      
                        // movntq qword ptr [edi+ecx*4], mm0  //不使用缓存的写入指令
                        asm _emit 0x0F asm _emit 0xE7 asm _emit 0x04 asm _emit 0x8F 

                        mov       eax,ebp
                        shr       eax,16            //srcx_16>>16
                        lea       ebx,[ebp+edx]
                        movd      mm1,[esi+eax*4]
                        shr       ebx,16            //srcx_16>>16
                        PUNPCKlDQ mm1,[esi+ebx*4]
                        lea       ebp,[ebp+edx*2]
                       
                        // movntq qword ptr [edi+ecx*4+8], mm1 //不使用缓存的写入指令
                        asm _emit 0x0F asm _emit 0xE7 asm _emit 0x4C asm _emit 0x8F asm _emit 0x08

                        add ecx, 4
                        jnz WriteLoop

                        //sfence //刷新写入
                        emms
                EndWriteLoop:

            mov    ebx,ebp
            pop    ebp

            //处理边界  循环次数为0,1,2,3；(这个循环可以展开,做一个跳转表,略)
            mov    ecx,dst_width
            and    ecx,3
            TEST   ECX,ECX
            jle    EndLineZoom

            lea       edi,[edi+ecx*4]
            neg       ecx
      StartBorder:
            mov       eax,ebx
            shr       eax,16            //srcx_16>>16
            mov       eax,[esi+eax*4]
            mov       [edi+ecx*4],eax
            add       ebx,edx

            inc       ECX
            JNZ       StartBorder
      EndLineZoom:
        }

        //
        srcy_16+=yrIntFloat_16;
        ((TUInt8*&)pDstLine)+=Dst.byte_width;
    }
}
//=====================================================================
//鉴于有读者反映汇编代码阅读困难，这里给出一个使用intel提供的函数调用方式的实现，
//读者可以相互对照来阅读代码
//要编译PicZoom3_SSE_mmh,需要#include <mmintrin.h> #include <xmmintrin.h>
//并且需要编译器支持
//函数PicZoom3_SSE_mmh速度和PicZoom3_SSE相当
void PicZoom3_SSE_mmh(const TPicRegion& Dst,const TPicRegion& Src)
{
    //警告: 函数需要CPU支持MMX和movntq指令
    if (  (0==Dst.width)||(0==Dst.height)
        ||(0==Src.width)||(0==Src.height)) return;
    unsigned long xrIntFloat_16=(Src.width<<16)/Dst.width+1;
    unsigned long yrIntFloat_16=(Src.height<<16)/Dst.height+1;
    unsigned long dst_width=Dst.width;
    TARGB32* pDstLine=Dst.pdata;
    unsigned long srcy_16=0;
    unsigned long for4count=dst_width/4*4;
    for (unsigned long y=0;y<Dst.height;++y)
    {
        TARGB32* pSrcLine=((TARGB32*)((TUInt8*)Src.pdata+Src.byte_width*(srcy_16>>16)));
        unsigned long srcx_16=0;
        unsigned long x;
        for (x=0;x<for4count;x+=4)//循环4次展开
        {
            __m64 m0=_m_from_int(*(int*)(&pSrcLine[srcx_16>>16]));
            srcx_16+=xrIntFloat_16;
            m0=_m_punpckldq(m0, _m_from_int(*(int*)(&pSrcLine[srcx_16>>16])) );
            srcx_16+=xrIntFloat_16;
            __m64 m1=_m_from_int(*(int*)(&pSrcLine[srcx_16>>16]));
            srcx_16+=xrIntFloat_16;
            m1=_m_punpckldq(m1, _m_from_int(*(int*)(&pSrcLine[srcx_16>>16])) );
            srcx_16+=xrIntFloat_16;
            _mm_stream_pi((__m64 *)&pDstLine[x],m0); //不使用缓存的写入指令
            _mm_stream_pi((__m64 *)&pDstLine[x+2],m1); //不使用缓存的写入指令
        }
        for (x=for4count;x<dst_width;++x)//处理边界
        {
            pDstLine[x]=pSrcLine[srcx_16>>16];
            srcx_16+=xrIntFloat_16;
        }
        srcy_16+=yrIntFloat_16;
        ((TUInt8*&)pDstLine)+=Dst.byte_width;
    }
    _m_empty();
}
//速度测试:
//==============================================================================
// PicZoom3_SSE    301--330 fps  (fps在一个范围是因为movntq指令受内存对齐的影响)


E: 缩放效果图：

                

     原图       放大图(x轴放大8倍,y轴放大12倍)


                                  
     原图        缩小图(缩小到0.66倍)      放大图(放大到1.6倍)

 

F: 把测试成绩放在一起：


//zoom 800*600 to 1024*1024
//==============================================================================
// BitBlt               245 fps  //is copy 800*600 to 800*600
// BitBlt               159 fps  //is copy 1024*1024 to 1024*1024
// StretchBlt           169 fps 
//
// PicZoom0               6 fps
// PicZoom1              23 fps
// PicZoom2              86 fps
// PicZoom3             183 fps
// PicZoom3_float       178 fps
// PicZoom3_Table       180 fps
// PicZoom3_SSE    301--330 fps  (fps在一个范围是因为movntq指令受内存对齐的影响)

 


本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/yangdelong/archive/2007/04/03/1550733.aspx

Redeom
关注
专栏目录
图形图像处理－之－高质量的快速的图像缩放 上篇 近邻取样插值和其速度优化
HouSisong的专栏
11-22 1万+
图形图像处理－之－高质量的快速的图像缩放 上篇 近邻取样插值和其速度优化                   HouSisong@GMail.com  2006.11.22(2009.03.07  可以到这里下载缩放算法的完整的可以编译的项目源代码:  http://blog.csdn.net/housisong/archive/2009/03/07/3967270.a
图形图像处理－之－高质量的快速的图像缩放 下篇 三次线性插值和MipMap链
HouSisong的专栏
03-13 9960
        图形图像处理－之－高质量的快速的图像缩放 下篇 三次线性插值和MipMap链                     HouSisong@Gmail.com   2007.03.13tag:图像缩放,速度优化,定点数优化,近邻取样插值,二次线性插值,三次线性插值,   MipMap链,三次卷积插值,MMX,SSE优化,CPU缓存优化摘要:首先给出一个基本的图像缩放算法，然后
图形图像处理－之－高质量的快速的图像缩放 补充 使用SSE2优化
热门推荐
HouSisong的专栏
04-12 2万+
本文章对线性插值和三次卷积插值(bicubic)的实现做了一些新的优化尝试; 使用了SSE2的128bit寄存器及相关指令;并预先建立SSE2用到的缩放系数表; 实现的结果在我的i7电脑上比以前的版本分别快出145%和75%! 线性插值的速度是StretchBlt的13倍!
近邻取样插值和其速度优化
凌风探梅的专栏
03-08 1298
本文的主要内容转载自博客 《图像缩放算法 》或《图形图像处理－之－高质量的快速的图像缩放 上篇 近邻取样插值和其速度优化》，将其中的代码改写在自己的机器上进行实际测试，从而更加体会到代码优化的意义及方向。 正文说明：        为了便于讨论，这里只处理24bit的RGB颜色；         代码使用C++，涉及到汇编优化的时候假定为x86平台;使用的编译器为vs2010；
图像缩放算法
liyuan02的专栏
09-10 1万+
http://blog.chinaunix.com/space.php?uid=22915173&do=blog&id=2185545   摘要:首先给出一个基本的图像缩放算法，然后一步一步的优化其速度和缩放质量； 高质量的快速的图像缩放 全文 分为:      上篇
图片缩放之近邻取样插值
ap105638的专栏
04-20 2285
近邻取样插值的一些理解：比如原图有100个点，想缩放10倍的话，那就要取10个点，（点的编号）比如0 10 20 30 。。。100（其他点就不要了）下面的的程序建立的取点编号表（这只是X轴例子） for(x=0;x<dwDstWidth;x++) { pdwSrcXTable[x]=(x*ptOriginPic->iWidth/ptZoomPic->iWidth); }
近邻取样插值matlab代码-Climate-Machine-Learning:基于机器学习的气候降尺度方法
05-28
近邻取样插值matlab代码基于机器学习的降尺度模型 该目录包含由智能决策支持设施的研究生开发的各种统计缩减模型和工具的源代码。 这些模型包括天气生成器，变化因子气候缩放算法和基于回归的模型。 此外，还开发了...
最近邻插值缩小图片程序c语言,图像缩放--最近邻插值
weixin_32058239的博客
05-18 569
这种方法的优点是速度快，在放大倍数不大的时候，与其他几种算法效果差别不大1. 用 P (i，j)表示目标图像的像素点(RGB)，P(x，y)表示源图像的像素点(RGB)2. 求解水平和垂直缩放因子double horFactor = srcWidth / dstWidth;double verFactor = srcHeight / dstHeight;3.计算 P(i，j)在源图中的映射 P(x...
c语言实现图片缩放,图片缩放与合并（C语言实现）
weixin_36073895的博客
05-20 1810
定义一个结构体用来存放像素数据，和一些图片相关的信息，当给一个函数传递参数的时候，我们更多的选择是传递指针而不是实际的值。下面给出一个实际的例子，只写出了部分的函数代码，提取出了程序的核心部分。/* 图片的象素数据 */typedef struct PixelDatas {int iWidth; /* 宽度: 一行有多少个象素 */int iHeight; /* 高度: 一列有多少个象素 *...
任意角度的高质量的快速的图像旋转.doc
06-16
【近邻取样插值】 近邻取样是最简单的图像插值方法之一，它通过取源图像中最近的像素值来估算目标位置的颜色。这种方法速度快，但可能导致图像边缘出现锯齿状。在文档的上篇中，作者对近邻取样的速度进行了优化，以...
03｜缩放算法：如何高质量地缩放图像？
最新发布
qq_37756660的博客
10-17 2836
在开始讲双线性插值的原理之前，我们先来看看双线性插值的基础，也就是线性插值的原理。线性插值是在两个点中间的某一个位置插值得到一个新的值。线性插值认为，这个需要插值得到的点跟这两个已知点都有一定的关系，并且，待插值点与离它近的那个点更相似。因此，
图像处理之-----插值算法
xp_fangfei的博客
08-14 1万+
插值算法是图像处理中最基本的算法，首先我们先了解一下什么是插值算法，以及插值算法在图像处理过程中的应用。 1、什么是插值 Interpolation is a method of constructing new data points within the range of a discrete set of known data points. Image interpolation refers to the “guess” of intensity values at missing locatio
图像处理中常见的几种插值方法：最近邻插值、双线性插值、双三次插值（附Pytorch测试代码）
NorthSmile的博客
09-14 1万+
在学习可变形卷积时，因为学习到的位移量Δpn可能是小数，因此作者采用双线性插值算法确定卷积操作最终采样的位置。通过插值算法我们可以根据现有已知的数据估计未知位置的数据，并且可以利用这种方法对图像进行缩放、旋转以及几何校正等任务。此处我通过这篇文章学习总结常见的三种插值方法，包括最近邻插值、双线性插值、双三次插值算法，其中双线性插值方法属于使用频率较高的方法，比如在Pytorch以及Tensorflow框架中默认的插值方法就是双线性插值方法。
图像处理-放大和缩小
陈建驱的博客
08-16 1万+
个人博客：http://www.chenjianqu.com/ 原文链接：http://www.chenjianqu.com/show-7.html 在计算机图像处理和计算机图形学中，图像缩放（image scaling）是指对数字图像的大小进行调整的过程。图像缩放是一种非平凡的过程，需要在处理效率以及结果的平滑度（smoothness）和清晰度（sharpness）上做一个权衡。当一个图像的...
图形图像处理－之－高质量的快速的图像缩放 中篇 二次线性插值和三次卷积插值
杨德龙的专栏
04-03 3269
图形图像处理－之－高质量的快速的图像缩放 中篇 二次线性插值和三次卷积插值                     HouSisong@263.net   2006.12.13(2007.03.06更新)tag:图像缩放、速度优化、定点数优化、近邻取样插值、二次线性插值、三次线性插值、   MipMap链、三次卷积插值、MMX/SSE优化、CPU缓存优化摘要:首先给出一个基本的图像缩放
双三次插值算法的C++实现与SSE指令优化
shandianfengfan的博客
12-24 2289
在上篇文章中，我们讲解了常见的最邻近插值算法、双线性插值算法和双三次插值算法的原理与实现，三种插值算法中双三次插值算法的插值效果最好，但其也是三种算法中计算复杂度最高、耗时最长的算法。本...
数字图像处理领域算法之图像缩放
diyuan365760的专栏
06-09 280
摘自：http://blog.csdn.net/v_july_v/article/details/6227072 算法描述： I、最邻近插值（近邻取样法）：　　最临近插值的的思想很简单，对于通过反向变换得到的的一个浮点坐标，对其进行简单的取整，得到一个整数型坐标，这个整数型坐标对应的像素值就是目的像素的像素值，也就是说，取浮点坐标最邻近的左上角点（对于DIB是右上角，因为它...
图像缩放算法——近邻取样插值
01-12 1820
近邻取样插值原理：               缩放后图片         原来的图片     对于缩放后图片中的某点 (Dx, Dy) 对应于原图片中的点 (Sx, Sy)，它们之间存在如下的比例关系：     (Sx-0)/(SW-0)=(Dx-0)/(DW-0)     (Sy-0)/(SH-0)=(Dy-0)/(DH-0)     因此，已知缩放后图片中的任意一点 (Dx,
使用双线性插值提升图像缩放质量
双线性插值图像缩放算法是数字图像处理中提高缩放质量的有效手段，其核心在于通过对相邻像素灰度值的加权平均，实现平滑过渡，从而减少缩放过程中的失真。通过理解和优化这个算法，可以更好地服务于图像处理的各种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值