图像旋转由16*16扩展存入20*20的分块

扩展为存入20*20的分块，需要改动的地方：

• 预设blockSrc[ ]扩展为400。
• 存入时，分块改为20*20的循环。
• 映射后的块初始点本身为（16*block_numx-16，16*block_numy-16),扩展为20*20是周围补了两圈，因此块初始点应该行列各减2，变为（16*block_numx-16，16*block_numy-16）。
• 由原图中的距离xOr,yOr，映射到块内相对的xOr,yOr，还需要改一下（16*block_numx-16，16*block_numy-16）。
• 最后利用分块存入的数组信息blockSrc[ ]时，求其对应位置时，iWidth要变为20。

16*16四周扩展2圈

考虑到由于扩展-2-2，xOr和yOr也要对应变一下：

改为20*20的Width，OK了。

 

// RotateZoom.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "RotateZoom.h"


#ifdef _DEBUG
#define new DEBUG_NEW
#endif
#include <atlimage.h>
#include <locale.h>

// The one and only application object

CWinApp theApp;

using namespace std;
//双三次插值系数
double fs(double w)
{    
        double a=-0.5;
        double fs;
        if (abs(w)<=1)
            fs=(a+2)*pow(abs(w),3)-(a+3)*pow(abs(w),2)+1;
        else if (abs(w)>1&&abs(w)<=2)
            fs=a*pow(abs(w),3)-5*a*pow(abs(w),2)+8*a*abs(w)-4*a;
        else
            fs=0;
        return fs;
}

