home *** CD-ROM | disk | FTP | other *** search
/ Windows Graphics Programming / Feng_Yuan_Win32_GDI_DirectX.iso / Samples / include / Image.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2000-05-11  |  13.8 KB  |  565 lines
  1. //-----------------------------------------------------------------------------------//
  2. //              Windows Graphics Programming: Win32 GDI and DirectDraw               //
  3. //                             ISBN  0-13-086985-6                                   //
  4. //                                                                                   //
  5. //  Written            by  Yuan, Feng                             www.fengyuan.com   //
  6. //  Copyright (c) 2000 by  Hewlett-Packard Company                www.hp.com         //
  7. //  Published          by  Prentice Hall PTR, Prentice-Hall, Inc. www.phptr.com      //
  8. //                                                                                   //
  9. //  FileName   : image.cpp                                                                //
  10. //  Description: Generic Image Processing Classes                                    //
  11. //  Version    : 1.00.000, May 31, 2000                                              //
  12. //-----------------------------------------------------------------------------------//
  13.  
  14. #define STRICT
  15. #define WIN32_LEAN_AND_MEAN
  16.  
  17. #include <windows.h>
  18. #include <math.h>
  19. #include <tchar.h>
  20.  
  21. #include "DIB.h"
  22. #include "Image.h"
  23.  
  24. //////////////////////////////////////////////////
  25. //                                                //
  26. //           C O N V O L U T I O N                //
  27. //                                                //
  28. //////////////////////////////////////////////////
  29.  
  30. bool KImage::Convolution(KFilter * pFilter)
  31. {
  32.     BYTE * pDestBits = new BYTE[m_nImageSize];
  33.  
  34.     if ( pDestBits==NULL )
  35.         return false;
  36.  
  37.     for (int y=0; y<m_nHeight; y++)
  38.     {
  39.         unsigned char * pBuffer = (unsigned char *) m_pBits   + m_nBPS * y;
  40.         unsigned char * pDest   = (unsigned char *) pDestBits + m_nBPS * y;
  41.  
  42.         if (  (y>=pFilter->GetHalf()) && (y<(m_nHeight- pFilter->GetHalf())) )
  43.             switch ( m_nImageFormat )
  44.             {
  45.                 case DIB_8BPP:
  46.                     pFilter->Filter8bpp(pDest, pBuffer, m_nWidth, m_nBPS);
  47.                     break;
  48.  
  49.                 case DIB_24RGB888:    // 24-bpp RGB
  50.                     pFilter->Filter24bpp(pDest, pBuffer, m_nWidth, m_nBPS);
  51.                     break;
  52.  
  53.                 case DIB_32RGBA8888: // 32-bpp RGBA
  54.                 case DIB_32RGB888:   // 32-bpp RGB
  55.                     pFilter->Filter32bpp(pDest, pBuffer, m_nWidth, m_nBPS);
  56.                     break;
  57.  
  58.                 default:
  59.                     delete [] pDestBits;
  60.                     return false;
  61.             }
  62.         else
  63.             memcpy(pDest, pBuffer, m_nBPS); // copy unprocessed scanlines
  64.     }
  65.     
  66.     memcpy(m_pBits, pDestBits, m_nImageSize); // overwrite source pixel array
  67.     delete [] pDestBits;
  68.  
  69.     return true;
  70. }
  71.  
  72. //////////////////////////////////////////////////
  73. //                                                //
  74. //   P I X E L   T R A N S F O R M A T I O N    //
  75. //                                                //
  76. //////////////////////////////////////////////////
  77.  
  78. BITMAPINFO * KImage::SplitChannel(Operator oper)
  79. {
  80.     KChannel channel;
  81.  
  82.     return channel.Split(* this, oper);
  83. }
  84.  
  85.  
  86. bool KImage::PixelTransform(KPixelMapper & map)
  87. {
  88.     if ( m_pRGBTRIPLE )
  89.         map.SetColorTable((BYTE *) m_pRGBTRIPLE, sizeof(RGBTRIPLE), m_nClrUsed);
  90.     else if ( m_pRGBQUAD )
  91.         map.SetColorTable((BYTE *) m_pRGBQUAD, sizeof(RGBQUAD), m_nClrUsed);
  92.  
  93.     for (int y=0; y<m_nHeight; y++)
  94.     {
  95.         unsigned char * pBuffer = (unsigned char *) m_pBits + m_nBPS * y;
  96.     
  97.         if ( ! map.StartLine(y) )
  98.             break;
  99.  
  100.         switch ( m_nImageFormat )
  101.         {
  102.             case DIB_1BPP:
  103.                 map.Map1bpp(pBuffer, m_nWidth);
  104.                 break;
  105.  
  106.             case DIB_2BPP:
  107.                 map.Map2bpp(pBuffer, m_nWidth);
  108.                 break;
  109.  
  110.             case DIB_4BPP:
  111.                 map.Map4bpp(pBuffer, m_nWidth);
  112.                 break;
  113.  
  114.             case DIB_8BPP:
  115.                 map.Map8bpp(pBuffer, m_nWidth);
  116.                 break;
  117.  
  118.             case DIB_16RGB555:     // 15 bit RGB color image, 5-5-5, 1 bit unused
  119.                 map.Map555(pBuffer, m_nWidth);
  120.                 break;
  121.  
  122.             case DIB_16RGB565:    // 16 bit RGB color image, 5-6-5
  123.                 map.Map565(pBuffer, m_nWidth);
  124.                 break;
  125.  
  126.             case DIB_24RGB888:    // 24-bpp RGB
  127.                 map.Map24bpp(pBuffer, m_nWidth);
  128.                 break;
  129.  
  130.             case DIB_32RGBA8888: // 32-bpp RGBA
  131.             case DIB_32RGB888:   // 32-bpp RGB
  132.                 map.Map32bpp(pBuffer, m_nWidth);
  133.                 break;
  134.  
  135.             default:
  136.                 return false;
  137.         }
  138.     }
  139.     
  140.     return true;
  141. }
  142.  
  143. //////////////////////////////////////////////////
  144. //                                                //
  145. //   C O L O R   T R A N S F O R M A T I O N    //
  146. //                                                //
  147. //////////////////////////////////////////////////
  148.  
  149. template <class Dummy>
  150. bool ColorTransform(KDIB * dib, Dummy map)
  151. {
  152.     // support OS/2 DIB color table: 1-bpp, 4-bpp, 8-bpp, include RLE compression
  153.     if ( dib->m_pRGBTRIPLE )
  154.     {
  155.         for (int i=0; i<dib->m_nClrUsed; i++)
  156.             map(dib->m_pRGBTRIPLE[i].rgbtRed, dib->m_pRGBTRIPLE[i].rgbtGreen, dib->m_pRGBTRIPLE[i].rgbtBlue);
  157.  
  158.         return true;
  159.     }
  160.  
  161.     // support Windows DIB color table: 1-bpp, 2-bpp, 4-bpp, 8-bpp, include RLE compression
  162.     if ( dib->m_pRGBQUAD )
  163.     {
  164.         for (int i=0; i<dib->m_nClrUsed; i++)
  165.             map(dib->m_pRGBQUAD[i].rgbRed, dib->m_pRGBQUAD[i].rgbGreen, dib->m_pRGBQUAD[i].rgbBlue);
  166.  
  167.         return true;
  168.     }
  169.     
  170.     for (int y=0; y<dib->m_nHeight; y++)
  171.     {
  172.         int width = dib->m_nWidth;
  173.         unsigned char * pBuffer = (unsigned char *) dib->m_pBits + dib->m_nBPS * y;
  174.         
  175.         switch ( dib->m_nImageFormat )
  176.         {
  177.             case DIB_16RGB555:     // 15 bit RGB color image, 5-5-5, 1 bit unused
  178.                 for (; width>0; width--)
  179.                 {
  180.                     BYTE red   = ( (* (WORD *) pBuffer) & 0x7C00 ) >> 7;
  181.                     BYTE green = ( (* (WORD *) pBuffer) & 0x03E0 ) >> 2;
  182.                     BYTE blue  = ( (* (WORD *) pBuffer) & 0x001F ) << 3;
  183.                     
  184.                     map( red, green, blue );
  185.                     
  186.                     * ( WORD *) pBuffer = ( ( red >> 3 ) << 10 ) | ( ( green >> 3 ) << 5 ) | ( blue >> 3 );
  187.                     
  188.                     pBuffer += 2;
  189.                 }
  190.                 break;
  191.  
  192.             case DIB_16RGB565:    // 16 bit RGB color image, 5-6-5
  193.                 for (; width>0; width--)
  194.                 {
  195.                     const DWORD StandardMask565[] =  { 0x00F800, 0x0007E0, 0x00001F };
  196.  
  197.                     BYTE red   = ( (* (WORD *) pBuffer) & 0xF800 ) >> 8;
  198.                     BYTE green = ( (* (WORD *) pBuffer) & 0x07E0 ) >> 3;
  199.                     BYTE blue  = ( (* (WORD *) pBuffer) & 0x001F ) << 3;
  200.                     
  201.                     map( red, green, blue );
  202.                     
  203.                     * ( WORD *) pBuffer = ( ( red >> 3 ) << 11 ) | ( ( green >> 2 ) << 5 ) | ( blue >> 3 );
  204.                     
  205.                     pBuffer += 2;
  206.                 }
  207.                 break;
  208.  
  209.             case DIB_24RGB888:    // 24-bpp RGB
  210.                 for (; width>0; width--)
  211.                 {
  212.                     map( pBuffer[2], pBuffer[1], pBuffer[0] );
  213.                     pBuffer += 3;
  214.                 }
  215.                 break;
  216.  
  217.             case DIB_32RGBA8888: // 32-bpp RGBA
  218.             case DIB_32RGB888:   // 32-bpp RGB
  219.                 for (; width>0; width--)
  220.                 {
  221.                     map( pBuffer[2], pBuffer[1], pBuffer[0] );
  222.                     pBuffer += 4;
  223.                 }
  224.                 break;
  225.  
  226.             default:
  227.                 return false;
  228.         }
  229.     }
  230.     
  231.     return true;
  232. }
  233.  
  234.  
  235. bool KImage::ToGreyScale(void)
  236. {
  237.     return ColorTransform(this, MaptoGray);
  238. }
  239.  
  240.  
  241. BYTE   redGammaRamp[256];
  242. BYTE greenGammaRamp[256];
  243. BYTE  blueGammaRamp[256];
  244.  
  245. inline void MapGamma(BYTE & red, BYTE & green, BYTE & blue)
  246. {
  247.     red   =   redGammaRamp[red];
  248.     green = greenGammaRamp[green];
  249.     blue  =  blueGammaRamp[blue];
  250. }
  251.  
  252.  
  253. BYTE gamma(double g, int index)
  254. {
  255.     return min(255, (int) ( (255.0 * pow(index/255.0, 1.0/g)) + 0.5 ) ); 
  256. } 
  257.     
  258. bool KImage::GammaCorrect(double redgamma, double greengamma, double bluegamma)
  259. {
  260.     for (int i=0; i<256; i++)
  261.     {
  262.           redGammaRamp[i] = gamma(  redgamma, i);
  263.         greenGammaRamp[i] = gamma(greengamma, i);
  264.          blueGammaRamp[i] = gamma( bluegamma, i);
  265.     }
  266.  
  267.     return ColorTransform(this, MapGamma);
  268. }
  269.  
  270.  
  271. bool KImage::Lighten(void)
  272. {
  273.     return ColorTransform(this, LightenColor);
  274. }
  275.  
  276.  
  277. //////////////////////////////////////////////////////////////
  278.  
  279.  
  280. void KPixelMapper::Map1bpp(BYTE * pBuffer, int width)
  281. {
  282.     BYTE mask  = 0x80;
  283.     int  shift = 7;
  284.  
  285.     for (; width>0; width--)
  286.     {
  287.         BYTE index = ( ( pBuffer[0] & mask ) >> shift ) & 0x1;
  288.  
  289.         if ( MapIndex(index) )
  290.             pBuffer[0] =  ( pBuffer[0] & ~ mask ) || (( index & 0x0F) << shift);
  291.  
  292.         mask  >>= 1;
  293.         shift -= 1;
  294.  
  295.         if ( mask==0 )
  296.         {
  297.             pBuffer ++; mask = 0x80; shift = 7;
  298.         }
  299.     }
  300. }
  301.  
  302.  
  303. void KPixelMapper::Map2bpp(BYTE * pBuffer, int width)
  304. {
  305.     BYTE mask  = 0xC0;
  306.     int  shift = 6;
  307.  
  308.     for (; width>0; width--)
  309.     {
  310.         BYTE index = ( ( pBuffer[0] & mask ) >> shift ) & 0x3;
  311.  
  312.         if ( MapIndex(index) )
  313.             pBuffer[0] =  ( pBuffer[0] & ~ mask ) || (( index & 0x0F) << shift);
  314.  
  315.         mask  >>= 2;
  316.         shift -= 2;
  317.  
  318.         if ( mask==0 )
  319.         {
  320.             pBuffer ++; mask = 0xC0; shift = 6;
  321.         }
  322.     }
  323. }
  324.  
  325.  
  326. void KPixelMapper::Map4bpp(BYTE * pBuffer, int width)
  327. {
  328.     BYTE mask  = 0xF0;
  329.     int  shift = 4;
  330.  
  331.     for (; width>0; width--)
  332.     {
  333.         BYTE index = ( ( pBuffer[0] & mask ) >> shift ) & 0x0F;
  334.  
  335.         if ( MapIndex(index) )
  336.             pBuffer[0] =  ( pBuffer[0] & ~ mask ) || (( index & 0x0F) << shift);
  337.  
  338.         mask  = ~ mask;
  339.         shift = 4 - shift;
  340.  
  341.         if ( mask==0xF0 )
  342.             pBuffer ++;
  343.     }
  344. }
  345.  
  346.  
  347. void KPixelMapper:: Map8bpp(BYTE * pBuffer, int width)
  348. {
  349.     for (; width>0; width--)
  350.     {
  351.         MapIndex(pBuffer[0]);
  352.         pBuffer ++;
  353.     }
  354. }
  355.  
  356.  
  357. void KPixelMapper::Map555(BYTE * pBuffer, int width)
  358. {
  359.     for (; width>0; width--)
  360.     {
  361.         BYTE red   = ( (* (WORD *) pBuffer) & 0x7C00 ) >> 7;
  362.         BYTE green = ( (* (WORD *) pBuffer) & 0x03E0 ) >> 2;
  363.         BYTE blue  = ( (* (WORD *) pBuffer) & 0x001F ) << 3;
  364.                     
  365.         if ( MapRGB( red, green, blue ) )
  366.             * ( WORD *) pBuffer = ( ( red >> 3 ) << 10 ) | ( ( green >> 3 ) << 5 ) | ( blue >> 3 );
  367.                     
  368.         pBuffer += 2;
  369.     }
  370. }
  371.  
  372.  
  373. void KPixelMapper::Map565(BYTE * pBuffer, int width)
  374. {
  375.     for (; width>0; width--)
  376.     {
  377.         BYTE red   = ( (* (WORD *) pBuffer) & 0xF800 ) >> 8;
  378.         BYTE green = ( (* (WORD *) pBuffer) & 0x07E0 ) >> 3;
  379.         BYTE blue  = ( (* (WORD *) pBuffer) & 0x001F ) << 3;
  380.                     
  381.         if ( MapRGB( red, green, blue ) )
  382.             * ( WORD *) pBuffer = ( ( red >> 3 ) << 11 ) | ( ( green >> 2 ) << 5 ) | ( blue >> 3 );
  383.                     
  384.         pBuffer += 2;
  385.     }
  386. }
  387.  
  388.  
  389. void KPixelMapper::Map24bpp(BYTE * pBuffer, int width)
  390. {
  391.     for (; width>0; width--)
  392.     {
  393.         MapRGB( pBuffer[2], pBuffer[1], pBuffer[0] );
  394.         pBuffer += 3;
  395.     }
  396. }
  397.  
  398.  
  399. void KPixelMapper::Map32bpp(BYTE * pBuffer, int width)
  400. {
  401.     for (; width>0; width--)
  402.     {
  403.         MapRGB( pBuffer[2], pBuffer[1], pBuffer[0] );
  404.         pBuffer += 4;
  405.     }
  406. }
  407.  
  408.  
  409. BITMAPINFO * KChannel::Split(KImage & dib, Operator oper)
  410. {
  411.     m_Operator = oper;
  412.     m_nBPS     = (dib.GetWidth() + 3) / 4 * 4;    // scanline size for 8-bpp DIB
  413.     
  414.     int headsize = sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD);
  415.  
  416.     BITMAPINFO * pNewDIB = (BITMAPINFO *) new BYTE[headsize + m_nBPS * abs(dib.GetHeight())];
  417.  
  418.     memset(pNewDIB, 0, headsize);
  419.  
  420.     pNewDIB->bmiHeader.biSize         = sizeof(BITMAPINFOHEADER); 
  421.     pNewDIB->bmiHeader.biWidth         = dib.GetWidth(); 
  422.     pNewDIB->bmiHeader.biHeight         = dib.GetHeight(); 
  423.     pNewDIB->bmiHeader.biPlanes         = 1; 
  424.     pNewDIB->bmiHeader.biBitCount     = 8; 
  425.     pNewDIB->bmiHeader.biCompression = BI_RGB; 
  426.  
  427.     for (int c=0; c<256; c++)
  428.     {
  429.         pNewDIB->bmiColors[c].rgbRed   = c;
  430.         pNewDIB->bmiColors[c].rgbGreen = c;
  431.         pNewDIB->bmiColors[c].rgbBlue  = c;
  432.     }
  433.  
  434.     m_pBits  = (BYTE*) & pNewDIB->bmiColors[256];
  435.     
  436.     if ( pNewDIB==NULL )
  437.         return NULL;
  438.  
  439.     dib.PixelTransform(* this);
  440.  
  441.     return pNewDIB;
  442. }
  443.  
  444.  
  445. void KHistogram::Sample(KImage & dib)
  446. {
  447.     memset(m_FreqRed,   0, sizeof(m_FreqRed));
  448.     memset(m_FreqGreen, 0, sizeof(m_FreqGreen));
  449.     memset(m_FreqBlue,  0, sizeof(m_FreqBlue));
  450.     memset(m_FreqGray,  0, sizeof(m_FreqGray));
  451.     
  452.     dib.PixelTransform(* this);
  453. }
  454.  
  455.  
  456. void KFilter::Filter8bpp(BYTE * pDest, BYTE * pSource, int nWidth, int dy)
  457. {
  458.     memcpy(pDest, pSource, m_nHalf); 
  459.     pDest   += m_nHalf; 
  460.     pSource += m_nHalf;
  461.  
  462.     for (int i=nWidth - 2 * m_nHalf; i>0; i--)
  463.         * pDest ++ = Kernel(pSource++, 1, dy);
  464.         
  465.     memcpy(pDest, pSource, m_nHalf); 
  466. }
  467.  
  468.  
  469. void KFilter::Filter24bpp(BYTE * pDest, BYTE * pSource, int nWidth, int dy)
  470. {
  471.     memcpy(pDest, pSource, m_nHalf * 3);
  472.     pDest   += m_nHalf * 3;
  473.     pSource += m_nHalf * 3;
  474.  
  475.     for (int i=nWidth - 2 * m_nHalf; i>0; i--)
  476.     {
  477.         * pDest ++ = Kernel(pSource++, 3, dy);
  478.         * pDest ++ = Kernel(pSource++, 3, dy);
  479.         * pDest ++ = Kernel(pSource++, 3, dy);
  480.     }
  481.  
  482.     memcpy(pDest, pSource, m_nHalf * 3);
  483. }
  484.  
  485.  
  486. void KFilter::Filter32bpp(BYTE * pDest, BYTE * pSource, int nWidth, int dy)
  487. {
  488.     memcpy(pDest, pSource, m_nHalf * 4);
  489.     pDest   += m_nHalf * 4;
  490.     pSource += m_nHalf * 4;
  491.  
  492.     for (int i=nWidth - 2 * m_nHalf; i>0; i--)
  493.     {
  494.         * pDest ++ = Kernel(pSource++, 4, dy);
  495.         * pDest ++ = Kernel(pSource++, 4, dy);
  496.         * pDest ++ = Kernel(pSource++, 4, dy);
  497.         * pDest ++ = * pSource++;                // copy alpha channel
  498.     }
  499.  
  500.     memcpy(pDest, pSource, m_nHalf * 4);
  501. }
  502.  
  503.  
  504. void Describe33Filter(HDC hDC, int x, int y, const int * matrix, TCHAR * name, int weight, int add)
  505. {
  506.     SelectObject(hDC, GetStockObject(SYSTEM_FIXED_FONT));
  507.  
  508.     TextOut(hDC, x, y, name, _tcslen(name)); 
  509.  
  510.     if ( matrix )
  511.     {
  512.         y+=20;
  513.  
  514.         TCHAR number[32];
  515.  
  516.         for (int i=0; i<3; i++)
  517.         {
  518.             wsprintf(number, _T("%c |%2d %2d %2d|"), 
  519.                 (i==1) ? '*' : ' ',
  520.                 matrix[i*3], matrix[i*3+1], matrix[i*3+2]);
  521.             TextOut(hDC, x + 5, y + i * 15, number, _tcslen(number));
  522.         }
  523.  
  524.         if ( add )
  525.             wsprintf(number, _T("/ %d + %d"), weight, add);
  526.         else
  527.             wsprintf(number, _T("/ %d"), weight);
  528.     
  529.         TextOut(hDC, x+5, y + 50, number, _tcslen(number));
  530.     }
  531. }
  532.     
  533.  
  534. TCHAR szSmooth[]        = _T("Smooth");
  535. TCHAR szGuasianSmooth[] = _T("Guasian Smooth");
  536. TCHAR szSharpening[]    = _T("Sharpening");
  537. TCHAR szLaplasian[]     = _T("Laplasian");
  538. TCHAR szEmboss135[]     = _T("Emboss 135░");
  539. TCHAR szEmboss90[]      = _T("Emboss 90░ 50%");
  540.  
  541. K33Filter< 1,  1,  1,  1,  1,  1,  1,  1,  1, 9,   0, false, szSmooth        > filter33_smooth;
  542. K33Filter< 0,  1,  0,  1,  4,  1,  0,  1,  0, 8,   0, false, szGuasianSmooth > filter33_guasiansmooth;
  543. K33Filter< 0, -1,  0, -1,  9, -1,  0, -1,  0, 5,   0, true,  szSharpening    > filter33_sharpening;
  544. K33Filter<-1, -1, -1, -1,  8, -1, -1, -1, -1, 1, 128, true,  szLaplasian     > filter33_laplasian;
  545. K33Filter< 1,  0,  0,  0,  0,  0,  0,  0, -1, 1, 128, true,  szEmboss135     > filter33_emboss135;
  546. K33Filter< 0,  1,  0,  0,  0,  0,  0, -1,  0, 2, 128, true,  szEmboss90      > filter33_emboss90;
  547.  
  548. KDilation filter_dilation;
  549. KErosion  filter_erosion;
  550. KOutline  filter_outline;
  551.  
  552. KFilter * StockFilters[] = {
  553.     NULL,
  554.     & filter33_smooth,
  555.     & filter33_guasiansmooth,
  556.     & filter33_sharpening,
  557.     & filter33_laplasian,
  558.     & filter33_emboss135,
  559.     & filter33_emboss90,
  560.     & filter_dilation,
  561.     & filter_erosion,
  562.     & filter_outline
  563. };
  564.  
  565.