（转）任意角度的高质量的快速的图…

最新推荐文章于 2025-09-02 14:25:32 发布
原创 最新推荐文章于 2025-09-02 14:25:32 发布 · 283 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了一种高效的图像旋转算法，通过优化内部循环判断和利用像素绘制原理寻找边界来提高旋转速度。采用TRotaryClipData类确定旋转边界，并通过PicRotary3函数实现图像旋转。进一步使用SSE指令优化内存写操作，显著提升处理速度。
E:优化内部循环的判断函数PixelsIsInPic，将判断展开到内部循环之外，跳过不需要处理的目标像素；
    TRotaryClipData类用于寻找旋转需要处理的边界范围；算法思路是首先寻找原图片中心点对应的；
那条扫描线，然后依次向上和向下寻找边界；  如果想要更快速的边界寻找算法，可以考虑利用像素的直线
  绘制原理来自动生成边界(有机会的时候再来实现它)；

                   （转）任意角度的高质量的快速的图像旋转（中）

                       边界寻找算法图示

struct TRotaryClipData{
public:
    long src_width;
    long src_height;
    long dst_width;
    long dst_height;
    long Ax_16;
    long Ay_16;
    long Bx_16;
    long By_16;
    long Cx_16;
    long Cy_16;
public:
    long out_dst_up_y;
    long out_dst_down_y;

    long out_src_x0_16;
    long out_src_y0_16;
private:
    long out_dst_up_x0;
    long out_dst_up_x1;
    long out_dst_down_x0;
    long out_dst_down_x1;
public:
    inline long get_up_x0(){ if (out_dst_up_x0<0) return 0;  else return out_dst_up_x0; }
    inline long get_up_x1(){ if (out_dst_up_x1>=dst_width) return dst_width;  else return out_dst_up_x1; }
    inline long get_down_x0(){ if (out_dst_down_x0<0) return 0;  else return out_dst_down_x0; }
    inline long get_down_x1(){ if (out_dst_down_x1>=dst_width) return dst_width;  else return out_dst_down_x1; }

    inline bool is_in_src(long src_x_16,long src_y_16)
    {
         return ( ( (src_x_16>=0)&&((src_x_16>>16)<src_width) )
               && ( (src_y_16>=0)&&((src_y_16>>16)<src_height) ) );
    }
    void find_begin_in(long dst_y,long& out_dst_x,long& src_x_16,long& src_y_16)
    {
        src_x_16-=Ax_16;
        src_y_16-=Ay_16;
        while (is_in_src(src_x_16,src_y_16))
        {
            --out_dst_x;
            src_x_16-=Ax_16;
            src_y_16-=Ay_16;
        }
        src_x_16+=Ax_16;
        src_y_16+=Ay_16;
    }
    bool find_begin(long dst_y,long& out_dst_x0,long dst_x1)
    {
        long test_dst_x0=out_dst_x0-1;
        long src_x_16=Ax_16*test_dst_x0 + Bx_16*dst_y + Cx_16;
        long src_y_16=Ay_16*test_dst_x0 + By_16*dst_y + Cy_16;
        for (long i=test_dst_x0;i<=dst_x1;++i)
        {
            if (is_in_src(src_x_16,src_y_16))
            {
                out_dst_x0=i;
                if (i==test_dst_x0)
                    find_begin_in(dst_y,out_dst_x0,src_x_16,src_y_16);
                if (out_dst_x0<0)
                {
                    src_x_16-=(Ax_16*out_dst_x0);
                    src_y_16-=(Ay_16*out_dst_x0);
                }
                out_src_x0_16=src_x_16;
                out_src_y0_16=src_y_16;
                return true;
            }
            else
            {
                src_x_16+=Ax_16;
                src_y_16+=Ay_16;
            }
        }
        return false;
    }
    void find_end(long dst_y,long dst_x0,long& out_dst_x1)
    {
        long test_dst_x1=out_dst_x1;
        if (test_dst_x1<dst_x0) test_dst_x1=dst_x0;

        long src_x_16=Ax_16*test_dst_x1 + Bx_16*dst_y + Cx_16;
        long src_y_16=Ay_16*test_dst_x1 + By_16*dst_y + Cy_16;
        if (is_in_src(src_x_16,src_y_16))
        {
            ++test_dst_x1;
            src_x_16+=Ax_16;
            src_y_16+=Ay_16;
            while (is_in_src(src_x_16,src_y_16))
            {
                ++test_dst_x1;
                src_x_16+=Ax_16;
                src_y_16+=Ay_16;
            }
            out_dst_x1=test_dst_x1;
        }
        else
        {
            src_x_16-=Ax_16;
            src_y_16-=Ay_16;
            while (!is_in_src(src_x_16,src_y_16))
            {
                --test_dst_x1;
                src_x_16-=Ax_16;
                src_y_16-=Ay_16;
            }
            out_dst_x1=test_dst_x1;
        }
    }