HRESULT RotateZoom(PBYTE pbSrc,int iWidth,int iHeight,double dbRotate,double dbZoom,PBYTE pbTag);
int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
    int nRetCode = 0;

    setlocale(LC_ALL,"chs");
    HMODULE hModule = ::GetModuleHandle(NULL);
    if (hModule != NULL)
    {
        // initialize MFC and print and error on failure
        CImage cImage;
        HRESULT hResult;
        int        iWidth,iHeight,iBytePerPixel,iPitch;
        int        i,j,x,y,w,h;
        PBYTE    pbSrc=NULL,pbTag=NULL;
        PBYTE    pbImage=NULL;
        PDWORD    pdwImage=NULL;
        double    dbRotate=0,dbZoom=0;
        double    dbRotateStart=0,dbRotateEnd=0,dbRotateStep;
        double    dbZoomStart=0,dbZoomEnd=0,dbZoomStep;
        BOOL    bBenchWork=FALSE;
        CString csSrcName,csTagName,csNameRoot;
        TCHAR    *ptChar;
        do{
            if (!AfxWinInit(hModule, NULL, ::GetCommandLine(), 0))
            {
                // TODO: change error code to suit your needs
                _tprintf(_T("Fatal Error: MFC initialization failed
"));
                nRetCode = 1;
                break;
            }
            // TODO: code your application's behavior here.
            if(argc!=6 && argc!=10 )
            {
                _tprintf(_T("使用方法：
  RotateZoom -S 源图像文件 旋转角度 缩放倍数 输出文件
或：
  RotateZoom -B 源图像文件 旋转起始角度 步长 旋转终止角度 缩放起始倍数 步长 缩放终止倍数 输出文件
"));
                nRetCode= -1;
                break;
            }
            if(_tcsnicmp(argv[1],_T("-B"),2)==0)
            {
                bBenchWork=TRUE;
            }
            else if(_tcsnicmp(argv[1],_T("-S"),2)==0)
            {
                bBenchWork=FALSE;
            }
            else
            {
                _tprintf(_T("使用方法：
  RotateZoom -S 源图像文件 旋转角度 缩放倍数 输出文件
或：
RotateZoom -B 源图像文件 旋转起始角度 步长 旋转终止角度 缩放起始倍数 步长 缩放终止倍数 输出文件
"));
                nRetCode= -1;
                break;
            }
            if(bBenchWork)
            {
                csSrcName=argv[2];
                _stscanf(argv[3],_T("%lf"),&dbRotateStart);
                _stscanf(argv[4],_T("%lf"),&dbRotateStep);
                _stscanf(argv[5],_T("%lf"),&dbRotateEnd);
                _stscanf(argv[6],_T("%lf"),&dbZoomStart);
                _stscanf(argv[7],_T("%lf"),&dbZoomStep);
                _stscanf(argv[8],_T("%lf"),&dbZoomEnd);
                dbZoom=dbZoomStart>dbZoomEnd?dbZoomStart:dbZoomEnd;
                csTagName=argv[9];
                if(!((dbRotateStart>=0 && dbRotateStart<360) && 
                     (dbRotateEnd>=0 && dbRotateEnd<360)     &&
                     (dbZoomStart>=0.26 && dbZoomStart<=16)  && 
                     (dbZoomStart>=0.25 && dbZoomStart<=16)  &&
                     (dbRotateStep>=0.01) && (dbZoomEnd>=0.01)))
                {
                    _tprintf(_T("旋转角度范围（0~360），缩放倍数范围（0.25~16），步长范围（>=0.01）。输入参数超出范围！
"));
                    nRetCode= -2;
                    break;
                }    
            }
            else
            {
                csSrcName=argv[2];
                _stscanf(argv[3],_T("%lf"),&dbRotate);
                _stscanf(argv[4],_T("%lf"),&dbZoom);
                csTagName=argv[5];
                if(!((dbRotate>=0 && dbRotate<360) && (dbZoom>=0.25 && dbZoom<=16)))
                {
                    _tprintf(_T("旋转角度范围（0~360），缩放倍数范围（0.25~16）。输入参数超出范围！
"));
                    nRetCode= -2;
                    break;
                }            
            }

            hResult=cImage.Load(csSrcName);
            if(hResult!=ERROR_SUCCESS)
            {
                _tprintf(_T("源图像文件名错误！
"));
                nRetCode= -3;
                break;
            }
            iWidth=cImage.GetWidth();
            iHeight=cImage.GetHeight();
            pbSrc = (PBYTE)malloc(iWidth*iHeight);//存原图数据大小没问题
            if(dbZoom>1) pbTag = (PBYTE)malloc(ceil(iWidth*dbZoom)*ceil(iHeight*dbZoom));
            else         pbTag = (PBYTE)malloc(iWidth*iHeight);
            if(pbSrc==NULL || pbTag==NULL )
            {
                _tprintf(_T("内存申请错误！
"));
                nRetCode= -4;
                break;
            }
            iPitch=cImage.GetPitch();
            iBytePerPixel=(cImage.GetBPP()+7)/8;
            if(iBytePerPixel==3)
            {
                for(y=0;y<iHeight;y++)
                {
                    pbImage=(PBYTE)(PBYTE(cImage.GetBits())+iPitch*y);//得到的是图像初始像素地址
                    for(x=0;x<iWidth;x++)
                    {
                        pbSrc[y*iWidth+x]=(pbImage[3*x]*0.15+pbImage[3*x+1]*0.55+pbImage[3*x+2]*0.3);//转换成灰度就是单个像素了，分配大小还是原来的？。
                    }
                }
            }
            cImage.Destroy();

            csTagName.Trim();
            csTagName.MakeUpper();        
            if(bBenchWork)
            {

                if(csTagName.Right(4)!=_T(".BMP") ) csNameRoot=csTagName;
                else csNameRoot=csTagName.Left (csTagName.GetLength()-4);
                j=0;
                for(dbZoom=dbZoomStart;dbZoom<=dbZoomEnd;dbZoom+=dbZoomStep)
                {
                    w=ceil(iWidth*dbZoom);
                    h=ceil(iHeight*dbZoom);
                    cImage.Create(w,-h,32);
                    iPitch=cImage.GetPitch();                    
                    for(dbRotate=dbRotateStart;dbRotate<=dbRotateEnd;dbRotate+=dbRotateStep)
                    {
                        hResult=RotateZoom(pbSrc,iWidth,iHeight,dbRotate,dbZoom,pbTag);
                        if(hResult!=ERROR_SUCCESS)
                        {
                            _tprintf(_T("图像处理错误！
"));
                            nRetCode= -5;
                            break;
                        }

                        for(y=0;y<h;y++)
                        {
                            pdwImage=(PDWORD)(PBYTE(cImage.GetBits())+iPitch*y);
                            for(x=0;x<w;x++)
                            {
                                pdwImage[x]=pbTag[y*w+x]*0x10101;  
                            }
                        }    
                        csTagName=csNameRoot;
                        csTagName.AppendFormat(_T("_Z%05.2f_R%06.2f.BMP"),dbZoom,dbRotate);            
                        hResult=cImage.Save(csTagName,Gdiplus::ImageFormatBMP);
                        if(hResult!=ERROR_SUCCESS)
                        {
                            _tprintf(_T("图像结果保存错误！
"));
                            nRetCode= -5;
                            break;
                        }
                        i=csTagName.GetLength();
                        ptChar=csTagName.GetBuffer(i+1);
                        ptChar[i]=_T('');
                        _tprintf(_T("图像处理成功！%s
"),ptChar);
                        csTagName.ReleaseBuffer();
                        nRetCode= ERROR_SUCCESS;
                        j++;
                    }
                    cImage.Destroy();
                    if(nRetCode!=ERROR_SUCCESS) break;
                }
                if(nRetCode==ERROR_SUCCESS) _tprintf(_T("批处理完成！共处理%d
"),j);
                else                        _tprintf(_T("批处理出错！已处理%d
"),j);
            }
            else
            {
                hResult=RotateZoom(pbSrc,iWidth,iHeight,dbRotate,dbZoom,pbTag);
                if(hResult!=ERROR_SUCCESS)
                {
                    _tprintf(_T("图像处理错误！
"));
                    nRetCode= -5;
                    break;
                }
                iWidth=ceil(iWidth*dbZoom);
                iHeight=ceil(iHeight*dbZoom);
                cImage.Create(iWidth,-iHeight,32);
                iPitch=cImage.GetPitch();
                for(y=0;y<iHeight;y++)
                {
                    pdwImage=(PDWORD)(PBYTE(cImage.GetBits())+iPitch*y);
                    for(x=0;x<iWidth;x++)
                    {
                        pdwImage[x]=pbTag[y*iWidth+x]*0x10101;  
                    }
                }    
                if(csTagName.Right(4)!=_T(".BMP") ) csTagName.Append(_T(".BMP"));
                hResult=cImage.Save(csTagName,Gdiplus::ImageFormatBMP);
                if(hResult!=ERROR_SUCCESS)
                {
                    _tprintf(_T("图像结果保存错误！
"));
                    nRetCode= -5;
                    break;
                }
                i=csTagName.GetLength();
                ptChar=csTagName.GetBuffer(i+1);
                ptChar[i]=_T('');
                _tprintf(_T("图像处理成功！%s
"),ptChar);
                csTagName.ReleaseBuffer();
                nRetCode= ERROR_SUCCESS;
            }
            break;
        }while(0);
        if(pbSrc) free(pbSrc);
        if(pbTag) free(pbTag);
    }
    else
    {
        // TODO: change error code to suit your needs
        _tprintf(_T("Fatal Error: GetModuleHandle failed
"));
        nRetCode = 1;
    }
    _tprintf(_T("按任意键退出！"));
    getchar();    
    return nRetCode;
}
HRESULT RotateZoom(PBYTE pbSrc,int iWidth,int iHeight,double dbRotate,double dbZoom,PBYTE pbTag)
{
    double phase[33]={0};//16相位，包含端点存在33个距离
    for (int i=0;i<33;i++)
    {
        double i2=1.0*i;
        phase[i]=fs(i2/16);
    }
    int size;
    if(dbZoom>1)
    {
        size=iWidth*iHeight;
    }
    else
    {
        size=ceil(iWidth*dbZoom)*ceil(iHeight*dbZoom);
    }
    int newWidth=ceil(dbZoom*iWidth);
    //旋转中心为图像中心
    double rx0=ceil(dbZoom*iWidth)*0.5;  
    double ry0=ceil(dbZoom*iHeight)*0.5; 
    double srcx,srcy,u,v;
    int xOr,yOr;
    dbRotate=dbRotate*3.1415926/180.0;
    int xo=0,yo=0;
         for(int y=yo;y<ceil(dbZoom*iHeight);y++)
            {
                for(int x=xo;x<ceil(dbZoom*iWidth);x++)
                {
                    srcx=(double)((x-rx0)*cos(dbRotate) - (y-ry0)*sin(dbRotate) + rx0) ;
                    srcy=(double)((x-rx0)*sin(dbRotate) + (y-ry0)*cos(dbRotate) + ry0) ;
                    srcx=srcx*1/dbZoom;
                    srcy=srcy*1/dbZoom;
                    xOr = floor(srcx);
                    yOr = floor(srcy);
                    if( !(xOr-2>=0 && xOr+2<=iWidth && yOr-2>=0 && yOr+2<=iHeight))
                    {
                        pbTag[y*newWidth+x]=0;//255
                    }
                    else
                    {
                        u=srcx-xOr;
                        v=srcy-yOr;
                        int phasex=floor(16*u+0.5);//16相位
                        int phasey=floor(16*v+0.5);

                        double A1,B1,C1,D1,A2,B2,C2,D2;
                        A1=phase[16+phasex];
                        B1=phase[phasex];
                        C1=phase[16-phasex];
                        D1=phase[32-phasex];
                        A2=phase[16+phasey];
                        B2=phase[phasey];
                        C2=phase[16-phasey];
                        D2=phase[32-phasey];

                        int newWidth=ceil(dbZoom*iWidth);
                        int block_numx=ceil((xOr+1.0)/16);
                        int block_numy=ceil((yOr+1.0)/16);

                        double blockSrc[400]={0};
                        int newcount=0;
                        //int k=0,l=0;
                        //分块存储进数组blockSrc[]中
                        for(int k=0;k<20;k++)
                        {
                            for(int l=0;l<20;l++)
                            {
                                int oldcount=(16*block_numy-16+k-2)*iWidth+16*block_numx-16-2+l;   
                                blockSrc[newcount]=pbSrc[oldcount];
                                //pbTag[newcount]=pbSrc[oldcount];
                                newcount++;
                                //cout<<oldcount<<endl;
                            }
                        }//分块存入完毕
                        //映射到16×16块内的初始点位置
                        xOr=xOr-(16*block_numx-16-2);
                        yOr=yOr-(16*block_numy-16-2);
                        //变为18*18块后直接运算即可
                        //if(xOr>=1 && xOr<=14 && yOr>=1 && yOr<=14)
                        //    pbTag[y*newWidth+x]=blockSrc[yOr*16+xOr];
                        //20*20d
                            double middle=
                                blockSrc[(yOr-1)*20+(xOr-1)]*A1*A2+
                                blockSrc[(yOr)*20+(xOr-1)]*A1*B2+
                                blockSrc[(yOr+1)*20+(xOr-1)]*A1*C2+
                                blockSrc[(yOr+2)*20+(xOr-1)]*A1*D2+

                                blockSrc[(yOr-1)*20+(xOr)]*B1*A2+
                                blockSrc[(yOr)*20+(xOr)]*B1*B2+
                                blockSrc[(yOr+1)*20+(xOr)]*B1*C2+
                                blockSrc[(yOr+2)*20+(xOr)]*B1*D2+

                                blockSrc[(yOr-1)*20+(xOr+1)]*C1*A2+
                                blockSrc[(yOr)*20+(xOr+1)]*C1*B2+
                                blockSrc[(yOr+1)*20+(xOr+1)]*C1*C2+
                                blockSrc[(yOr+2)*20+(xOr+1)]*C1*D2+

                                blockSrc[(yOr-1)*20+(xOr+2)]*D1*A2+
                                blockSrc[(yOr)*20+(xOr+2)]*D1*B2+
                                blockSrc[(yOr+1)*20+(xOr+2)]*D1*C2+
                                blockSrc[(yOr+2)*20+(xOr+2)]*D1*D2;
                            if(middle<=255&&middle>=0)
                                pbTag[y*newWidth+x]=middle;
                            else if(middle>255)
                                pbTag[y*newWidth+x]=255;
                            else 
                                pbTag[y*newWidth+x]=0;
                    }
                }             
            }
    return ERROR_SUCCESS;
}