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

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

图形图象

开发平台：

Visual C++

DrawPreView.cpp：源码内容
  1. #include "StdAfx.h"
  2. #include "DrawPreView.h"
  3. #include "System.h"
  4. #include "draw.h"
  5. #include "Contrast.h"
  6. #include "EdgeEnhance.h"
  7. #include "Filter.h"
  8. #include "Resource.h"
  10. static int prev_width,prev_height,mem_size,Img_size;
  11. static RECT rt;
  13. // 清理内存函数，这里借用了临风的格式
  14. void ClearPreView()
  15. {
  16. EndDraw();
  17. Del(lptemp);
  18. Del(lpPreView);
  19. Del(lpPreBack);
  20. lptemp=NULL;
  21. lpPreView=NULL;
  22. lpPreBack=NULL;
  23. }
  25. // 预览窗口预览绘制函数
  26. void _fnSPE_DrawPreView(LPDRAWITEMSTRUCT lpInfo,int x,int y,int nStype)
  27. {
  28. WORD skip=lpProcInfo->sImageInfo.bitperpix/8;
  30. //求预览图片尺寸
  31. int rcw=lpInfo->rcItem.right-lpInfo->rcItem.left;
  32. int rch=lpInfo->rcItem.bottom-lpInfo->rcItem.top;
  34. if(lpPreView==NULL)
  35. {
  36. lpPreView=(LPBYTE)lpProcInfo->_psbdata;
  38. if(lpPreView==NULL)
  39. {
  40.     lpProcInfo->result=PR_MEMORYERR;
  41.     return;
  42. }
  44. if(lpProcInfo->sImageInfo.width < rcw || lpProcInfo->sImageInfo.height < rch)
  45. {
  46. if(lpProcInfo->sImageInfo.width >= rcw )
  47. {
  48.        prev_width=PREV_WIDTH;
  49. prev_height=lpProcInfo->sImageInfo.height;
  50. rt.left=0;
  51. rt.top=(rch-prev_height)/2;
  52. rt.right=rt.left+prev_width;
  53. rt.bottom=rt.top+prev_height;
  54. }
  55. else if(lpProcInfo->sImageInfo.height >= rch)
  56. {
  57.        prev_width=lpProcInfo->sImageInfo.width;
  58. prev_height=PREV_HEIGHT;
  59. rt.left=(rcw-prev_width)/2;
  60. rt.top=0;
  61. rt.right=rt.left+prev_width;
  62. rt.bottom=rt.top+prev_height;
  63. }
  64. else
  65. {
  66. prev_width=lpProcInfo->sImageInfo.width;
  67. prev_height=lpProcInfo->sImageInfo.height;
  68. rt.left=(rcw-prev_width)/2;
  69. rt.top=(rch-prev_height)/2;
  70. rt.right=rt.left+prev_width;
  71. rt.bottom=rt.top+prev_height;
  73. }
  74. //创建预览内存图像
  75. mem_size=prev_height*prev_width*skip;
  76. lptemp=(LPBYTE)New(mem_size);
  77. if(lptemp==NULL)
  78. {
  79.     lpProcInfo->result=PR_MEMORYERR;
  80.     return;
  81. }
  82. lpPreBack=(LPBYTE)New(mem_size);
  83. if(lpPreBack==NULL)
  84. {
  85.     lpProcInfo->result=PR_MEMORYERR;
  86.     return;
  87. }
  88. if(lpProcInfo->sImageInfo.width >= rcw )
  89. {
  90. for(int i=0;i<prev_height;i++)
  91. {
  92. CopyMemory(lptemp+i*(PREV_WIDTH)*skip,lpProcInfo->_psbdata+i*lpProcInfo->sImageInfo.byteperline+x*skip,PREV_WIDTH*skip);
  93. }
  94. }
  95. else if(lpProcInfo->sImageInfo.height >= rch)
  96. {
  97. for(int j=0,i=y;i<PREV_HEIGHT+y;i++,j++)
  98. {
  99. CopyMemory(lptemp+j*(prev_width)*skip,lpProcInfo->_psbdata+i*lpProcInfo->sImageInfo.byteperline,prev_width*skip);
  100. }
  101. }
  102. else
  103. {
  104. //生成预览图像
  105. CopyMemory(lptemp,lpProcInfo->_psbdata ,mem_size);
  106. }
  107. }
  108. else
  109. {
  110.       prev_height=PREV_HEIGHT;
  111. prev_width=PREV_WIDTH;
  112.     rt.left=0;
  113.        rt.top=(prev_width-prev_height)/2;
  114. rt.right=prev_width;
  115. rt.bottom=rt.top+prev_height;
  117. //创建预览内存图像
  118. mem_size=prev_height*prev_width*skip;
  119. lptemp=(LPBYTE)New(mem_size);
  120. if(lptemp==NULL)
  121. {
  122.     lpProcInfo->result=PR_MEMORYERR;
  123.     return;
  124. }
  125. lpPreBack=(LPBYTE)New(mem_size);
  126. if(lpPreBack==NULL)
  127. {
  128.     lpProcInfo->result=PR_MEMORYERR;
  129.     return;
  130. }
  132. //生成预览图像
  133. for(int j=0,i=y;i<PREV_HEIGHT+y;i++,j++)
  134. {
  135. CopyMemory(lptemp+j*(PREV_WIDTH)*skip,lpProcInfo->_psbdata+i*lpProcInfo->sImageInfo.byteperline+x*skip ,(PREV_WIDTH)*skip);
  136. }
  137. }
  139. lpPreView=lptemp;
  140. CopyMemory(lpPreBack,lpPreView,mem_size);
  141. }
  143. DoDlgDraw(lpInfo->hDC,&rt,prev_width,prev_height,lpPreView);
  144. }
  146. // 预览窗口（缩比）绘制函数,这里借用了临风的格式
  147. void _fnSPE_DrawResizePreView(LPDRAWITEMSTRUCT lpInfo)
  148. {
  149. float x,y;
  150. if(lpPreView==NULL)
  151. {
  152.     lpPreView=(LPBYTE)lpProcInfo->_psbdata;
  153. if(lpPreView==NULL)
  154.        return;
  156. //求预览图片尺寸
  157. int rcw=lpInfo->rcItem.right-lpInfo->rcItem.left;
  158. int rch=lpInfo->rcItem.bottom-lpInfo->rcItem.top;
  160. x=(float)lpProcInfo->sImageInfo.width;
  161. y=(float)lpProcInfo->sImageInfo.height;
  163. if(lpProcInfo->sImageInfo.width > rcw || lpProcInfo->sImageInfo.height > rch)
  164. {
  165.        if(lpProcInfo->sImageInfo.width >= lpProcInfo->sImageInfo.height)
  166. {
  167.         prev_width=rcw;
  168.        x=y/x;
  169.           x=x*prev_width;
  170. if(x<8)
  171.              x=8;
  172. prev_height=(int)x;
  174.     rt.left=0;
  175.        rt.top=(prev_width-prev_height)/2;
  176.           rt.right=prev_width;
  177. rt.bottom=rt.top+prev_height;
  178.     }
  179.        else
  180. {
  181.     prev_height=rch;
  182.        x=x/y;
  183.       x=x*prev_height;
  184.     if(x<8)
  185. x=8;
  186. prev_width=(int)x;
  188.     rt.left=(prev_height-prev_width)/2;
  189.        rt.top=0;
  190.           rt.right=rt.left+prev_width;
  191.         rt.bottom=prev_height;
  192.     }
  193. }
  194. else
  195. {
  196.        prev_width=lpProcInfo->sImageInfo.width;
  197. prev_height=lpProcInfo->sImageInfo.height;
  198. rt.left=(rcw-prev_width)/2;
  199. rt.top=(rch-prev_height)/2;
  200. rt.right=rt.left+prev_width;
  201. rt.bottom=rt.top+prev_height;
  202. }
  204.    //创建prev_width*prev_height内存图像
  205. mem_size=prev_width*prev_height*(lpProcInfo->sImageInfo.bitperpix/8);
  206. lpPreBack=(LPBYTE)New(mem_size);
  207. if(lpPreBack==NULL)
  208. {
  209.     lpProcInfo->result=PR_MEMORYERR;
  210. // SendMessage(NULL ,WM_CLOSE,0,0);
  211.     return;
  212. }
  213. lptemp=(LPBYTE)New(mem_size);
  214. if(lptemp==NULL)
  215. {
  216.     lpProcInfo->result=PR_MEMORYERR;
  217. // SendMessage(NULL,WM_CLOSE,0,0);
  218.     return;
  219. }
  221. //生成预览图像
  222. _fnSPE_Output_Resize(prev_width,prev_height,(LPBYTE)lptemp);
  224. lpPreView=lptemp;
  225. CopyMemory(lpPreBack,lpPreView,mem_size);
  226.    }
  227. DoDlgDraw(lpInfo->hDC,&rt,prev_width,prev_height,lpPreView);
  228. }
  230. // 重定义尺寸,这里借用了临风的格式
  231. int _fnSPE_Output_Resize(int width,int height,LPBYTE lpDestData)
  232. {
  233. LPBYTE lpData=(LPBYTE)lpProcInfo->_psbdata,lpBak,lpBako;
  234. LPBYTE lpdData=lpDestData;
  236. if(lpDestData==NULL )
  237.     return PROCERR_FALSE;
  239. int skip = lpProcInfo->sImageInfo.bitperpix/8;
  241.     float x=(float)lpProcInfo->sImageInfo.width/(float)width;
  242.     float y=(float)lpProcInfo->sImageInfo.height/(float)height;
  243. float x_cnt,y_cnt=0.00;
  245.     lpBak=lpBako=lpData;
  246.     for(int j=0;j<height;j++)
  247.     {
  248. x_cnt=0.00;
  249.        for(int i=0;i<width;i++)
  250.         {
  251. for(int k=0;k<skip;k++)
  252.             {
  253. *lpdData=*lpData;
  254. lpdData++;
  255. lpData++;
  256. }
  257.             x_cnt+=x;
  258.         lpData=lpBak+skip*(int)x_cnt;
  259. }
  260. y_cnt+=y;
  261.       lpBak=lpBako+lpProcInfo->sImageInfo.width*skip*(int)y_cnt;
  262. lpData=lpBak;
  263. }
  264. return TRUE;
  265. }
  267. // 绘制预览图像（缩比）,这里借用了临风的格式
  268. void _fnCOM_DrawResizePrView(int nCtlID,LPDRAWITEMSTRUCT lpInfo)
  269. {
  270. switch(nCtlID)
  271.     {
  272. case IDC_PRVIEW_CONTRAST:
  273. _fnSPE_DrawResizePreView(lpInfo);
  274.             return;
  275. case IDC_PRVIEW_EDGE:
  276. _fnSPE_DrawResizePreView(lpInfo);
  277.             return;
  278. case IDC_PRVIEW_FILTER:
  279. _fnSPE_DrawResizePreView(lpInfo);
  280. return;
  281. }
  282. }
  284. void _fnCOM_SetPos_xy(int x,int y)
  285. {
  286. nPos_x=x;
  287. nPos_y=y;
  288. }
  290. int _fnCOM_GetPosx()
  291. {
  292. return nPos_x;
  293. }
  295. int _fnCOM_GetPosy()
  296. {
  297. return nPos_y;
  298. }
  300. // 绘制预览图像,这里借用了临风的格式
  301. void _fnCOM_DrawPrView(int nCtlID,LPDRAWITEMSTRUCT lpInfo)
  302. {
  303. switch(nCtlID)
  304.     {
  305. case IDC_PRVIEW_CONTRAST:
  306. _fnSPE_DrawPreView(lpInfo,nPos_x,nPos_y,nStype);
  307.             return;
  308. case IDC_PRVIEW_EDGE:
  309. _fnSPE_DrawPreView(lpInfo,nPos_x,nPos_y,nStype);
  310.             return;
  311. case IDC_PRVIEW_FILTER:
  312. _fnSPE_DrawPreView(lpInfo,nPos_x,nPos_y,nStype);
  313.             return;
  315. }
  316. }
  318. // 预览图像的亮度,对比度调节处理函数
  319. void _fnCOM_AdjustContrastPreView(int Brightness,int Contrast)
  320. {
  321. CopyMemory(lpPreView,lpPreBack,mem_size);
  322. LPBYTE pRed=(LPBYTE)lpPreView;
  323. LPBYTE pGrn=pRed+1, pBlu=pRed+2;
  324. int skip=mem_size/prev_width/prev_height;
  326. for(UINT i=0;i<(UINT)prev_width;i++)
  327. {
  328. for(UINT j=0;j<(UINT)prev_height;j++)
  329. {
  330. _fnSPE_ChangeBrightness(Brightness,pRed,pGrn,pBlu);
  331. _fnSPE_ChangeContrast(Contrast,pRed,pGrn,pBlu);
  332.        pRed+=skip;
  333.        pGrn+=skip;
  334.        pBlu+=skip;
  335. }
  336. }
  337. }
  339. // 预览图像的亮度,对比度调节处理函数
  340. void _fnCOM_AdjustConvolutePreView(int nKernel,int nStrength,KERNEL* kernel)
  341. {
  342. CopyMemory(lpPreView,lpPreBack,mem_size);
  344. WORD skip=mem_size/prev_height;
  346. UINT i,j;
  347. for(i=1;i<(UINT)prev_height-1;i++)
  348. {
  349. for(j=1;j<(UINT)prev_width-1;j++)
  350. {
  351. int red=0,green=0,blue=0;
  352. for(int k=0;k<nKernel;++k)
  353. {
  354. int r=0,g=0,b=0;
  355. _fnSPE_Convolute(&r,&g,&b,i,j,skip,lpPreBack,kernel+k);
  356. if(r>red)
  357. red=r;
  358. if(g>green)
  359. green=g;
  360. if(b>blue)
  361. blue=b;
  362. }
  364. LONG lOffset=(LONG)(i*skip)+(LONG)(j*4);
  365. if(nStrength!=100)
  366. {
  367. BYTE Oldb=*(lpPreBack+lOffset++);
  368. BYTE Oldg=*(lpPreBack+lOffset++);
  369. BYTE Oldr=*(lpPreBack+lOffset);
  370. red=Oldr+(((red-Oldr)*nStrength)/100);
  371. green=Oldg+(((green-Oldg)*nStrength)/100);
  372. blue=Oldb+(((blue-Oldb)*nStrength)/100);
  373. lOffset=(LONG)(i*skip)+(LONG)(j*4);
  374. }
  375. *(lpPreView+lOffset++)=(BYTE)((blue)<(0)?(0):((blue)>(255)?(255):(blue)));
  376. *(lpPreView+lOffset++)=(BYTE)((green)<(0)?(0):((green)>(255)?(255):(green)));
  377. *(lpPreView+lOffset)=(BYTE)((red)<(0)?(0):((red)>(255)?(255):(red)));
  378. }
  379. }
  380. }
  382. // 预览图像的亮度,对比度调节处理函数
  383. void _fnCOM_AdjustEdgePreView(int nStrength,BOOL bAlgorith)
  384. {
  385. CopyMemory(lpPreView,lpPreBack,mem_size);
  387. WORD skip=mem_size/prev_height;
  389. UINT i,j;
  390. for(i=1;i<(UINT)prev_height-1;i++)
  391. {
  392. for(j=1;j<(UINT)prev_width-1;j++)
  393. {
  394. int red=0,green=0,blue=0;
  395. _fnSPE_Edge(&red,&green,&blue,i,j,skip,lpPreBack,nStrength,bAlgorith);
  396. LONG lOffset=(LONG)(i*skip)+(LONG)(j*4);
  397. *(lpPreView+lOffset++)=(BYTE)((blue)<(0)?(0):((blue)>(255)?(255):(blue)));
  398. *(lpPreView+lOffset++)=(BYTE)((green)<(0)?(0):((green)>(255)?(255):(green)));
  399. *(lpPreView+lOffset)=(BYTE)((red)<(0)?(0):((red)>(255)?(255):(red)));
  400. }
  401. }
  402. }
  404. void _fnCOM_MedianFilterPreView(int nPels,int nStype)
  405. {
  406. CopyMemory(lpPreView,lpPreBack,mem_size);
  408. WORD skip=mem_size/prev_height;
  410. UINT i,j;
  411. for(i=1;i<(UINT)prev_height-1-1;i++)
  412. {
  413. for(j=1;j<(UINT)prev_width-1;j++)
  414. {
  415. int red=0,green=0,blue=0;
  417. _fnSPE_MedianFilter(&red,&green,&blue,i,j,1,skip,lpPreBack,nStype);
  418. LONG lOffset=(LONG)(i*skip)+(LONG)(j*4);
  420. *(lpPreView+lOffset++)=(BYTE)((blue)<(0)?(0):((blue)>(255)?(255):(blue)));
  421. *(lpPreView+lOffset++)=(BYTE)((green)<(0)?(0):((green)>(255)?(255):(green)));
  422. *(lpPreView+lOffset)=(BYTE)((red)<(0)?(0):((red)>(255)?(255):(red)));
  423. }
  424. }
  425. }
  427. void _fnCOM_HighFilterPreView(int nStrength,int nStype)
  428. {
  429. CopyMemory(lpPreView,lpPreBack,mem_size);
  431. WORD skip=mem_size/prev_height;
  432. static DWORD dwFact[9];
  434. switch(nStype)
  435. {
  436. case 0:
  437. dwFact[0]=10;
  438. dwFact[1]=10;
  439. dwFact[2]=10;
  440. dwFact[3]=10;
  441. dwFact[4]=160+nStrength;
  442. dwFact[5]=10;
  443. dwFact[6]=10;
  444. dwFact[7]=10;
  445. dwFact[8]=10;
  446. break;
  447. case 1:
  448. dwFact[0]=10;
  449. dwFact[1]=10;
  450. dwFact[2]=10;
  451. dwFact[3]=10;
  452. dwFact[4]=10;
  453. dwFact[5]=10;
  454. dwFact[6]=10;
  455. dwFact[7]=10;
  456. dwFact[8]=10;
  457. break;
  458. }
  460. UINT i,j;
  461. for(i=1;i<(UINT)prev_height-1-1;i++)
  462. {
  463. for(j=1;j<(UINT)prev_width-1;j++)
  464. {
  465. int red=0,green=0,blue=0;
  467. _fnSPE_Filter(&red,&green,&blue,i,j,skip,lpPreBack,dwFact);
  468. LONG lOffset=(LONG)(i*skip)+(LONG)(j*4);
  470. *(lpPreView+lOffset++)=(BYTE)((blue)<(0)?(0):((blue)>(255)?(255):(blue)));
  471. *(lpPreView+lOffset++)=(BYTE)((green)<(0)?(0):((green)>(255)?(255):(green)));
  472. *(lpPreView+lOffset)=(BYTE)((red)<(0)?(0):((red)>(255)?(255):(red)));
  473. }
  474. }
  475. }