    bool inti_clip(double move_x,double move_y)
    {
        //计算src中心点映射到dst后的坐标
        out_dst_down_y=(long)(src_height*0.5+move_y);
        out_dst_down_x0=(long)(src_width*0.5+move_x);
        out_dst_down_x1=out_dst_down_x0;
        //得到初始out_???
        if (find_begin(out_dst_down_y,out_dst_down_x0,out_dst_down_x1))
            find_end(out_dst_down_y,out_dst_down_x0,out_dst_down_x1);
        out_dst_up_y=out_dst_down_y;
        out_dst_up_x0=out_dst_down_x0;
        out_dst_up_x1=out_dst_down_x1;
        return (out_dst_down_x0<out_dst_down_x1);
    }
    bool next_clip_line_down()
    {
        ++out_dst_down_y;
        if (!find_begin(out_dst_down_y,out_dst_down_x0,out_dst_down_x1)) return false;
        find_end(out_dst_down_y,out_dst_down_x0,out_dst_down_x1);
        return (out_dst_down_x0<out_dst_down_x1);
    }
    bool next_clip_line_up()
    {
        --out_dst_up_y;
        if (!find_begin(out_dst_up_y,out_dst_up_x0,out_dst_up_x1)) return false;
        find_end(out_dst_up_y,out_dst_up_x0,out_dst_up_x1);
        return (out_dst_up_x0<out_dst_up_x1);
    }
};void PicRotary3_CopyLine(TARGB32* pDstLine,long dstCount,long Ax_16,long Ay_16,
                        long srcx0_16,long srcy0_16,TARGB32* pSrcLine,long src_byte_width)
{
    for (long x=0;x<dstCount;++x)
    {
        pDstLine[x]=Pixels(pSrcLine,src_byte_width,srcx0_16>>16,srcy0_16>>16);
        srcx0_16+=Ax_16;
        srcy0_16+=Ay_16;
    }
}

