开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图象 > 查看源码
rotate.cpp
资源名称：isee_code01231.zip　[点击查看]
上传用户：yatsl7111
上传日期：2007-01-08
资源大小：1433k
文件大小：12k
源码类别：

图形图象

开发平台：

Visual C++

rotate.cpp：源码内容
  1. /********************************************************************
  3. rotate.cpp - ISee图像浏览器—图像处理模块图像旋转处理实现代码文件
  5.     版权所有(C) VCHelp-coPathway-ISee workgroup 2000 all member's
  7.     这一程序是自由软件，你可以遵照自由软件基金会出版的GNU 通用许可证
  8. 条款来修改和重新发布这一程序。或者用许可证的第二版，或者（根据你
  9. 的选择）用任何更新的版本。
  11.     发布这一程序的目的是希望它有用，但没有任何担保。甚至没有适合特定
  12. 目地的隐含的担保。更详细的情况请参阅GNU通用许可证。
  14.     你应该已经和程序一起收到一份GNU通用许可证(GPL)的副本。如果还没有，
  15. 写信给：
  16.     The Free Software Foundation, Inc.,  675  Mass Ave,  Cambridge,
  17.     MA02139,  USA
  19. 如果你在使用本软件时有什么问题或建议，用以下地址可以与我们取得联
  20. 系：
  21. http://isee.126.com
  22. http://www.vchelp.net
  23. 或：
  24. iseesoft@china.com
  26. 作者：临风
  27.    e-mail:ringphone@sina.com
  29.    功能实现：图像旋转
  31. 文件版本：
  32. Build 00617
  33. Date  2000-6-17
  35. ********************************************************************/
  37. #include "p_win.h"
  38. #include "..publicgol_proc.h"
  39. #include "filter.h"
  40. #include "draw.h"
  41. #include "rotate.h"
  42. #include "resource.h"
  44. #define UL 0x00 //原图像左上角旋转后在左上角
  45. #define DL 0x40        //原图像左上角旋转后在左下角
  46. #define DR 0x80        //原图像左上角旋转后在右下角
  47. #define UR 0xc0        //原图像左上角旋转后在右上角
  49. LPVOID lpPreViewData=NULL,lpBakData=NULL;
  50. int prev_width,prev_height,mem_size;
  51. RECT rt;
  52. extern HBITMAP hbm;
  53. BOOL bRotate=FALSE; //图像是否旋转标志（即图像宽高是否调换）
  54. BYTE pos=UL;            //原图像左上角旋转后位置
  56. void Out_Rotate();
  57. void Out_Flip();
  59. //绘制预览图像
  60. void DrawPreView(HWND hWnd,LPDRAWITEMSTRUCT lpInfo)
  61. {
  62.    //绘制背景
  63.    HDC hmemdc;
  64.    hmemdc=CreateCompatibleDC(lpInfo->hDC);
  65.    // YZ Modify 2000-8-15 适当恢复DC中的单色位图
  66.    HBITMAP hOldBmp = (HBITMAP)SelectObject(hmemdc,hbm);
  67.    //SelectObject(hmemdc,hbm);
  68.    for(int j=0;j<lpInfo->rcItem.bottom;j+=48)
  69.       for(int i=0;i<lpInfo->rcItem.right;i+=48)
  70.          BitBlt(lpInfo->hDC,i,j,48,48,hmemdc,0,0,SRCCOPY);
  72.    SelectObject(hmemdc, hOldBmp);
  74.    DeleteDC(hmemdc);
  78.    float x,y;
  79. if(lpPreViewData==NULL)
  80.    {
  81.     lpPreViewData=(LPVOID)lpProcInfo->_psbdata;
  82.       if(lpPreViewData==NULL)
  83.        return;
  85.       //求预览图片尺寸
  86.       int rcw=lpInfo->rcItem.right-lpInfo->rcItem.left;
  87.       int rch=lpInfo->rcItem.bottom-lpInfo->rcItem.top;
  89.       x=(float)lpProcInfo->sImageInfo.width;
  90.       y=(float)lpProcInfo->sImageInfo.height;
  92.       if(lpProcInfo->sImageInfo.width > rcw || lpProcInfo->sImageInfo.height > rch)
  93.       {
  94.        if(lpProcInfo->sImageInfo.width >= lpProcInfo->sImageInfo.height)
  95. {
  96.         prev_width=rcw;
  97.           x=y/x;
  98.           x=x*prev_width;
  99.             if(x<8)
  100.              x=8;
  101.          prev_height=(int)x;
  103.           rt.left=0;
  104.           rt.top=(prev_width-prev_height)/2;
  105.           rt.right=prev_width;
  106.          rt.bottom=rt.top+prev_height;
  107.        }
  108.        else
  109.       {
  110.           prev_height=rch;
  111.           x=x/y;
  112.           x=x*prev_height;
  113.             if(x<8)
  114.              x=8;
  115.          prev_width=(int)x;
  117.           rt.left=(prev_height-prev_width)/2;
  118.           rt.top=0;
  119.           rt.right=rt.left+prev_width;
  120.          rt.bottom=prev_height;
  121.        }
  122.       }
  123.       else
  124.       {
  125.        prev_width=lpProcInfo->sImageInfo.width;
  126.          prev_height=lpProcInfo->sImageInfo.height;
  127.          rt.left=(rcw-prev_width)/2;
  128.          rt.top=(rch-prev_height)/2;
  129.          rt.right=rt.left+prev_width;
  130.          rt.bottom=rt.top+prev_height;
  131.       }
  133.    //创建prev_width*prev_height内存图像
  134.       mem_size=prev_width*prev_height*(lpProcInfo->sImageInfo.bitperpix/8);
  135.     LPVOID lptemp=New(mem_size);
  136.       lpBakData=New(mem_size);
  137.    if(lptemp==NULL || lpBakData==NULL)
  138.     {
  139.        // YZ Modify 2000-8-15 安全第一:-)
  140.          if (lptemp) lptemp=Del(lptemp);
  141.          if (lpBakData) lpBakData=Del(lpBakData);
  143.     lpProcInfo->result=PR_MEMORYERR;
  144.       SendMessage(hWnd,WM_CLOSE,0,0);
  145.        return;
  146.    }
  147.       //生成预览图像
  148. Output_Resize(prev_width,prev_height,(LPBYTE)lptemp);
  149.     lpPreViewData = lptemp;
  150.       CopyMemory(lpBakData,lpPreViewData,mem_size);
  151.    }
  152.    DoDlgDraw(lpInfo->hDC,&rt,prev_width,prev_height,lpPreViewData);
  153. }
  155. //预览图像向左旋转90度
  156. void TurnLeft()
  157. {
  158. if(lpPreViewData==NULL)
  159.     return;
  161.    int temp;
  163.    temp=rt.top;
  164.    rt.top=rt.left;
  165.    rt.left=temp;
  166.    temp=rt.right;
  167.    rt.right=rt.bottom;
  168.    rt.bottom=temp;
  170.    temp=prev_width;
  171.    prev_width=prev_height;
  172.    prev_height=temp;
  174. //标记图像已旋转，记录原图像左上角旋转后位置
  175.    bRotate = !bRotate;
  176.    pos = (BYTE)(pos+0x40);
  178. //prev_width与prev_height已调换，所以以下编程请注意:新图像宽高不调换，旧图像调换
  180. int skip = lpProcInfo->sImageInfo.bitperpix/8;
  181. LPBYTE lpData=(LPBYTE)lpBakData;
  182.    int new_width=prev_width*(lpProcInfo->sImageInfo.bitperpix/8);
  183.    LPBYTE lpDest=(LPBYTE)lpPreViewData+new_width-skip,lpBak=lpDest;
  185. for(int j=1;j<=prev_width;j++)
  186.    {
  187.     for(int i=0;i<prev_height;i++)
  188.       {
  189.        for(int k=0;k<skip;k++)
  190.          {
  191.           *lpDest=*lpData;
  192.             lpDest++;
  193.             lpData++;
  194.          }
  195.          lpDest+=(new_width-skip);
  196.       }
  197.       lpBak-=skip;
  198.       lpDest=lpBak;
  199.    }
  200.    CopyMemory(lpBakData,lpPreViewData,mem_size);
  201. }
  203. //预览图像向右旋转90度
  204. void TurnRight()
  205. {
  206. if(lpPreViewData==NULL)
  207.     return;
  209.    int temp;
  211.    temp=rt.top;
  212.    rt.top=rt.left;
  213.    rt.left=temp;
  214.    temp=rt.right;
  215.    rt.right=rt.bottom;
  216.    rt.bottom=temp;
  218.    temp=prev_width;
  219.    prev_width=prev_height;
  220.    prev_height=temp;
  222.    bRotate = !bRotate;
  223.    pos = (BYTE)(pos-0x40);
  225. int skip = lpProcInfo->sImageInfo.bitperpix/8;
  226. LPBYTE lpData=(LPBYTE)lpBakData;
  227.    int new_width=prev_width*(lpProcInfo->sImageInfo.bitperpix/8);
  228.    LPBYTE lpDest=(LPBYTE)lpPreViewData+new_width*(prev_height-1),lpBak=lpDest;
  230. for(int j=1;j<=prev_width;j++)
  231.    {
  232.     for(int i=0;i<prev_height;i++)
  233.       {
  234.        for(int k=0;k<skip;k++)
  235.          {
  236.           *lpDest=*lpData;
  237.             lpDest++;
  238.             lpData++;
  239.          }
  240.          lpDest-=(new_width+skip);
  241.       }
  242.       lpBak+=skip;
  243.       lpDest=lpBak;
  244.    }
  245.    CopyMemory(lpBakData,lpPreViewData,mem_size);
  246. }
  248. //预览图像横向反转
  249. void HFlip()
  250. {
  251. if(lpPreViewData==NULL)
  252.     return;
  254.    pos ^= 0xc0;
  256. int skip = lpProcInfo->sImageInfo.bitperpix/8;
  257.    int width=prev_width*skip;
  258.    LPBYTE lpData=(LPBYTE)lpBakData;
  259.    LPBYTE lpDest=(LPBYTE)lpPreViewData+width-skip;
  260.    int width_plus=skip<<1;
  261.    int height_plus=width<<1;
  263.    for(int j=0;j<prev_height;j++)
  264.    {
  265.     for(int i=0;i<prev_width;i++)
  266.       {
  267.        for(int k=0;k<skip;k++)
  268.          {
  269.           *lpDest=*lpData;
  270.             lpDest++;
  271.             lpData++;
  272.          }
  273.          lpDest-=width_plus;
  274.       }
  275.       lpDest+=height_plus;
  276.    }
  277.    CopyMemory(lpBakData,lpPreViewData,mem_size);
  278. }
  280. //预览图像纵向反转
  281. void VFlip()
  282. {
  283. if(lpPreViewData==NULL)
  284.     return;
  286.    pos ^= 0x40;
  288. int width=prev_width*(lpProcInfo->sImageInfo.bitperpix/8);
  289.    LPBYTE lpData=(LPBYTE)lpBakData;
  290.    LPBYTE lpDest=(LPBYTE)lpPreViewData+width*(prev_height-1);
  291.    int height_plus=width<<1;
  293.    for(int j=0;j<prev_height;j++)
  294.    {
  295.     for(int i=0;i<width;i++)
  296.       {
  297.        *lpDest=*lpData;
  298.          lpDest++;
  299.          lpData++;
  300.       }
  301.       lpDest-=height_plus;
  302.    }
  303.    CopyMemory(lpBakData,lpPreViewData,mem_size);
  304. }
  306. //实际图像旋转处理
  307. int Output_Rotate()
  308. {
  309. //创建内存图像
  310.    lpProcInfo->_pdbdata = (unsigned char*)New(lpProcInfo->sImageInfo.width*lpProcInfo->sImageInfo.height*(lpProcInfo->sImageInfo.bitperpix/8));
  311.    if(lpProcInfo->_pdbdata==NULL)
  312.    {
  313.     lpProcInfo->result=PR_MEMORYERR;
  314.     return PROCERR_FALSE;
  315.    }
  317.    //填写旋转后图像信息
  318.    if(bRotate)
  319.    {
  320. lpProcInfo->dImageInfo.width=lpProcInfo->sImageInfo.height;
  321.       lpProcInfo->dImageInfo.height=lpProcInfo->sImageInfo.width;
  322.    }
  323.    else
  324.    {
  325. lpProcInfo->dImageInfo.width=lpProcInfo->sImageInfo.width;
  326.       lpProcInfo->dImageInfo.height=lpProcInfo->sImageInfo.height;
  327.    }
  329.    lpProcInfo->pdLineAddr=(unsigned long**)New(lpProcInfo->dImageInfo.height*sizeof(long));
  330.    if(lpProcInfo->pdLineAddr==NULL)
  331.    {
  332.     // YZ Modify 2000-8-15 增加了释放上面那个内存块的代码
  333.       lpProcInfo->_pdbdata = Del(lpProcInfo->_pdbdata);
  335.     lpProcInfo->result=PR_MEMORYERR;
  336.     return PROCERR_FALSE;
  337.    }
  339.    lpProcInfo->dImageInfo.bitperpix=lpProcInfo->sImageInfo.bitperpix;
  340.    lpProcInfo->dImageInfo.bAlpha=lpProcInfo->sImageInfo.bAlpha;
  341.    // YZ Modify 2000-8-15 因为图像处理模块将始终工作在32位位图格式，所以
  342.    // 下面的几行可不要。
  343.    //int bpl=lpProcInfo->dImageInfo.width*(lpProcInfo->sImageInfo.bitperpix/8);
  344.    //bpl=bpl%4==0?bpl:(bpl/4+1)*4;
  345.    //lpProcInfo->dImageInfo.byteperline=bpl;
  346.    lpProcInfo->dImageInfo.byteperline=lpProcInfo->dImageInfo.width*4;
  349. // YZ Modify 2000-8-15 下面原来的那行代码的计算方式有误，因为ISee内部
  350.    // 标准图像格式是倒向的DIB（lpProcInfo->dImageInfo.height的值是一个正值），
  351.    // 所以，第一行的地址应该在位缓冲的末尾。
  352.    for(int i=0;i<lpProcInfo->dImageInfo.height;i++)
  353.       lpProcInfo->pdLineAddr[i]=(unsigned long*)(lpProcInfo->_pdbdata+((lpProcInfo->dImageInfo.height-i-1)*(lpProcInfo->dImageInfo.width*4)));
  354.     //lpProcInfo->pdLineAddr[i]=(unsigned long*)lpProcInfo->_pdbdata+lpProcInfo->dImageInfo.byteperline*i;
  357. //根据图像旋转标志做相应处理
  358.    if(bRotate)
  359.     Out_Rotate();
  360.    else
  361.     Out_Flip();
  363.    lpProcInfo->result=PR_SUCCESS;
  364.    return PROCERR_SUCCESS;
  365. }
  367. //图像宽高已调换，做旋转处理
  368. void Out_Rotate()
  369. {
  370. int skip = lpProcInfo->sImageInfo.bitperpix/8;
  371. LPBYTE lpData=(LPBYTE)lpProcInfo->_psbdata;
  372.    int new_width=lpProcInfo->dImageInfo.width*skip;
  373.    LPBYTE lpDest;
  374.    int width_plus,height_plus;
  376.    switch(pos)
  377.    {
  378.     case UL:        //图像向左旋转90度后上下反转
  379.     lpDest=(LPBYTE)lpProcInfo->_pdbdata+new_width*lpProcInfo->dImageInfo.height-skip;
  380.          width_plus=-new_width-skip;
  381.          height_plus=-skip;
  382.          break;
  383.       case DL:        //图像向左旋转90度
  384.          lpDest=(LPBYTE)lpProcInfo->_pdbdata+new_width-skip;
  385.          width_plus=new_width-skip;
  386.          height_plus=-skip;
  387.          break;
  388.       case DR:        //图像向右旋转90度后上下反转
  389.          lpDest=(LPBYTE)lpProcInfo->_pdbdata;
  390.          width_plus=new_width-skip;
  391.          height_plus=skip;
  392.          break;
  393.       case UR:        //图像向右旋转90度
  394.          lpDest=(LPBYTE)lpProcInfo->_pdbdata+new_width*(lpProcInfo->dImageInfo.height-1);
  395.          width_plus=-new_width-skip;
  396.          height_plus=skip;
  397.          break;
  398.    }
  400.    LPBYTE lpBak=lpDest;
  402. for(int j=0;j<lpProcInfo->sImageInfo.height;j++)
  403.    {
  404.     for(int i=0;i<lpProcInfo->sImageInfo.width;i++)
  405.       {
  406.        for(int k=0;k<skip;k++)
  407.          {
  408.           *lpDest=*lpData;
  409.             lpDest++;
  410.             lpData++;
  411.          }
  412.          lpDest+=width_plus;
  413.       }
  414.       lpBak+=height_plus;
  415.       lpDest=lpBak;
  416.    }
  417. }
  419. //图像宽高未调换，做反转处理
  420. void Out_Flip()
  421. {
  422. int skip = lpProcInfo->sImageInfo.bitperpix/8;
  423. LPBYTE lpData=(LPBYTE)lpProcInfo->_psbdata;
  424.    int width=lpProcInfo->sImageInfo.width*skip;
  425.    LPBYTE lpDest;
  426.    int width_plus,height_plus;
  428.    switch(pos)
  429.    {
  430.       case UL:        //与原图像相同，直接COPY图像数据
  431.        CopyMemory(lpProcInfo->_pdbdata,lpProcInfo->_psbdata,lpProcInfo->sImageInfo.width*lpProcInfo->sImageInfo.height*(lpProcInfo->sImageInfo.bitperpix/8));
  432.          return;
  433.     case DL:        //图像上下反转
  434.          lpDest=(LPBYTE)lpProcInfo->_pdbdata+width*(lpProcInfo->dImageInfo.height-1);
  435.          width_plus=0;
  436.          height_plus=-(width<<1);
  437.          break;
  438.       case DR:        //图像旋转180度
  439.          lpDest=(LPBYTE)lpProcInfo->_pdbdata+width*lpProcInfo->dImageInfo.height-skip;
  440.          width_plus=-(skip<<1);
  441.          height_plus=0;
  442.          break;
  443.       case UR:        //图像左右反转
  444.          lpDest=(LPBYTE)lpProcInfo->_pdbdata+width-skip;
  445.          width_plus=-(skip<<1);
  446.          height_plus=width<<1;
  447.          break;
  448.    }
  450.    for(int j=0;j<lpProcInfo->sImageInfo.height;j++)
  451.    {
  452.     for(int i=0;i<lpProcInfo->sImageInfo.width;i++)
  453.       {
  454.          for(int k=0;k<skip;k++)
  455.          {
  456.        *lpDest=*lpData;
  457.           lpDest++;
  458.             lpData++;
  459.          }
  460.          lpDest+=width_plus;
  461.       }
  462.       lpDest+=height_plus;
  463.    }
  464. }