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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > GDI/图象编程 > 查看源码
Dib.cpp
资源名称：RotateByShear_demo.zip　[点击查看]
上传用户：weiyeyoule
上传日期：2007-01-03
资源大小：21k
文件大小：29k
源码类别：

GDI/图象编程

开发平台：

Visual C++

Dib.cpp：源码内容
  1. #include "stdafx.h"
  2. #include "DIB.h"
  4. #define PPM_EXT             ".PPM"
  6. BOOL CDIB::Create ( int Width, int Height )
  7. {
  8.     Destroy ();
  10.     ZeroMemory ( &m_Info, sizeof (BITMAPINFO) );
  12.     m_Info.bmiHeader.biSize=sizeof (BITMAPINFOHEADER);
  13.     m_Info.bmiHeader.biWidth=Width;
  14.     m_Info.bmiHeader.biHeight=Height;
  15.     m_Info.bmiHeader.biPlanes=1;
  16.     m_Info.bmiHeader.biBitCount=32; 
  17.     m_Info.bmiHeader.biCompression=BI_RGB;
  18.     m_Info.bmiHeader.biSizeImage=Width*Height*4;
  19.     
  20.     m_Bitmap=CreateDIBSection ( NULL, &m_Info, DIB_RGB_COLORS, (void **)&m_Bits, NULL, NULL ); 
  22.     if ( m_Bitmap )
  23.     {
  24.         m_Size=CSize ( Width, Height );
  25.         return TRUE;
  26.     }
  27.     else
  28.     {
  29.         m_Size=CSize ( 0, 0 );
  30.         return FALSE;
  31.     }
  32. }
  34. BOOL CDIB::Create (CDC *pDC, UINT uBitmapID)
  35. {   // Creates from a bitmap
  36.     CDC BufferDC;
  37.     CBitmap BufferBitmap, *OldBitmap;
  39.     if (!BufferBitmap.LoadBitmap (uBitmapID))
  40.         return FALSE;   // Can't load resource bitmap
  41.     BITMAP bmpData;
  42.     if (!BufferBitmap.GetBitmap (&bmpData))
  43.         return FALSE;   // Can't get bitmap info
  44.     if (!Create (bmpData.bmWidth, bmpData.bmHeight))
  45.         return FALSE;   // Can't create DIB buffer
  47.     BufferDC.CreateCompatibleDC (pDC);
  48.     OldBitmap=BufferDC.SelectObject (&BufferBitmap);
  49.     GetDIBits (BufferDC.m_hDC, HBITMAP(BufferBitmap), 0, m_Size.cy, m_Bits, &(m_Info), DIB_RGB_COLORS); 
  50.     BufferDC.SelectObject (OldBitmap);
  51.     BufferBitmap.DeleteObject();
  52.     return TRUE;
  53. }
  55. void CDIB::Destroy ()
  56. {
  57.     if ( m_Bitmap )
  58.         DeleteObject ( m_Bitmap );
  59.     m_Bitmap=NULL;
  60.     m_Size=CSize ( 0, 0 );
  61. }
  64. void CDIB::GetFromDC ( CDC *pDC, int x, int y, int w, int h )
  65. {
  66.     // If DibSize Wrong Re-Create Dib
  67.     if ( (m_Size.cx!=w) || (m_Size.cy!=h) )
  68.         Create ( w, h );
  69.     
  70.     CDC BufferDC;
  71.     CBitmap BufferBitmap, *OldBitmap;
  73.     BufferDC.CreateCompatibleDC ( pDC );
  74.     BufferBitmap.CreateCompatibleBitmap ( pDC, w, h );
  75.     OldBitmap=BufferDC.SelectObject ( &BufferBitmap );
  76.     BufferDC.FillSolidRect ( 0, 0, w, h, 0 );
  77.     BufferDC.BitBlt ( 0, 0, w, h, pDC, x, y, SRCCOPY );
  78.     BufferDC.SelectObject ( OldBitmap );
  79.     GetDIBits ( pDC->m_hDC, HBITMAP(BufferBitmap), 0, h, m_Bits, &(m_Info), DIB_RGB_COLORS ); 
  80. }
  82. DIBLoadResult 
  83. CDIB::Load (CString cstrFile)
  84. {
  86.     if ((4 < cstrFile.GetLength()) && 
  87.         (0 == (cstrFile.Right(4)).CompareNoCase(PPM_EXT)))
  88.     {   // The extension is suggesting it's a binary PPM (P6) file
  89.         return LoadPPM ( cstrFile );
  90.     } 
  91.     // Unsupported file type
  92.     return DIB_LOAD_NOFILE_OR_CORRUPT;
  93. }
  96. void CDIB::Fill ( int R, int G, int B )
  97. {
  98.     COLORREF Color=RGB ( B, G, R );
  99.     int Size=m_Size.cx*m_Size.cy;
  101.     for ( int i=0; i<Size; i++ )
  102.         m_Bits[i]=Color;
  103. }
  105. void CDIB::FillGlass ( int R, int G, int B, int A )
  106. {
  107.     BYTE *dst=(BYTE*)m_Bits;
  108.     int Size=m_Size.cx*m_Size.cy;
  109.         
  110.     while ( Size-- )
  111.     {
  112.         dst[0]=(BYTE)(((B-dst[0])*A+(dst[0]<<8))>>8);
  113.         dst[1]=(BYTE)(((G-dst[1])*A+(dst[1]<<8))>>8);
  114.         dst[2]=(BYTE)(((R-dst[2])*A+(dst[2]<<8))>>8);   
  115.         dst+=4;
  116.     }
  117. }
  119. void CDIB::FillStippledGlass ( int R, int G, int B )
  120. {   
  121.     COLORREF Color=RGB ( B, G, R );
  122.     int w=m_Size.cx;
  123.     int h=m_Size.cy;
  125.     for ( int j=0; j<w; j++ )
  126.     {
  127.         for ( int i=0; i<h; i++ )
  128.         {
  129.             m_Bits[j*w+i]=((i+j)&0x1) ? m_Bits[j*w+i] : Color;
  130.         }
  131.     }
  132. }
  134. void CDIB::CopyTransparentlyFrom ( CDIB *Dib, int R, int G, int B )
  135. {
  136.     if ( m_Size!=Dib->m_Size )
  137.         return;
  139.     COLORREF *src=Dib->m_Bits;
  140.     COLORREF *dst=m_Bits;
  141.     COLORREF ColorKey=RGB ( B, G, R );
  142.     int Size=m_Size.cx*m_Size.cy;
  143.         
  144.     while ( Size-- )
  145.     {
  146.         dst[0]=(src[0]==ColorKey) ? dst[0] : src[0];    
  147.         dst++;
  148.         src++;
  149.     }
  150. }
  152. void CDIB::Add ( CDIB *Dib )
  153. {
  154.     if ( m_Size!=Dib->m_Size )
  155.         return;
  157.     BYTE *src=(BYTE*)Dib->m_Bits;
  158.     BYTE *dst=(BYTE*)m_Bits;
  159.     int Size=m_Size.cx*m_Size.cy;
  161.     int Sum;
  162.         
  163.     while ( Size-- )
  164.     {
  165.         Sum=src[0]+dst[0];
  166.         dst[0]=(BYTE)((Sum>255) ? 255 : Sum);
  167.         Sum=src[1]+dst[1];
  168.         dst[1]=(BYTE)((Sum>255) ? 255 : Sum);
  169.         Sum=src[2]+dst[2];
  170.         dst[2]=(BYTE)((Sum>255) ? 255 : Sum);   
  171.         dst+=4;
  172.         src+=4;
  173.     }
  174. }
  176. void CDIB::Blend ( CDIB *Dib, int A )
  177. {
  178.     if ( m_Size!=Dib->m_Size )
  179.         return;
  181.     BYTE *src=(BYTE*)Dib->m_Bits;
  182.     BYTE *dst=(BYTE*)m_Bits;
  183.     int Size=m_Size.cx*m_Size.cy;
  184.         
  185.     while ( Size-- )
  186.     {
  187.         dst[0]=(BYTE)(((src[0]-dst[0])*A+(dst[0]<<8))>>8);
  188.         dst[1]=(BYTE)(((src[1]-dst[1])*A+(dst[1]<<8))>>8);
  189.         dst[2]=(BYTE)(((src[2]-dst[2])*A+(dst[2]<<8))>>8);  
  190.         dst+=4;
  191.         src+=4;
  192.     }
  193. }
  195. void CDIB::Darken ( CDIB *Dib )
  196. {
  197.     if ( m_Size!=Dib->m_Size )
  198.         return;
  200.     BYTE *src=(BYTE*)Dib->m_Bits;
  201.     BYTE *dst=(BYTE*)m_Bits;
  202.     int Size=m_Size.cx*m_Size.cy;
  203.         
  204.     while ( Size-- )
  205.     {
  206.         dst[0]=(BYTE)((src[0]<dst[0]) ? src[0] : dst[0]);
  207.         dst[1]=(BYTE)((src[1]<dst[1]) ? src[1] : dst[1]);
  208.         dst[2]=(BYTE)((src[2]<dst[2]) ? src[2] : dst[2]);   
  209.         dst+=4;
  210.         src+=4;
  211.     }
  212. }
  214. void CDIB::Difference ( CDIB *Dib )
  215. {
  216.     if ( m_Size!=Dib->m_Size )
  217.         return;
  219.     BYTE *src=(BYTE*)Dib->m_Bits;
  220.     BYTE *dst=(BYTE*)m_Bits;
  221.     int Size=m_Size.cx*m_Size.cy;
  223.     int Difference;
  225.     while ( Size-- )
  226.     {
  227.         Difference=src[0]-dst[0];
  228.         dst[0]=(BYTE)((Difference<0) ? -Difference : Difference);
  229.         Difference=src[1]-dst[1];
  230.         dst[1]=(BYTE)((Difference<0) ? -Difference : Difference);
  231.         Difference=src[2]-dst[2];
  232.         dst[2]=(BYTE)((Difference<0) ? -Difference : Difference);   
  233.         dst+=4;
  234.         src+=4;
  235.     }
  236. }
  238. void CDIB::Lighten ( CDIB *Dib )
  239. {
  240.     if ( m_Size!=Dib->m_Size )
  241.         return;
  243.     BYTE *src=(BYTE*)Dib->m_Bits;
  244.     BYTE *dst=(BYTE*)m_Bits;
  245.     int Size=m_Size.cx*m_Size.cy;
  246.         
  247.     while ( Size-- )
  248.     {
  249.         dst[0]=(BYTE)((src[0]>dst[0]) ? src[0] : dst[0]);
  250.         dst[1]=(BYTE)((src[1]>dst[1]) ? src[1] : dst[1]);
  251.         dst[2]=(BYTE)((src[2]>dst[2]) ? src[2] : dst[2]);   
  252.         dst+=4;
  253.         src+=4;
  254.     }
  255. }
  257. void CDIB::Multiply ( CDIB *Dib )
  258. {
  259.     if ( m_Size!=Dib->m_Size )
  260.         return;
  262.     BYTE *src=(BYTE*)Dib->m_Bits;
  263.     BYTE *dst=(BYTE*)m_Bits;
  264.     int Size=m_Size.cx*m_Size.cy;
  265.         
  266.     while ( Size-- )
  267.     {
  268.         dst[0]=(BYTE)(((src[0])*(dst[0]))>>8);
  269.         dst[1]=(BYTE)(((src[1])*(dst[1]))>>8);
  270.         dst[2]=(BYTE)(((src[2])*(dst[2]))>>8);  
  271.         dst+=4;
  272.         src+=4;
  273.     }
  274. }
  276. void CDIB::Screen ( CDIB *Dib )
  277. {
  278.     if ( m_Size!=Dib->m_Size )
  279.         return;
  281.     BYTE *src=(BYTE*)Dib->m_Bits;
  282.     BYTE *dst=(BYTE*)m_Bits;
  283.     int Size=m_Size.cx*m_Size.cy;
  284.         
  285.     while ( Size-- )
  286.     {
  287.         dst[0]=(BYTE)(255-(((255-src[0])*(255-dst[0]))>>8));
  288.         dst[1]=(BYTE)(255-(((255-src[1])*(255-dst[1]))>>8));
  289.         dst[2]=(BYTE)(255-(((255-src[2])*(255-dst[2]))>>8));    
  290.         dst+=4;
  291.         src+=4;
  292.     }
  293. }
  295. //////////////////////////////////////////////////////////////////////
  296. // Rectangle Functions
  297. //////////////////////////////////////////////////////////////////////
  299. void CDIB::CopyRect ( CDIB *Dib, int x, int y )
  300. {
  301.     // Clip Rect
  302.     int px=(x>=0) ? x : 0;
  303.     int py=(y>=0) ? y : 0;
  304.     int dx=((x+Dib->m_Size.cx)<m_Size.cx) ? Dib->m_Size.cx : m_Size.cx-x;
  305.     int dy=((y+Dib->m_Size.cy)<m_Size.cy) ? Dib->m_Size.cy : m_Size.cy-y;
  306.     dx=(x>=0) ? dx : dx + x;
  307.     dy=(y>=0) ? dy : dy + y;
  309.     // If Nothing to Copy return
  310.     if ( (dx<=0) || (dy<=0) )
  311.         return;
  312.     // If DibSize Wrong Re-Create Dib
  313.     if ( (dx!=Dib->m_Size.cx) || (dy!=Dib->m_Size.cy) )
  314.         Dib->Create ( dx, dy );
  316.     // Prepare Buffer Addresses
  317.     COLORREF *src=m_Bits+(py*m_Size.cx)+px;
  318.     COLORREF *dst=Dib->m_Bits;
  320.     // Do Copy
  321.     while ( dy-- )
  322.     {
  323.         for ( int i=0; i<dx; i++ )
  324.             dst[i]=src[i];
  325.         src+=m_Size.cx;
  326.         dst+=Dib->m_Size.cx;
  327.     }
  328. }
  330. void CDIB::PasteRect ( CDIB *Dib, int x, int y )
  331. {
  332.     // Clip Rect
  333.     int px=(x>=0) ? x : 0;
  334.     int py=(y>=0) ? y : 0;
  335.     int dx=((x+Dib->m_Size.cx)<m_Size.cx) ? Dib->m_Size.cx : m_Size.cx-x;
  336.     int dy=((y+Dib->m_Size.cy)<m_Size.cy) ? Dib->m_Size.cy : m_Size.cy-y;
  337.     dx=(x>=0) ? dx : dx + x;
  338.     dy=(y>=0) ? dy : dy + y;
  340.     // If Nothing to Paste return
  341.     if ( (dx<=0) || (dy<=0) )
  342.         return;
  344.     // Prepare Buffer Addresses
  345.     COLORREF *src=Dib->m_Bits+((py-y)*Dib->m_Size.cx)+px-x;
  346.     COLORREF *dst=m_Bits+(py*m_Size.cx)+px;
  348.     // Do Paste
  349.     while ( dy-- )
  350.     {
  351.         for ( int i=0; i<dx; i++ )
  352.             dst[i]=src[i];
  353.         src+=Dib->m_Size.cx;
  354.         dst+=m_Size.cx;
  355.     }
  356. }
  358. void CDIB::PasteCKRect ( CDIB *Dib, int x, int y, int R, int G, int B )
  359. {
  360.     // Clip Rect
  361.     int px=(x>=0) ? x : 0;
  362.     int py=(y>=0) ? y : 0;
  363.     int dx=((x+Dib->m_Size.cx)<m_Size.cx) ? Dib->m_Size.cx : m_Size.cx-x;
  364.     int dy=((y+Dib->m_Size.cy)<m_Size.cy) ? Dib->m_Size.cy : m_Size.cy-y;
  365.     dx=(x>=0) ? dx : dx + x;
  366.     dy=(y>=0) ? dy : dy + y;
  368.     // If Nothing to Paste return
  369.     if ( (dx<=0) || (dy<=0) )
  370.         return;
  372.     // Prepare Buffer Addresses
  373.     COLORREF *src=Dib->m_Bits+((py-y)*Dib->m_Size.cx)+px-x;
  374.     COLORREF *dst=m_Bits+(py*m_Size.cx)+px;
  375.     COLORREF ColorKey=RGB ( B, G, R );
  377.     // Do Paste
  378.     while ( dy-- )
  379.     {
  380.         for ( int i=0; i<dx; i++ )
  381.             dst[i]=(src[i]==ColorKey) ? dst[i] : src[i];
  382.         src+=Dib->m_Size.cx;
  383.         dst+=m_Size.cx;
  384.     }
  385. }
  387. void CDIB::FillRect ( int x, int y, int w, int h, int R, int G, int B )
  388. {
  389.     // Clip Rect
  390.     int px=(x>=0) ? x : 0;
  391.     int py=(y>=0) ? y : 0;
  392.     int dx=((x+w)<m_Size.cx) ? w : m_Size.cx-x;
  393.     int dy=((y+h)<m_Size.cy) ? h : m_Size.cy-y;
  394.     dx=(x>=0) ? dx : dx + x;
  395.     dy=(y>=0) ? dy : dy + y;
  397.     // If Nothing to Fill return
  398.     if ( (dx<=0) || (dy<=0) )
  399.         return;
  401.     // Prepare Buffer Address
  402.     COLORREF *dst=m_Bits+(py*m_Size.cx)+px;
  403.     COLORREF Color=RGB ( B, G, R );
  405.     // Do Fill
  406.     while ( dy-- )
  407.     {
  408.         for ( int i=0; i<dx; i++ )
  409.         {
  410.             dst[i]=Color;   
  411.         }
  412.         dst+=m_Size.cx;
  413.     }
  414. }
  416. void CDIB::FillGlassRect ( int x, int y, int w, int h, int R, int G, int B, int A )
  417. {
  418.     // Clip Rect
  419.     int px=(x>=0) ? x : 0;
  420.     int py=(y>=0) ? y : 0;
  421.     int dx=((x+w)<m_Size.cx) ? w : m_Size.cx-x;
  422.     int dy=((y+h)<m_Size.cy) ? h : m_Size.cy-y;
  423.     dx=(x>=0) ? dx : dx + x;
  424.     dy=(y>=0) ? dy : dy + y;
  426.     // If Nothing to FillGlass return
  427.     if ( (dx<=0) || (dy<=0) )
  428.         return;
  430.     // Prepare Buffer Address
  431.     BYTE *dst=(BYTE *)m_Bits+((py*m_Size.cx)+px)*4;
  433.     // Do FillGlass
  434.     while ( dy-- )
  435.     {
  436.         for ( int i=0; i<dx; i++ )
  437.         {
  438.             dst[0]=(BYTE)(((B-dst[0])*A+(dst[0]<<8))>>8);
  439.             dst[1]=(BYTE)(((G-dst[1])*A+(dst[1]<<8))>>8);
  440.             dst[2]=(BYTE)(((R-dst[2])*A+(dst[2]<<8))>>8);   
  441.             dst+=4;
  442.         }
  443.         dst+=(m_Size.cx-dx)<<2;
  444.     }
  445. }
  447. void CDIB::FillStippledGlassRect ( int x, int y, int w, int h, int R, int G, int B )
  448. {
  449.     // Clip Rect
  450.     int px=(x>=0) ? x : 0;
  451.     int py=(y>=0) ? y : 0;
  452.     int dx=((x+w)<m_Size.cx) ? w : m_Size.cx-x;
  453.     int dy=((y+h)<m_Size.cy) ? h : m_Size.cy-y;
  454.     dx=(x>=0) ? dx : dx + x;
  455.     dy=(y>=0) ? dy : dy + y;
  457.     // If Nothing to FillStippledGlass return
  458.     if ( (dx<=0) || (dy<=0) )
  459.         return;
  461.     // Prepare Buffer Address
  462.     COLORREF *dst=m_Bits+(py*m_Size.cx)+px;
  463.     COLORREF Color=RGB ( B, G, R );
  465.     // Do FillStippledGlass
  466.     for ( int j=0; j<dy; j++ )
  467.     {
  468.         for ( int i=0; i<dx; i++ )
  469.         {
  470.             dst[i]=((i+j)&0x1) ? dst[i] : Color;    
  471.         }
  472.         dst+=m_Size.cx;
  473.     }
  474. }
  476. void CDIB::AddRect ( CDIB *Dib, int x, int y )
  477. {
  478.     // Clip Rect
  479.     int px=(x>=0) ? x : 0;
  480.     int py=(y>=0) ? y : 0;
  481.     int dx=((x+Dib->m_Size.cx)<m_Size.cx) ? Dib->m_Size.cx : m_Size.cx-x;
  482.     int dy=((y+Dib->m_Size.cy)<m_Size.cy) ? Dib->m_Size.cy : m_Size.cy-y;
  483.     dx=(x>=0) ? dx : dx + x;
  484.     dy=(y>=0) ? dy : dy + y;
  486.     // If Nothing to Add return
  487.     if ( (dx<=0) || (dy<=0) )
  488.         return;
  490.     // Prepare Buffer Addresses
  491.     BYTE *src=(BYTE *)Dib->m_Bits+(((py-y)*Dib->m_Size.cx)+px-x)*4;
  492.     BYTE *dst=(BYTE *)m_Bits+((py*m_Size.cx)+px)*4;
  494.     int Sum;
  496.     // Do Add
  497.     while ( dy-- )
  498.     {
  499.         for ( int i=0; i<dx; i++ )
  500.         {
  501.             Sum=src[0]+dst[0];
  502.             dst[0]=(BYTE)((Sum>255) ? 255 : Sum);
  503.             Sum=src[1]+dst[1];
  504.             dst[1]=(BYTE)((Sum>255) ? 255 : Sum);
  505.             Sum=src[2]+dst[2];
  506.             dst[2]=(BYTE)((Sum>255) ? 255 : Sum);   
  507.             dst+=4;
  508.             src+=4;
  509.         }
  510.         dst+=(m_Size.cx-dx)<<2;
  511.         src+=(Dib->m_Size.cx-dx)<<2;
  512.     }
  513. }
  515. void CDIB::BlendRect ( CDIB *Dib, int x, int y, int A )
  516. {
  517.     // Clip Rect
  518.     int px=(x>=0) ? x : 0;
  519.     int py=(y>=0) ? y : 0;
  520.     int dx=((x+Dib->m_Size.cx)<m_Size.cx) ? Dib->m_Size.cx : m_Size.cx-x;
  521.     int dy=((y+Dib->m_Size.cy)<m_Size.cy) ? Dib->m_Size.cy : m_Size.cy-y;
  522.     dx=(x>=0) ? dx : dx + x;
  523.     dy=(y>=0) ? dy : dy + y;
  525.     // If Nothing to Blend return
  526.     if ( (dx<=0) || (dy<=0) )
  527.         return;
  529.     // Prepare Buffer Addresses
  530.     BYTE *src=(BYTE *)Dib->m_Bits+(((py-y)*Dib->m_Size.cx)+px-x)*4;
  531.     BYTE *dst=(BYTE *)m_Bits+((py*m_Size.cx)+px)*4;
  533.     // Do Blend
  534.     while ( dy-- )
  535.     {
  536.         for ( int i=0; i<dx; i++ )
  537.         {
  538.             dst[0]=(BYTE)(((src[0]-dst[0])*A+(dst[0]<<8))>>8);
  539.             dst[1]=(BYTE)(((src[1]-dst[1])*A+(dst[1]<<8))>>8);
  540.             dst[2]=(BYTE)(((src[2]-dst[2])*A+(dst[2]<<8))>>8);  
  541.             dst+=4;
  542.             src+=4;
  543.         }
  544.         dst+=(m_Size.cx-dx)<<2;
  545.         src+=(Dib->m_Size.cx-dx)<<2;
  546.     }
  547. }
  549. void CDIB::DarkenRect ( CDIB *Dib, int x, int y )
  550. {
  551.     // Clip Rect
  552.     int px=(x>=0) ? x : 0;
  553.     int py=(y>=0) ? y : 0;
  554.     int dx=((x+Dib->m_Size.cx)<m_Size.cx) ? Dib->m_Size.cx : m_Size.cx-x;
  555.     int dy=((y+Dib->m_Size.cy)<m_Size.cy) ? Dib->m_Size.cy : m_Size.cy-y;
  556.     dx=(x>=0) ? dx : dx + x;
  557.     dy=(y>=0) ? dy : dy + y;
  559.     // If Nothing to Darken return
  560.     if ( (dx<=0) || (dy<=0) )
  561.         return;
  563.     // Prepare Buffer Addresses
  564.     BYTE *src=(BYTE *)Dib->m_Bits+(((py-y)*Dib->m_Size.cx)+px-x)*4;
  565.     BYTE *dst=(BYTE *)m_Bits+((py*m_Size.cx)+px)*4;
  567.     // Do Darken
  568.     while ( dy-- )
  569.     {
  570.         for ( int i=0; i<dx; i++ )
  571.         {
  572.             dst[0]=(BYTE)((src[0]<dst[0]) ? src[0] : dst[0]);
  573.             dst[1]=(BYTE)((src[1]<dst[1]) ? src[1] : dst[1]);
  574.             dst[2]=(BYTE)((src[2]<dst[2]) ? src[2] : dst[2]);   
  575.             dst+=4;
  576.             src+=4;
  577.         }
  578.         dst+=(m_Size.cx-dx)<<2;
  579.         src+=(Dib->m_Size.cx-dx)<<2;
  580.     }
  581. }
  583. void CDIB::DifferenceRect ( CDIB *Dib, int x, int y )
  584. {
  585.     // Clip Rect
  586.     int px=(x>=0) ? x : 0;
  587.     int py=(y>=0) ? y : 0;
  588.     int dx=((x+Dib->m_Size.cx)<m_Size.cx) ? Dib->m_Size.cx : m_Size.cx-x;
  589.     int dy=((y+Dib->m_Size.cy)<m_Size.cy) ? Dib->m_Size.cy : m_Size.cy-y;
  590.     dx=(x>=0) ? dx : dx + x;
  591.     dy=(y>=0) ? dy : dy + y;
  593.     // If Nothing to Difference return
  594.     if ( (dx<=0) || (dy<=0) )
  595.         return;
  597.     // Prepare Buffer Addresses
  598.     BYTE *src=(BYTE *)Dib->m_Bits+(((py-y)*Dib->m_Size.cx)+px-x)*4;
  599.     BYTE *dst=(BYTE *)m_Bits+((py*m_Size.cx)+px)*4;
  601.     // Do Difference
  602.     while ( dy-- )
  603.     {
  604.         for ( int i=0; i<dx; i++ )
  605.         {
  606.             int Difference;
  607.             Difference=src[0]-dst[0];
  608.             dst[0]=(BYTE)((Difference<0) ? -Difference : Difference);
  609.             Difference=src[1]-dst[1];
  610.             dst[1]=(BYTE)((Difference<0) ? -Difference : Difference);
  611.             Difference=src[2]-dst[2];
  612.             dst[2]=(BYTE)((Difference<0) ? -Difference : Difference);   
  613.             dst+=4;
  614.             src+=4;
  615.         }
  616.         dst+=(m_Size.cx-dx)<<2;
  617.         src+=(Dib->m_Size.cx-dx)<<2;
  618.     }
  619. }
  621. void CDIB::LightenRect ( CDIB *Dib, int x, int y )
  622. {
  623.     // Clip Rect
  624.     int px=(x>=0) ? x : 0;
  625.     int py=(y>=0) ? y : 0;
  626.     int dx=((x+Dib->m_Size.cx)<m_Size.cx) ? Dib->m_Size.cx : m_Size.cx-x;
  627.     int dy=((y+Dib->m_Size.cy)<m_Size.cy) ? Dib->m_Size.cy : m_Size.cy-y;
  628.     dx=(x>=0) ? dx : dx + x;
  629.     dy=(y>=0) ? dy : dy + y;
  631.     // If Nothing to Lighten return
  632.     if ( (dx<=0) || (dy<=0) )
  633.         return;
  635.     // Prepare Buffer Addresses
  636.     BYTE *src=(BYTE *)Dib->m_Bits+(((py-y)*Dib->m_Size.cx)+px-x)*4;
  637.     BYTE *dst=(BYTE *)m_Bits+((py*m_Size.cx)+px)*4;
  639.     // Do Lighten
  640.     while ( dy-- )
  641.     {
  642.         for ( int i=0; i<dx; i++ )
  643.         {
  644.             dst[0]=(BYTE)((src[0]>dst[0]) ? src[0] : dst[0]);
  645.             dst[1]=(BYTE)((src[1]>dst[1]) ? src[1] : dst[1]);
  646.             dst[2]=(BYTE)((src[2]>dst[2]) ? src[2] : dst[2]);
  647.             dst+=4;
  648.             src+=4;
  649.         }
  650.         dst+=(m_Size.cx-dx)<<2;
  651.         src+=(Dib->m_Size.cx-dx)<<2;
  652.     }
  653. }
  655. void CDIB::MultiplyRect ( CDIB *Dib, int x, int y )
  656. {
  657.     // Clip Rect
  658.     int px=(x>=0) ? x : 0;
  659.     int py=(y>=0) ? y : 0;
  660.     int dx=((x+Dib->m_Size.cx)<m_Size.cx) ? Dib->m_Size.cx : m_Size.cx-x;
  661.     int dy=((y+Dib->m_Size.cy)<m_Size.cy) ? Dib->m_Size.cy : m_Size.cy-y;
  662.     dx=(x>=0) ? dx : dx + x;
  663.     dy=(y>=0) ? dy : dy + y;
  665.     // If Nothing to Multiply return
  666.     if ( (dx<=0) || (dy<=0) )
  667.         return;
  669.     // Prepare Buffer Addresses
  670.     BYTE *src=(BYTE *)Dib->m_Bits+(((py-y)*Dib->m_Size.cx)+px-x)*4;
  671.     BYTE *dst=(BYTE *)m_Bits+((py*m_Size.cx)+px)*4;
  673.     // Do Multiply
  674.     while ( dy-- )
  675.     {
  676.         for ( int i=0; i<dx; i++ )
  677.         {
  678.             dst[0]=(BYTE)(((src[0])*(dst[0]))>>8);
  679.             dst[1]=(BYTE)(((src[1])*(dst[1]))>>8);
  680.             dst[2]=(BYTE)(((src[2])*(dst[2]))>>8);
  681.             dst+=4;
  682.             src+=4;
  683.         }
  684.         dst+=(m_Size.cx-dx)<<2;
  685.         src+=(Dib->m_Size.cx-dx)<<2;
  686.     }
  687. }
  689. void CDIB::ScreenRect ( CDIB *Dib, int x, int y )
  690. {
  691.     // Clip Rect
  692.     int px=(x>=0) ? x : 0;
  693.     int py=(y>=0) ? y : 0;
  694.     int dx=((x+Dib->m_Size.cx)<m_Size.cx) ? Dib->m_Size.cx : m_Size.cx-x;
  695.     int dy=((y+Dib->m_Size.cy)<m_Size.cy) ? Dib->m_Size.cy : m_Size.cy-y;
  696.     dx=(x>=0) ? dx : dx + x;
  697.     dy=(y>=0) ? dy : dy + y;
  699.     // If Nothing to Screen return
  700.     if ( (dx<=0) || (dy<=0) )
  701.         return;
  703.     // Prepare Buffer Addresses
  704.     BYTE *src=(BYTE *)Dib->m_Bits+(((py-y)*Dib->m_Size.cx)+px-x)*4;
  705.     BYTE *dst=(BYTE *)m_Bits+((py*m_Size.cx)+px)*4;
  707.     // Do Screen
  708.     while ( dy-- )
  709.     {
  710.         for ( int i=0; i<dx; i++ )
  711.         {
  712.             dst[0]=(BYTE)(255-(((255-src[0])*(255-dst[0]))>>8));
  713.             dst[1]=(BYTE)(255-(((255-src[1])*(255-dst[1]))>>8));
  714.             dst[2]=(BYTE)(255-(((255-src[2])*(255-dst[2]))>>8));
  715.             dst+=4;
  716.             src+=4;
  717.         }
  718.         dst+=(m_Size.cx-dx)<<2;
  719.         src+=(Dib->m_Size.cx-dx)<<2;
  720.     }
  721. }
  723. //////////////////////////////////////////////////////////////////////
  724. // Line Functions
  725. //////////////////////////////////////////////////////////////////////
  727. #define CLIPCODE(x,y) (((x<0)?8:0)|((x>=m_Size.cx)?4:0)|((y<0)?2:0)|((y>=m_Size.cy)?1:0))
  729. void CDIB::ClippedLine ( int x1, int y1, int x2, int y2, int R, int G, int B )
  730. {
  731.     int c1=CLIPCODE(x1,y1), 
  732.         c2=CLIPCODE(x2,y2);
  733.     
  734.     int dx, dy;
  735.     while ( (c1|c2)!=0 )
  736.     {
  737.         if ( (c1&c2)!=0 )
  738.             return;
  739.         dx=x2-x1;
  740.         dy=y2-y1;
  741.         if ( c1!=0 )
  742.         {  
  743.             if ( (c1&8)==8)
  744.             {
  745.                 y1+=(0-x1)*dy/dx;
  746.                 x1=0;
  747.             }  
  748.             else if ( (c1&4)==4)
  749.             {
  750.                 y1+=(m_Size.cx-1-x1)*dy/dx;
  751.                 x1=m_Size.cx-1;
  752.             }  
  753.             else if ((c1&2) == 2)
  754.             {
  755.                 x1+=(0-y1)*dx/dy;
  756.                 y1=0;
  757.             }  
  758.             else
  759.             if ( (c1&1)==1)
  760.             {
  761.                 x1+=(m_Size.cy-1-y1)*dx/dy;
  762.                 y1=m_Size.cy-1;
  763.             }  
  764.             c1=CLIPCODE(x1,y1);
  765.          }  
  766.          else if ( c2!=0 )
  767.          {
  768.             if ( (c2&8)==8 )
  769.             {
  770.                 y2+=(0-x2)*dy/dx;
  771.                 x2=0;
  772.             }  
  773.             else if ( (c2&4)==4 )
  774.             {
  775.                 y2+=(m_Size.cx-1-x2)*dy/dx;
  776.                 x2=m_Size.cx-1;
  777.             }  
  778.             else if ( (c2&2)==2 )
  779.             {
  780.                 x2+=(0-y2)*dx/dy;
  781.                 y2=0;
  782.             }  
  783.             else if ( (c2&1)==1 )
  784.             {
  785.                 x2+=(m_Size.cy-1-y2)*dx/dy;
  786.                 y2=m_Size.cy-1;
  787.             }  
  788.             c2=CLIPCODE(x2,y2);
  789.         }  
  790.     }
  791.     
  792.     int d, x, y, ax, ay, sx, sy;
  793.     COLORREF Color=RGB ( B, G, R );
  794.     
  795.     dx=x2-x1;
  796.     ax=abs ( dx )<<1;
  797.     sx=(dx<0) ? -1 : 1;
  798.     dy=y2-y1;
  799.     ay=abs ( dy )<<1;
  800.     sy=(dy<0) ? -1 : 1;
  801.     x=x1;
  802.     y=y1;
  803.     
  804.     if ( ax>ay )
  805.     {
  806.         d=ay-(ax>>1);
  807.         while ( x!=x2 )
  808.         {
  809.             m_Bits[y*m_Size.cx+x]=Color;
  810.             if ( d>=0 )
  811.             {
  812.                 y+=sy;
  813.                 d-=ax;
  814.             }
  815.             x+=sx;
  816.             d+=ay;
  817.         }
  818.     }
  819.     else
  820.     {
  821.         d=ax-(ay>>1);
  822.         while ( y!=y2 )
  823.         {
  824.             m_Bits[y*m_Size.cx+x]=Color;
  825.             if ( d>=0 )
  826.             {
  827.                 x+=sx;
  828.                 d-=ay;
  829.             }
  830.             y+=sy;
  831.             d+=ax;
  832.         }
  833.     }
  834. }
  836. void CDIB::Line ( int x1, int y1, int x2, int y2, int R, int G, int B )
  837. {
  838.     int d, x, y, ax, ay, sx, sy, dx, dy;
  839.     COLORREF Color=RGB ( B, G, R );
  840.     
  841.     dx=x2-x1;
  842.     ax=abs ( dx )<<1;
  843.     sx=(dx<0) ? -1 : 1;
  844.     dy=y2-y1;
  845.     ay=abs ( dy )<<1;
  846.     sy=(dy<0) ? -1 : 1;
  847.     x=x1;
  848.     y=y1;
  849.     
  850.     if ( ax>ay )
  851.     {
  852.         d=ay-(ax>>1);
  853.         while ( x!=x2 )
  854.         {
  855.             m_Bits[y*m_Size.cx+x]=Color;
  856.             if ( d>=0 )
  857.             {
  858.                 y+=sy;
  859.                 d-=ax;
  860.             }
  861.             x+=sx;
  862.             d+=ay;
  863.         }
  864.     }
  865.     else
  866.     {
  867.         d=ax-(ay>>1);
  868.         while ( y!=y2 )
  869.         {
  870.             m_Bits[y*m_Size.cx+x]=Color;
  871.             if ( d>=0 )
  872.             {
  873.                 x+=sx;
  874.                 d-=ay;
  875.             }
  876.             y+=sy;
  877.             d+=ax;
  878.         }
  879.     }
  880. }
  882. void CDIB::LineGlass ( int x1, int y1, int x2, int y2, int R, int G, int B, int A )
  883. {
  884.     int d, x, y, ax, ay, sx, sy, dx, dy;
  885.     BYTE *dst=(BYTE *)m_Bits;
  886.     
  887.     dx=x2-x1;
  888.     ax=abs ( dx )<<1;
  889.     sx=(dx<0) ? -1 : 1;
  890.     dy=y2-y1;
  891.     ay=abs ( dy )<<1;
  892.     sy=(dy<0) ? -1 : 1;
  893.     x=x1;
  894.     y=y1;
  895.     
  896.     if ( ax>ay )
  897.     {
  898.         d=ay-(ax>>1);
  899.         while ( x!=x2 )
  900.         {
  901.             dst[(y*m_Size.cx+x)<<2]=(BYTE)(((B-dst[(y*m_Size.cx+x)<<2])*A+(dst[(y*m_Size.cx+x)<<2]<<8))>>8);
  902.             dst[((y*m_Size.cx+x)<<2)+1]=(BYTE)(((G-dst[((y*m_Size.cx+x)<<2)+1])*A+(dst[((y*m_Size.cx+x)<<2)+1]<<8))>>8);
  903.             dst[((y*m_Size.cx+x)<<2)+2]=(BYTE)(((R-dst[((y*m_Size.cx+x)<<2)+2])*A+(dst[((y*m_Size.cx+x)<<2)+2]<<8))>>8);
  904.             if ( d>=0 )
  905.             {
  906.                 y+=sy;
  907.                 d-=ax;
  908.             }
  909.             x+=sx;
  910.             d+=ay;
  911.         }
  912.     }
  913.     else
  914.     {
  915.         d=ax-(ay>>1);
  916.         while ( y!=y2 )
  917.         {
  918.             dst[(y*m_Size.cx+x)<<2]=(BYTE)(((B-dst[(y*m_Size.cx+x)<<2])*A+(dst[(y*m_Size.cx+x)<<2]<<8))>>8);
  919.             dst[((y*m_Size.cx+x)<<2)+1]=(BYTE)(((G-dst[((y*m_Size.cx+x)<<2)+1])*A+(dst[((y*m_Size.cx+x)<<2)+1]<<8))>>8);
  920.             dst[((y*m_Size.cx+x)<<2)+2]=(BYTE)(((R-dst[((y*m_Size.cx+x)<<2)+2])*A+(dst[((y*m_Size.cx+x)<<2)+2]<<8))>>8);
  921.             if ( d>=0 )
  922.             {
  923.                 x+=sx;
  924.                 d-=ay;
  925.             }
  926.             y+=sy;
  927.             d+=ax;
  928.         }
  929.     }
  930. }
  932. BOOL 
  933. CDIB::operator == (const CDIB &dib) const
  934. {
  935.     if (m_Size != dib.m_Size)
  936.         return FALSE;
  937.     if ((NULL == m_Bits) || (NULL == dib.m_Bits))
  938.         return FALSE;
  939.     if (0 != memcmp (&m_Info, &dib.m_Info, sizeof (BITMAPINFO)))
  940.         return FALSE;
  941.     if (0 != memcmp (m_Bits, dib.m_Bits, m_Info.bmiHeader.biSizeImage))
  942.         return FALSE;
  943.     return TRUE;
  944. }
  946. CDIB &
  947. CDIB::operator = (const CDIB &dib)
  948. {
  949.     CopyFrom (&dib); 
  950.     return *this;
  951. }
  953. DIBSaveResult 
  954. CDIB::SavePPM (CString cstrFileName, UINT uDescID)
  955. {
  956.     FILE *fp;
  958.     fp = fopen (cstrFileName,"wb");
  959.     if (NULL == fp)
  960.     {
  961.         return DIB_SAVE_CANT_WRITE;
  962.     }
  963.     fprintf (fp,"P6n");
  964.     CString cstrDesc;
  965.     if (uDescID && cstrDesc.LoadString(uDescID))
  966.     {   // Description string ID specified and loaded successfully
  967.         fprintf (fp,"# %sn", cstrDesc);
  968.     }
  969.     fprintf (fp, "%d %dn",
  970.              m_Size.cx,
  971.              m_Size.cy);
  972.     fprintf (fp,"255n");
  973.     for (int y=m_Size.cy - 1; y>=0; y--)
  974.         for (int x=0; x<m_Size.cx; x++)
  975.         {
  976.             COLORREF c = m_Bits[x + y * m_Size.cx];
  977.             if (3 != fprintf (fp, "%c%c%c", GetBValue(c), GetGValue(c), GetRValue(c)))
  978.             {
  979.                 fclose (fp);
  980.                 return DIB_SAVE_CANT_WRITE;
  981.             }
  982.         }
  983.     fclose (fp);
  984.     return DIB_SAVE_OK;
  985. }
  987. DIBSaveResult 
  988. CDIB::SaveBMP (CString cstrFileName)
  989. {
  990.     BITMAPFILEHEADER    hdr;
  992.     CFile file;
  993.     if( !file.Open( cstrFileName, CFile::modeWrite |CFile::modeCreate) )
  994.         return DIB_SAVE_CANT_WRITE;
  996.     // Fill in the fields of the file header 
  997.     hdr.bfType      = ((WORD) ('M' << 8) | 'B');    // is always "BM"
  998.     hdr.bfSize      = m_Info.bmiHeader.biSize + m_Info.bmiHeader.biSizeImage + sizeof( hdr );
  999.     hdr.bfReserved1 = 0;
  1000.     hdr.bfReserved2 = 0;
  1001.     hdr.bfOffBits   = (DWORD) (sizeof( hdr ) + m_Info.bmiHeader.biSize);
  1003.     // Write the file header 
  1004.     file.Write( &hdr, sizeof(hdr) );
  1005.     // Write BITMAPINFO header
  1006.     file.Write (&m_Info, m_Info.bmiHeader.biSize);
  1007.     // Write the DIB header and the bits 
  1008.     file.Write( m_Bits, m_Info.bmiHeader.biSizeImage );
  1010.     return DIB_SAVE_OK;
  1011. }
  1014. DIBLoadResult 
  1015. CDIB::LoadPPM (CString cstrFile)
  1016. {
  1017.     FILE *fp = NULL;
  1018.     int i,j;
  1019.     DIBLoadResult res = DIB_LOAD_OK;
  1020.     BOOL bPPM3;
  1022.     if ((cstrFile.GetLength() < int(strlen (PPM_EXT))) ||
  1023.         stricmp (PPM_EXT, cstrFile.Right(strlen(PPM_EXT))))
  1024.     {
  1025.         /* No extension, create one */
  1026.         cstrFile += PPM_EXT;
  1027.     }
  1029.     if ((fp = fopen (cstrFile,"rb"))==NULL)
  1030.     {
  1031.         res = DIB_LOAD_NOFILE_OR_CORRUPT;
  1032.         goto cleanup;
  1033.     }
  1035.     char tmp[1024];
  1036.     fgets (tmp,1024,fp); /* Get header */
  1037.     if (!strcmp (tmp,"P6n"))   /* Test header */
  1038.         bPPM3 = FALSE;  /* PPM6 - binary */
  1039.     else if (!strcmp (tmp,"P3n"))
  1040.         bPPM3 = TRUE;  /* PPM3 - ASCII */
  1041.     else
  1042.     {   /* Bad PPM header */
  1043.         res = DIB_LOAD_NOFILE_OR_CORRUPT;
  1044.         goto cleanup;
  1045.     }
  1046.     do    /* Read remarks (starting with '#' char) */
  1047.         fgets (tmp,1024,fp);
  1048.     while ('#' == tmp[0]); 
  1050.     int Width,Height;
  1052.     if (!strlen(tmp) || (2 != sscanf (tmp,"%d %d",&Width,&Height)))   /* Obtain width and height */
  1053.     {
  1054.         res = DIB_LOAD_NOFILE_OR_CORRUPT;
  1055.         goto cleanup;
  1056.     }
  1057.     fgets (tmp,1024,fp); 
  1059.     int MaxColor;
  1061.     if (!strlen(tmp) || (1 != sscanf (tmp,"%d",&MaxColor)))  /* Get max color used */
  1062.     {
  1063.         res = DIB_LOAD_NOFILE_OR_CORRUPT;
  1064.         goto cleanup;
  1065.     }
  1066.     if (!Create (Width, Height))
  1067.     {
  1068.         res = DIB_LOAD_NO_MEM;
  1069.         goto cleanup;
  1070.     }
  1071.     for (i=Height - 1; i >= 0; i--)      /* Read each row (reverse) */
  1072.         for (j=0; j < Width; j++)   /* Read each column */
  1073.             if (!bPPM3)
  1074.             {   // PPM 6
  1075.                 BYTE rgb[3];
  1077.                 if (fread (rgb, 3, 1, fp) != 1)
  1078.                 {   // Can't read pixel
  1079.                     res = DIB_LOAD_NOFILE_OR_CORRUPT;
  1080.                     goto cleanup;
  1081.                 }
  1082.                 else
  1083.                 {
  1084.                     ColorAt(j,i) = RGB(rgb[2],rgb[1],rgb[0]);
  1085.                 }
  1086.             }
  1087.             else
  1088.             {   // PPM 3
  1089.                 int r, g, b;
  1091.                 if (3 != fscanf(fp, "%d %d %d", &b, &g, &r))
  1092.                 {   // Can't read pixel
  1093.                     res = DIB_LOAD_NOFILE_OR_CORRUPT;
  1094.                     goto cleanup;
  1095.                 }
  1096.                 else
  1097.                 {
  1098.                     ColorAt(j,i) = RGB((BYTE)r, (BYTE)g, (BYTE)b);
  1099.                 }
  1100.             }
  1102. cleanup:
  1103.     if (NULL != fp)
  1104.     {
  1105.         fclose (fp);
  1106.     }
  1107.     return res;
  1108. }