void PicRotary3(const TPicRegion& Dst,const TPicRegion& Src,double RotaryAngle,double ZoomX,double ZoomY,double move_x,double move_y)
{
    if ( (fabs(ZoomX*Src.width)<1.0e-4) || (fabs(ZoomY*Src.height)<1.0e-4) ) return; //太小的缩放比例认为已经不可见
    double tmprZoomXY=1.0/(ZoomX*ZoomY); 
    double rZoomX=tmprZoomXY*ZoomY;
    double rZoomY=tmprZoomXY*ZoomX;
    double sinA,cosA;
    SinCos(RotaryAngle,sinA,cosA);
    long Ax_16=(long)(rZoomX*cosA*(1<<16));
    long Ay_16=(long)(rZoomX*sinA*(1<<16));
    long Bx_16=(long)(-rZoomY*sinA*(1<<16));
    long By_16=(long)(rZoomY*cosA*(1<<16));
    double rx0=Src.width*0.5;  //(rx0,ry0)为旋转中心
    double ry0=Src.height*0.5;
    long Cx_16=(long)((-(rx0+move_x)*rZoomX*cosA+(ry0+move_y)*rZoomY*sinA+rx0)*(1<<16));
    long Cy_16=(long)((-(rx0+move_x)*rZoomX*sinA-(ry0+move_y)*rZoomY*cosA+ry0)*(1<<16));

    TRotaryClipData rcData;
    rcData.Ax_16=Ax_16;
    rcData.Bx_16=Bx_16;
    rcData.Cx_16=Cx_16;
    rcData.Ay_16=Ay_16;
    rcData.By_16=By_16;
    rcData.Cy_16=Cy_16;
    rcData.dst_width=Dst.width;
    rcData.dst_height=Dst.height;
    rcData.src_width=Src.width;
    rcData.src_height=Src.height;
    if (!rcData.inti_clip(move_x,move_y)) return;

    TARGB32* pDstLine=Dst.pdata;
    ((TUInt8*&)pDstLine)+=(Dst.byte_width*rcData.out_dst_down_y);
    while (true) //to down
    {
        long y=rcData.out_dst_down_y;
        if (y>=Dst.height) break;
        if (y>=0)
        {
            long x0=rcData.get_down_x0();
            PicRotary3_CopyLine(&pDstLine[x0],rcData.get_down_x1()-x0,Ax_16,Ay_16,
                rcData.out_src_x0_16,rcData.out_src_y0_16,Src.pdata,Src.byte_width);
        }
        if (!rcData.next_clip_line_down()) break;
        ((TUInt8*&)pDstLine)+=Dst.byte_width;
    }
  
    pDstLine=Dst.pdata;
    ((TUInt8*&)pDstLine)+=(Dst.byte_width*rcData.out_dst_up_y);
    while (rcData.next_clip_line_up()) //to up
    {
        long y=rcData.out_dst_up_y;
        if (y<0) break;
        ((TUInt8*&)pDstLine)-=Dst.byte_width;
        if (y<Dst.height)
        {
            long x0=rcData.get_up_x0();
            PicRotary3_CopyLine(&pDstLine[x0],rcData.get_up_x1()-x0,Ax_16,Ay_16,
                rcData.out_src_x0_16,rcData.out_src_y0_16,Src.pdata,Src.byte_width);
        }
    }
}
////////////////////////////////////////////////////////////////////////////////
//速度测试:
//==============================================================================
// PicRotary3             280.9 fps
//////////////////////////////////////////////////////////////////////////////// 


F:使用SSE的MOVNTQ指令优化CPU写缓冲

 (仅改写了PicRotary3_CopyLine的实现)


void __declspec(naked) __stdcall PicRotarySSE_CopyLine(TARGB32* pDstLine,long dstCount,long Ax_16,long Ay_16,
                        //                                      [esp+ 4]      [esp+ 8]      [esp+12]   [esp+16]
                        long srcx0_16,long srcy0_16,TARGB32* pSrcLine,long src_byte_width)
                        //   [esp+20]      [esp+24]          [esp+28]      [esp+32]
{
    //利用SSE的MOVNTQ指令优化写缓冲的汇编实现
    asm
    {
        push        ebx 
        push        esi 
        push        edi  
        push        ebp 
        //esp offset 16
        mov         ebx,dword ptr [esp+ 8+16]
        mov         esi,dword ptr [esp+32+16]
        mov         edi,dword ptr [esp+28+16]
        mov         eax,dword ptr [esp+24+16]
        mov         ecx,dword ptr [esp+20+16]
        dec         ebx
        xor         edx,edx
        test        ebx,ebx
        mov         dword ptr [esp+ 8+16],ebx
        jle         loop_bound

        //jmp   loop_begin
        //align 16
    loop_begin:
            mov         ebx,eax
            add         eax,dword ptr [esp+16+16]
            sar         ebx,16
            imul        ebx,esi
            add         ebx,edi
            mov         ebp,ecx
            add         ecx,dword ptr [esp+12+16]
            sar         ebp,16
            MOVD        MM0,dword ptr [ebx+ebp*4]
            mov         ebx,eax
            add         eax,dword ptr [esp+16+16]
            sar         ebx,16
            imul        ebx,esi
            mov         ebp,ecx
            add         ecx,dword ptr [esp+12+16]
            sar         ebp,16
            add         ebx,edi
            MOVD        MM1,dword ptr [ebx+ebp*4]
            mov         ebp,dword ptr [esp+ 4+16]
            PUNPCKlDQ   MM0,MM1
            mov         ebx,dword ptr [esp+ 8+16]
            MOVNTQ      qword ptr [ebp+edx*4],MM0
            add         edx,2
            cmp         edx,ebx 
            jl          loop_begin

            EMMS

    loop_bound:
        cmp         edx,ebx
        jne         loop_bound_end
        sar         eax,16
        imul        eax,esi
        sar         ecx,16
        add         eax,edi
        mov         eax,dword ptr [eax+ecx*4]
        mov         ecx,dword ptr [esp+ 4+16]
        mov         dword ptr [ecx+edx*4],eax
    loop_bound_end:
        pop         ebp 
        pop         edi 
        pop         esi 
        pop         ebx 
        ret         32 
    }
}

void PicRotarySSE(const TPicRegion& Dst,const TPicRegion& Src,double RotaryAngle,double ZoomX,double ZoomY,double move_x,double move_y)
{
    if ( (fabs(ZoomX*Src.width)<1.0e-4) || (fabs(ZoomY*Src.height)<1.0e-4) ) return; //太小的缩放比例认为已经不可见
    double tmprZoomXY=1.0/(ZoomX*ZoomY); 
    double rZoomX=tmprZoomXY*ZoomY;
    double rZoomY=tmprZoomXY*ZoomX;
    double sinA,cosA;
    SinCos(RotaryAngle,sinA,cosA);
    long Ax_16=(long)(rZoomX*cosA*(1<<16));
    long Ay_16=(long)(rZoomX*sinA*(1<<16));
    long Bx_16=(long)(-rZoomY*sinA*(1<<16));
    long By_16=(long)(rZoomY*cosA*(1<<16));
    double rx0=Src.width*0.5;  //(rx0,ry0)为旋转中心
    double ry0=Src.height*0.5;
    long Cx_16=(long)((-(rx0+move_x)*rZoomX*cosA+(ry0+move_y)*rZoomY*sinA+rx0)*(1<<16));
    long Cy_16=(long)((-(rx0+move_x)*rZoomX*sinA-(ry0+move_y)*rZoomY*cosA+ry0)*(1<<16));

    TRotaryClipData rcData;
    rcData.Ax_16=Ax_16;
    rcData.Bx_16=Bx_16;
    rcData.Cx_16=Cx_16;
    rcData.Ay_16=Ay_16;
    rcData.By_16=By_16;
    rcData.Cy_16=Cy_16;
    rcData.dst_width=Dst.width;
    rcData.dst_height=Dst.height;
    rcData.src_width=Src.width;
    rcData.src_height=Src.height;
    if (!rcData.inti_clip(move_x,move_y)) return;

    TARGB32* pDstLine=Dst.pdata;
    ((TUInt8*&)pDstLine)+=(Dst.byte_width*rcData.out_dst_down_y);
    while (true) //to down
    {
        long y=rcData.out_dst_down_y;
        if (y>=Dst.height) break;
        if (y>=0)
        {
            long x0=rcData.get_down_x0();
            PicRotarySSE_CopyLine(&pDstLine[x0],rcData.get_down_x1()-x0,Ax_16,Ay_16,
                rcData.out_src_x0_16,rcData.out_src_y0_16,Src.pdata,Src.byte_width);
        }
        if (!rcData.next_clip_line_down()) break;
        ((TUInt8*&)pDstLine)+=Dst.byte_width;
    }
  
    pDstLine=Dst.pdata;
    ((TUInt8*&)pDstLine)+=(Dst.byte_width*rcData.out_dst_up_y);
    while (rcData.next_clip_line_up()) //to up
    {
        long y=rcData.out_dst_up_y;
        if (y<0) break;
        ((TUInt8*&)pDstLine)-=Dst.byte_width;
        if (y<Dst.height)
        {
            long x0=rcData.get_up_x0();
            PicRotarySSE_CopyLine(&pDstLine[x0],rcData.get_up_x1()-x0,Ax_16,Ay_16,
                rcData.out_src_x0_16,rcData.out_src_y0_16,Src.pdata,Src.byte_width);
        }
    }

    asm  sfence //刷新写入
}
////////////////////////////////////////////////////////////////////////////////
//速度测试:
//==============================================================================
// PicRotarySEE           306.3 fps
////////////////////////////////////////////////////////////////////////////////

飞鸽传说
关注
基于C＋＋图像处理－任意角度的高质量的快速的图像旋转
Franken Zeng的专栏
09-10 6876
在优快云的BLOG中，看到这篇文章http://blog.youkuaiyun.com/housisong/archive/2007/04/27/1586717.aspx  里面用C++实现的，现在我用C++复现了一下，希望以后用Python再实现。  假设对图片上任意点 (x,y) ，绕一个坐标点 (rx0,ry0) 逆时针旋转 a 角度后的新的坐标设为 (x, y) ，有公式：
图形图像处理－之－任意角度的高质量的快速的图像旋转 上篇 纯软件的任意角度的快速旋转...
weixin_33804990的博客
08-19 164
正文：  为了便于讨论，这里只处理32bit的ARGB颜色；  代码使用C++;涉及到汇编优化的时候假定为x86平台;使用的编译器为vc2005;  为了代码的可读性,没有加入异常处理代码;   测试使用的CPU为赛扬2G(新的测试平台的CPU为AMD64x2 4200+(2.37G),测试时使用的单线程执行);  (一些基础代码和插值原理的详细说明参见作者的《图形图像处理－之－高质量的快速的图像...
MinerU旋转文档：任意角度旋转自适应
gitblog_00387的博客
09-02 815
在日常文档处理中，我们经常会遇到各种旋转角度的PDF文档：扫描仪误操作导致的90度旋转、手机拍照产生的任意角度倾斜、甚至有些学术论文本身就包含旋转的图表和公式。传统PDF解析工具面对这些旋转文档时往往束手无策，要么直接解析失败，要么产生乱码输出。 **你还在为这些问题困扰吗？** - 旋转90度的表格无法正确识别结构 - 倾斜文本行被错误分割成多个片段 - 旋转公式的LaTeX转换完全失真 ...
任意角度的高质量的快速的图像旋转
liyuan02的专栏
09-10 2146
任意角度的高质量的快速的图像旋转 上篇 纯软件的任意角度的快速旋转 作者EMAIL: HouSisong@GMail.com 摘要:首先给出一个基本的图像旋转算法，然后一步一步的优化其速度和旋转质量,打破不能软件旋转的神话! 任意角度的高质量的快速的图像旋转 全文
c++实现图像旋转任意角度
wonengguwozai的博客
07-27 2万+
图形图像处理－之－任意角度的高质量的快速的图像旋转 上篇 纯软件的任意角度的快速旋转                                 HouSisong@GMail.com   2007.04.26   (2009.03.09  可以到这里下载旋转算法的完整的可以编译的项目源代码: http://blog.youkuaiyun.com/housisong/archive/2009
OpenCV中的图像旋转方法详解
zdx2585503940的博客
04-21 1606
OpenCV作为最流行的计算机视觉库之一，提供了多种实现图像旋转的方法。本文将详细介绍OpenCV中的各种旋转技术，帮助读者理解它们的原理、适用场景以及具体实现方法。OpenCV提供了丰富而强大的图像旋转功能，理解这些方法的原理和适用场景，可以帮助我们在实际应用中选择最合适的旋转策略，平衡速度和质量需求。希望本文能帮助您更好地理解和使用OpenCV中的旋转方法。在实际应用中，建议根据具体需求选择合适的方法，并通过实验调整参数以获得最佳效果。这段代码与上面所表示的代码实现的功能是一样的。
图形图像处理－之－任意角度的高质量的快速的图像旋转
阿特图
09-02 4198
图形图像处理－之－任意角度的高质量的快速的图像旋转  转自:http://blog.chinaunix.net/uid-20306372-id-1707267.html   上篇 纯软件的任意角度的快速旋转                                 HouSisong@GMail.com   2007.04.26 tag:图像旋转,任意角度,图像
图形图像处理－之－任意角度的高质量的快速的图像旋转 中篇 高质量的旋转
HouSisong的专栏
06-26 8736
          图形图像处理－之－任意角度的高质量的快速的图像旋转 中篇 高质量的旋转                         HouSisong@GMail.com   2007.06.26 (2009.03.09  可以到这里下载旋转算法的完整的可以编译的项目源代码:  http://blog.youkuaiyun.com/housisong/archive/2009/03/09/39
C# Bitmap实现角度旋转
wangnaisheng的专栏
04-24 2464
C# Bitmap实现角度旋转
任意角度的图形旋转
07-09
本文将深入探讨如何实现任意角度的高质量、快速的图像旋转。 首先，旋转的基本原理是利用三角函数和坐标变换公式。在笛卡尔坐标系中，一个点(x, y)绕原点逆时针旋转θ角度后的坐标(x', y')可以通过以下两个公式计算...
任意角度的高质量的快速的图像旋转.doc
06-16
在本文档中，重点讨论的是如何实现任意角度的高质量、快速的图像旋转。高质量的图像旋转通常涉及到插值算法，以减少旋转过程中的像素失真，确保图像清晰度。 【近邻取样插值】 近邻取样是最简单的图像插值方法之一...
图形图像处理－之－任意角度的高质量的快速的图像旋转 上篇 纯软件的任意角度的快速旋转
热门推荐
HouSisong的专栏
04-27 2万+
          图形图像处理－之－任意角度的高质量的快速的图像旋转 上篇 纯软件的任意角度的快速旋转                                HouSisong@GMail.com   2007.04.26 (2009.03.09  可以到这里下载旋转算法的完整的可以编译的项目源代码:  http://blog.youkuaiyun.com/housisong/archive
Java实现图片无损任意角度旋转代码分享
"java图片任意角度旋转 无损旋转 图片旋转工具类 实战代码" 在Java编程中，处理图像是一项常见的任务，而其中图片的旋转是尤为常见的需求。本资源提供了一个Java工具类，用于实现图片的无损任意角度旋转。这个工具...
基于C11标准实现的多项式运算管理系统_支持多项式创建存储求和乘法及删除操作提供命令行交互界面并兼容Linux与Windows平台包含完整错误处理与数据持久化功能_旨.zip
12-15
基于C11标准实现的多项式运算管理系统_支持多项式创建存储求和乘法及删除操作提供命令行交互界面并兼容Linux与Windows平台包含完整错误处理与数据持久化功能_旨.zip
基于EasyAR40引擎开发的稀疏空间地图构建与高精度室内导航系统_利用计算机视觉与即时定位与地图构建技术通过智能手机摄像头实时采集环境特征点云数据构建轻量级稀疏空间地图并.zip
12-15
基于EasyAR40引擎开发的稀疏空间地图构建与高精度室内导航系统_利用计算机视觉与即时定位与地图构建技术通过智能手机摄像头实时采集环境特征点云数据构建轻量级稀疏空间地图并.zip
git版本管理工具安装包
最新发布
12-15
git版本管理工具安装包
本项目是一个基于Python编程语言实现的专注于网络安全领域自动化文本处理与格式化输出能力提升的算数表达式排版工具旨在通过实际编码练习深化字符串操作正则表达式匹配输入数据清洗.zip
12-15
本项目是一个基于Python编程语言实现的专注于网络安全领域自动化文本处理与格式化输出能力提升的算数表达式排版工具旨在通过实际编码练习深化字符串操作正则表达式匹配输入数据清洗.zip
【未发表】基于哈里斯鹰优化算法HHO优化鲁棒极限学习机RELM实现风电数据时序预测算法研究附Matlab代码.zip
12-15
1.版本：matlab2014a/2019b/2024b 2.附赠案例数据可直接运行。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
Dephi实现图像任意角度旋转的快速方法
在Delphi环境下实现图像的任意角度旋转是一个涉及图像处理和图形算法的问题。此知识点主要包含以下几部分： ### Delphi编程基础 - **Delphi介绍**：Delphi是一个集成开发环境，由Embarcadero公司开发，主要用于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值