TnbBitmapImage.h

[詳解]

#pragma once
#include "TnbBitmapHandle.h"
#ifndef _WIN32_WCE
 #pragma comment(lib, "Msimg32.lib")
#endif
#ifndef _TnbDOXYGEN //Document作成用シンボル
 #ifndef AC_SRC_ALPHA
  #define AC_SRC_ALPHA                0x01
 #endif
#endif
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CBitmapImage
{
public:
 
    class CRawData
    {
        struct TParam
        {
            SIZE                size;           
            CWorkMemT<RGBQUAD>  work;           
            TParam(const SIZE& s) : size(s), work(s.cx * s.cy)
            {
            }
            TParam(void)
            {
                size.cx = size.cy = 0;
            }
        };
        CPointerHandleT<TParam> m_pParam;       
    public:
        CRawData(void) : m_pParam(new TParam()) { }
        CRawData(const SIZE& s) : m_pParam(new TParam(s)) { }
        bool IsValid(void) const { return m_pParam->size.cx != 0; }
        const SIZE& GetSize(void) const { return m_pParam->size; }
        size_t GetLineBytes(void) const { return m_pParam->size.cx * sizeof(RGBQUAD); }
        RGBQUAD* Refer(void) { return m_pParam->work; }
        const RGBQUAD* Refer(void) const { return m_pParam->work; }
        RGBQUAD* operator[](INDEX y)
        {
            if ( y >= static_cast<UINT>(m_pParam->size.cy) ) { return NULL; }
            return Refer() + (m_pParam->size.cy - y - 1) * m_pParam->size.cx;
        }
        const RGBQUAD* operator[](INDEX y) const
        {
            if ( y >= static_cast<UINT>(m_pParam->size.cy) ) { return NULL; }
            return Refer() + (m_pParam->size.cy - y - 1) * m_pParam->size.cx;
        }
    };
 
    CBitmapImage(void) : m_bmp(), m_pRgb(NULL), m_backDC(NULL), m_backBmp(NULL)
        , m_hWnd(NULL), m_nStretchMode(DEFAULT_STRETCHMODE)
    {
        m_size.cx = 0;
        m_size.cy = 0;
    }
 
    CBitmapImage(CBitmapHandle bmp) : m_bmp(), m_pRgb(NULL), m_backDC(NULL), m_backBmp(NULL)
        , m_hWnd(NULL), m_nStretchMode(DEFAULT_STRETCHMODE)
    {
        m_Set(bmp);
    }
    
    CBitmapImage(const CBitmapImage& other) : m_bmp(other.m_bmp), m_pRgb(other.m_pRgb), m_backDC(NULL), m_backBmp(NULL)
        , m_hWnd(other.m_hWnd), m_size(other.m_size), m_nStretchMode(other.m_nStretchMode)
    {
    }
 
    CBitmapImage& operator=(const CBitmapImage& other)
    {
        m_ReleaseDC();
        m_bmp = other.m_bmp;
        m_pRgb = other.m_pRgb;
        m_size = other.m_size;
        m_hWnd = other.m_hWnd;
        m_nStretchMode = other.m_nStretchMode;
        return *this;
    }
 
    virtual ~CBitmapImage(void)
    {
        Empty();
    }
 
    operator CBitmapHandle(void)
    {
        return m_bmp;
    }
 
    CBitmapHandle GetBitmapHandle(void)
    {
        return m_bmp;
    }
 
    void SetWorkWnd(HWND h)
    {
        m_hWnd = h;
    }
 
    void SetStretchBltMode(int nStretchMode)
    {
        m_nStretchMode = nStretchMode;
        if ( m_backDC != NULL )
        {
            ::SetStretchBltMode(m_backDC, m_nStretchMode);
            ::SetBrushOrgEx(m_backDC, 0, 0, NULL);
        }
    }
 
    void Empty(void)
    {
        m_ReleaseDC();
        m_bmp.Null();
        m_pRgb = NULL;
    }
 
    bool IsEmpty(void) const
    {
        return m_bmp.IsNull();
    }
 
    const SIZE& GetSize(void) const
    {
        ASSERT0( ! IsEmpty(), "CBitmapImage::GetSize()", "画像を持っていないオブジェクトからサイズを取得しようとしています。" );
        return m_size;
    }
 
    bool GetBitmapInfo(BITMAPINFOHEADER& _head) const
    {
        BITMAP bp;
        if ( ::GetObject(m_bmp, sizeof(BITMAP), &bp) > 0 )
        {
            ::ZeroMemory(&_head, sizeof(BITMAPINFOHEADER));
            _head.biSize        = sizeof(BITMAPINFOHEADER);
            _head.biWidth       = bp.bmWidth;
            _head.biHeight      = bp.bmHeight;
            _head.biPlanes      = bp.bmPlanes;
            _head.biBitCount    = bp.bmBitsPixel;
            _head.biCompression = BI_RGB;
            _head.biSizeImage   = bp.bmWidthBytes * bp.bmHeight;
            return true;
        }
        return false;
    }
 
    CBitmapImage Clone(void) const
    {
        CBitmapImage bi;
        bi.Set(m_bmp);
        return bi;
    }
 
    bool Attach(CBitmapHandle bmp)
    {
        return m_Set(bmp);
    }
 
    CBitmapHandle Detach(void)
    {
        CBitmapHandle h = m_bmp;
        Empty();
        return h;
    }
 
    bool Set(int cx, int cy, COLORREF color = CLR_INVALID)
    {
        CWorkDC workDC(m_hWnd);
        RGBQUAD* pRgb = NULL;
        HBITMAP h = ms_CreateBitmap(pRgb, workDC, cx, cy);
        if ( h != NULL && m_Set(h, pRgb) )
        {
            ASSERT( m_pRgb != NULL );
            if ( Fill(color) ) 
            {
                return true;
            }
        }
        Empty();
        return false;
    }
 
    bool SetEx(HDC hDC, int cx, int cy, COLORREF color = CLR_INVALID)
    {
        HBITMAP h = ::CreateCompatibleBitmap(hDC, cx, cy);
        bool r = ( h != NULL && m_Set(h) );
        if ( r )
        {
            r = Fill(color); 
        }
        return r;
    }
 
    bool Set(CBitmapHandle bmp)
    {
        RGBQUAD* pRgb = NULL;
        return m_Set(CBitmapHandle::Create32bitDibSection(bmp, pRgb), pRgb);
    }
 
    bool Set(const CBitmapImage& bmpimg, int cx = 0, int cy = 0)
    {
        if ( cx == 0 && cy == 0 ) 
        {
            return Set(bmpimg.m_bmp); 
        }
        bmpimg.m_CheckSize(cx, cy);
        if ( Set(cx, cy) )
        {
            HDC dc = GetDC();
            if ( dc != NULL )
            {
                bool r = bmpimg.StretchBlt(dc, 0, 0, SRCCOPY, cx, cy);
                ReleaseDC();
                return r; 
            }
        }
        Empty();
        return false;
    }
 
    bool _deprecated Set(const CRawData& rawData)
    {
        Empty();
        if ( rawData.IsValid() )
        {
            const SIZE& size = rawData.GetSize();
            if ( Set(size.cx, size.cy) )
            {
                ASSERT( m_pRgb != NULL );
                MemCopy(m_pRgb, rawData.Refer(), m_size.cy * m_size.cx);
            }
        }
        return ! m_bmp.IsNull();
    }
 
    bool SetFromDC(HDC hdc, const RECT& rect, int cx = 0, int cy = 0) 
    {
        Empty();
        SIZE s;
        if ( ms_CheckSize(s, rect) && Set(s.cx, s.cy) )
        {
            HDC dc = GetDC();
            if ( dc != NULL )
            {
                if ( cx <= 0 || cy <= 0 )
                {
                    ::BitBlt(dc, 0, 0, s.cx, s.cy, hdc, rect.left, rect.top, SRCCOPY);  //DCから取り出し
                }
                else
                {
                    ::StretchBlt(dc, 0, 0, cx, cy, hdc, rect.left, rect.top, s.cx, s.cy, SRCCOPY);  //DCから取り出し
                }
                ReleaseDC();
                return true;
            }
        }
        Empty();
        return false;
    }
 
    bool SetFromIcon(HICON hIcon, COLORREF backColor)
    {
        Empty();
        ICONINFO ii;
        ::GetIconInfo(hIcon, &ii);
        CBitmapImage biColor;
        CBitmapImage biMask;
        if ( ! biColor.Set(ii.hbmColor) || ! biMask.Set(ii.hbmMask) )
        {
            return false;
        }
        const SIZE& size = biColor.GetSize();
        bool r = Set(size.cx, size.cy, backColor);
        r &= Insert(0, 0, biMask, SRCAND);
        r &= Insert(0, 0, biColor, SRCPAINT);
        if ( ! r ) 
        { 
            Empty();
        }
        return r;
    }
 
    bool SetFromClient(HWND hWnd, const RECT& rect, COLORREF backColor = CLR_INVALID)
    {
        if ( Set(rect.right - rect.left, rect.bottom - rect.top, backColor) )
        {
#ifndef _WIN32_WCE
            HDC dc = GetDC();
            if ( dc != NULL )
            {
                ::SetWindowOrgEx(dc, rect.left, rect.top, NULL);
                WPARAM w = reinterpret_cast<WPARAM>(dc);
                if ( backColor == CLR_AUTOSELECT )
                {
                    ::SendMessage(hWnd, WM_ERASEBKGND, w, 0);
                }
                ::SendMessage(hWnd, WM_PRINTCLIENT, w, PRF_CLIENT);
                ReleaseDC();
                return true;
            }
#else
            return true;
#endif
        }
        Empty();
        return false;
    }
 
    bool SetFromClient(HWND hWnd, COLORREF backColor = CLR_INVALID)
    {
        RECT rect;
        if ( ::GetClientRect(hWnd, &rect) )
        {
            return SetFromClient(hWnd, rect, backColor);
        }
        Empty();
        return false;
    }
 
    #ifndef _WIN32_WCE
    bool SetFromWindow(HWND hWnd, COLORREF backColor = CLR_INVALID,
                        LPARAM mode = PRF_CLIENT | PRF_ERASEBKGND | PRF_NONCLIENT | PRF_OWNED)
    {
        RECT rect;
        if ( ::GetWindowRect(hWnd, &rect) && Set(rect.right - rect.left, rect.bottom - rect.top, backColor) )
        {
            HDC dc = GetDC();
            if ( dc != NULL )
            {
                ::SendMessage(hWnd, WM_PRINT, reinterpret_cast<WPARAM>(dc), mode);
                ReleaseDC();
                return true;
            }
        }
        Empty();
        return false;
    }
 
    bool InsertEx(int x, int y, HBITMAP hBitmap, UINT uExFlag = DSS_NORMAL)
    {
        HDC dc = GetDC();
        if ( dc != NULL ) 
        {
            LPARAM l = reinterpret_cast<LPARAM>(hBitmap);
            bool r = !! ::DrawState(dc, NULL, NULL, l, 0, x, y, 0, 0, DST_BITMAP | uExFlag);
            ReleaseDC();
            return r;
        }
        return false; 
    }
    #endif
 
    bool Insert(int x, int y, const CBitmapImage& bmpimg, DWORD raster = SRCCOPY, int cx = 0, int cy = 0)
    {
        if ( ! IsEmpty() && ! bmpimg.IsEmpty() )
        {
            HDC dc = GetDC();
            if ( dc != NULL ) 
            {
                bool r = bmpimg.StretchBlt(dc, x, y, raster, cx, cy);
                ReleaseDC();
                return r;
            }
        }
        return false;
    }
 
    bool InsertOnTransparent(int x, int y, const CBitmapImage& bmpimg, COLORREF color = CLR_AUTOSELECT, int cx = 0, int cy = 0)
    {
        if ( ! IsEmpty() && ! bmpimg.IsEmpty() )
        {
            HDC dc = GetDC();
            if ( dc != NULL )
            {
                bool r = bmpimg.TransparentBit(dc, x, y, color, cx, cy);
                ReleaseDC();
                return r;
            }
        }
        return false;
    }
 
    bool InsertOnAlphaBlend(int x, int y, const CBitmapImage& bmpimg, int parsent = 100, int cx = 0, int cy = 0)
    {
        if ( ! IsEmpty() && ! bmpimg.IsEmpty() )
        {
            HDC dc = GetDC();
            if ( dc != NULL )
            {
                bool r = bmpimg.AlphaBlend(dc, x, y, parsent, cx, cy);
                ReleaseDC();
                return r;
            }
        }
        return false;
    }
 
    bool InsertOnSemitransparect(int x, int y, const CBitmapImage& bmpimg, int parsent = 100, COLORREF color = CLR_AUTOSELECT)
    {
        if ( ! IsEmpty() && ! bmpimg.IsEmpty() )
        {
            HDC dc = GetDC();
            if ( dc != NULL )
            {
                bool r = bmpimg.SemitransparectBlt(dc, x, y, parsent, color);
                ReleaseDC();
                return r;
            }
        }
        return false;
    }
 
    bool Fill(COLORREF color, const RECT& rect)
    {
        HDC dc = GetDC();
        if ( dc != NULL )
        {
            COLORREF c = ::GetBkColor(dc);
            ::SetBkColor(dc, color);
            bool r = !! ::ExtTextOut(dc, 0, 0, ETO_OPAQUE, &rect, NULL, 0, NULL);
            ::SetBkColor(dc, c);
            ReleaseDC();
            return r;
        }
        return false;
    }
 
    bool Fill(COLORREF color)
    {
        RECT rect = { 0, 0, m_size.cx, m_size.cy };
        return Fill(color, rect);
    }
 
    enum EDirection
    {
        Vertical,       
        Horizontal      
    };
 
    bool GradationFill(COLORREF color1, COLORREF color2, EDirection direction, const RECT* pRect = NULL)
    {
        HDC dc = GetDC();
        if ( dc != NULL )
        {
            SIZE size = m_size;
            if ( pRect != NULL )
            {
                size.cx = pRect->right - pRect->left;
                size.cy = pRect->bottom - pRect->top;
            }
            int c = 0;
            if ( direction == Horizontal )
            {
                c = size.cx;
                size.cy = 1;
            }
            else
            {
                c = size.cy;
                size.cx = 1;
            }
            if ( size.cx > 0 && size.cy > 0 )
            {
                CBitmapImage bi;
                bi.Set(size.cx, size.cy);
                ASSERT( bi.m_pRgb != NULL );
                int r1 = GetRValue(color1);
                int g1 = LOBYTE((color1 >> 8) & 0xFF);
                int b1 = GetBValue(color1);
                int r2 = GetRValue(color2);
                int g2 = LOBYTE((color2 >> 8) & 0xFF);
                int b2 = GetBValue(color2);
                int a = c - 1;
                if ( a <= 0 ) { a = 1; }
                loop ( i, c )
                {
                    bi.m_pRgb[i].rgbRed = static_cast<BYTE>((r1 * (a - i) / a) + (r2 * i / a));
                    bi.m_pRgb[i].rgbGreen = static_cast<BYTE>((g1 * (a - i) / a) + (g2 * i / a));
                    bi.m_pRgb[i].rgbBlue = static_cast<BYTE>((b1 * (a - i) / a) + (b2 * i / a));
                }
                bool r = false;
                if ( pRect != NULL )
                {
                    ::SetBrushOrgEx(dc, pRect->left, pRect->top, NULL);
                    r = bi.DrawTile(dc, *pRect);
                    ::SetBrushOrgEx(dc, 0, 0, NULL);
                }
                else
                {
                    RECT rect = { 0, 0, m_size.cx, m_size.cy };
                    r = bi.DrawTile(dc, rect);
                }
                ReleaseDC();
                return r;
            }
        }
        return false;
    }
 
    bool GradationFill(COLORREF color1, COLORREF color2, bool boIsHorizontal, const RECT* pRect = NULL)
    {
        EDirection d = boIsHorizontal ? Horizontal : Vertical;
        return GradationFill(color1, color2, d, pRect);
    }
 
    bool GradientFill(const PTRIVERTEX pVertex, DWORD dwNumVertex, const PGRADIENT_RECT pMesh, DWORD dwNumMesh, bool boIsHorizontal)
    {
        HDC dc = GetDC();
        if ( dc != NULL )
        {
            DWORD dwMode = boIsHorizontal ? GRADIENT_FILL_RECT_H : GRADIENT_FILL_RECT_V;
            bool r = !! ::GradientFill(dc, pVertex, dwNumVertex, pMesh, dwNumMesh, dwMode);
            ReleaseDC();
            return r;
        }
        return false;
    }
 
    bool CustomizeAlpha(BYTE alpha)
    {
        if ( m_CheckDib() )
        {
            loop ( i, m_size.cx * m_size.cy )
            {
                m_pRgb[i].rgbReserved = alpha;
            }
            return true;
        }
        return false;
    }
 
    bool CustomizeAlpha(BYTE alpha, COLORREF colorEx, BYTE alphaEx)
    {
        if ( m_CheckDib() )
        {
            colorEx = (colorEx & 0x0000ff00) | (colorEx & 0x00ff0000) >> 16 | (colorEx & 0x000000ff) << 16;
            RGBQUAD* pRgba = m_pRgb;
            loop ( i, m_size.cx * m_size.cy )
            {
                if ( (*(reinterpret_cast<COLORREF*>(pRgba)) & 0x00FFFFFF) == colorEx )
                {
                    pRgba->rgbReserved = alphaEx;
                }
                else
                {
                    pRgba->rgbReserved = alpha;
                }
                pRgba++;
            }
            return true;
        }
        return false;
    }
 
    bool CustomizeAlpha(CBitmapHandle bmp)
    {
        CBitmapImage bi;
        if ( ! bi.Set(bmp) )
        {
            return false;
        }
        if ( ! m_CheckDib() || ! bi.m_CheckDib() )
        {
            return false; 
        }
        if ( bi.m_size.cx < m_size.cx || bi.m_size.cy < m_size.cy )
        {
            return false; 
        }
        loop ( y, m_size.cy )
        {
            RGBQUAD* pSrc = bi.GetRgbDataPtr(y);
            RGBQUAD* pBase = GetRgbDataPtr(y);
            loop ( x, m_size.cx )
            {
                pBase->rgbReserved = pSrc->rgbRed;
                pSrc++;
                pBase++;
            }
        }
        return true;
    }
 
    int ChangePixelColor(COLORREF targetColor, COLORREF drawColor)
    {
        if ( m_CheckDib() )
        {
            int rc = 0;
            targetColor = (targetColor & 0x0000ff00) | (targetColor & 0x00ff0000) >> 16 | (targetColor & 0x000000ff) << 16;
            drawColor = (drawColor & 0x0000ff00) | (drawColor & 0x00ff0000) >> 16 | (drawColor & 0x000000ff) << 16;
            COLORREF* pRgba = reinterpret_cast<COLORREF*>(m_pRgb);
            loop ( i, m_size.cx * m_size.cy )
            {
                if ( ((*pRgba) & 0x00FFFFFF) == targetColor )
                {
                    *pRgba = drawColor;
                    rc++;
                }
                pRgba++;
            }
            return rc;
        }
        return -1;
    }
 
    bool ChangePixelColor(COLORREF r, COLORREF g, COLORREF b)
    {
        struct TRGB
        {
            BYTE rgbRed;
            BYTE rgbGreen;
            BYTE rgbBlue;
            BYTE rgbReserved;
        };
        if ( m_CheckDib() )
        {
            TRGB* R = reinterpret_cast<TRGB*>(&r);
            TRGB* G = reinterpret_cast<TRGB*>(&g);
            TRGB* B = reinterpret_cast<TRGB*>(&b);
            RGBQUAD* P = m_pRgb;
            loop ( i, m_size.cx * m_size.cy )
            {
                int rr = P->rgbRed * R->rgbRed + P->rgbGreen * R->rgbGreen + P->rgbBlue * R->rgbBlue;
                int gg = P->rgbRed * G->rgbRed + P->rgbGreen * G->rgbGreen + P->rgbBlue * G->rgbBlue;
                int bb = P->rgbRed * B->rgbRed + P->rgbGreen * B->rgbGreen + P->rgbBlue * B->rgbBlue;
                P->rgbRed = static_cast<BYTE>(min(rr / 255, 255));
                P->rgbGreen = static_cast<BYTE>(min(gg / 255, 255));
                P->rgbBlue = static_cast<BYTE>(min(bb / 255, 255));
                P++;
            }
            return true;
        }
        return false;
    }
 
    CBitmapImage Cut(const RECT& rect, int cx = 0, int cy = 0) const
    {
        CBitmapImage bi;
        SIZE s;
        if ( ms_CheckSize(s, rect) )
        {
            ms_CheckSize(cx, cy, s);
            CWorkDC workDC(m_hWnd);
            CTempDC dc(workDC, m_bmp);
            bi.Set(cx, cy);
            HDC tempDc = bi.GetDC();
            if ( tempDc != NULL )
            {
                bool r = !! ::StretchBlt(tempDc, 0, 0, cx, cy, dc, rect.left, rect.top, s.cx, s.cy, SRCCOPY);
                bi.ReleaseDC();
                if ( ! r )
                {
                    bi.Empty();
                }
            }
            else
            {
                bi.Empty();
            }
        }
        return bi;
    }
 
    HDC GetDC(void)
    {
        if ( ! IsEmpty() && m_backDC == NULL )
        {
            CWorkDC workDC(m_hWnd);
            m_backDC = ::CreateCompatibleDC(workDC);
            m_backBmp = ::SelectObject(m_backDC, m_bmp);
            ::SetStretchBltMode(m_backDC, m_nStretchMode);
            ::SetBrushOrgEx(m_backDC, 0, 0, NULL);
            return m_backDC;
        }
        return NULL;
    }
 
    bool ReleaseDC(void)
    {
        if ( m_backDC != NULL )
        {
            m_ReleaseDC();
            return true;
        }
        return false;
    }
 
    HBITMAP CreateMaskBitmap(bool boIsReverse = false, COLORREF transColor = CLR_AUTOSELECT) const
    {
        HRGN rgn = CreateRgn(transColor);
        if ( rgn != NULL ) 
        {
            HBITMAP hMonoBitmap = ::CreateBitmap(m_size.cx, m_size.cy, 1, 1, NULL);
            CTempBitmapDC hdc(m_hWnd, hMonoBitmap);
            RGBQUAD aColors[2] = { {0, 0, 0, 0}, {255, 255, 255, 0} };
            ::SetDIBColorTable(hdc, 0, 2, aColors);
            RECT rect = { 0, 0, m_size.cx, m_size.cy };
            if ( ! boIsReverse )
            {
                ::FillRect(hdc, &rect, static_cast<HBRUSH>(::GetStockObject(WHITE_BRUSH)));
                ::FillRgn(hdc, rgn, static_cast<HBRUSH>(::GetStockObject(BLACK_BRUSH)));
            }
            else
            {
                ::FillRect(hdc, &rect, static_cast<HBRUSH>(::GetStockObject(BLACK_BRUSH)));
                ::FillRgn(hdc, rgn, static_cast<HBRUSH>(::GetStockObject(WHITE_BRUSH)));
            }
            _DeleteObject(rgn);
            return hMonoBitmap;
        }
        return NULL;
    }
 
    CRawData _deprecated CreateRawData(void) const
    {
        if ( ! IsEmpty() && m_backDC == NULL )
        {
            if ( m_pRgb == NULL )
            {
                RGBQUAD* pRgb = NULL;
                CBitmapHandle b = CBitmapHandle::Create32bitDibSection(m_bmp, pRgb);
                if ( pRgb != NULL )
                {
                    CRawData data(m_size);
                    MemCopy(data.Refer(), pRgb, m_size.cx * m_size.cy);
                    return data;
                }
            }
            else
            {
                CRawData data(m_size);
                MemCopy(data.Refer(), m_pRgb, m_size.cx * m_size.cy);
                return data;
            }
        }
        return CRawData();
    }
 
    HRGN CreateRgn(COLORREF transColor = CLR_AUTOSELECT) const
    {
        if ( transColor == CLR_INVALID )
        {
            return ::CreateRectRgn(0, 0, m_size.cx, m_size.cy);
        }
        CBitmapImage bi(*this);
        if ( ! bi.m_CheckDib() )
        {
            return NULL; 
        }
        HRGN hRgn = NULL;   // リージョンハンドル
        transColor = (transColor & 0xff00ff00) |
                    (transColor & 0x00ff0000) >> 16 |
                    (transColor & 0x000000ff) << 16;
        //
        CWorkMem rgbWork(sizeof(RGNDATAHEADER) + sizeof(RECT) * bi.m_size.cx * bi.m_size.cy);
        LPRGNDATA pRgnData = reinterpret_cast<LPRGNDATA>(rgbWork.Ref());
        LPRECT pRect = reinterpret_cast<LPRECT>(pRgnData->Buffer);
        int nCntRect = 0;   // 四角形リージョンの数
        loop_dn ( y, bi.m_size.cy )
        {
            const COLORREF* pScanData = reinterpret_cast<const COLORREF*>(bi.GetRgbDataPtr(y));
            if ( transColor == CLR_AUTOSELECT )
            {
                transColor = pScanData[0];
            }
            // 一行分の透明／非透明の変化点を調査する
            loop ( x, bi.m_size.cx )
            {
                if ( pScanData[x] == transColor )
                {
                    continue;
                }
                // その位置から透明までの長さをカウントする
                pRect->left = down_cast<long>(x);
                for ( ; x < static_cast<size_t>(bi.m_size.cx); x++ )
                {
                    if ( pScanData[x] == transColor ) { break; }
                }
                // その情報を四角形情報として追加する
                pRect->right    = static_cast<LONG>(x);
                pRect->top      = static_cast<LONG>(y);
                pRect->bottom   = static_cast<LONG>(y + 1);
                pRect++;
                nCntRect++;
            }
        }
        // 書きためた四角形情報を元にリージョンを作成する
        pRgnData->rdh.dwSize            = sizeof(RGNDATAHEADER);
        pRgnData->rdh.iType             = RDH_RECTANGLES;
        pRgnData->rdh.nRgnSize          = sizeof(RGNDATAHEADER) + sizeof(RECT) * nCntRect;
        pRgnData->rdh.nCount            = nCntRect;
        pRgnData->rdh.rcBound.top       = 0;
        pRgnData->rdh.rcBound.left      = 0;
        pRgnData->rdh.rcBound.bottom    = bi.m_size.cy;
        pRgnData->rdh.rcBound.right     = bi.m_size.cx;
        hRgn = ::ExtCreateRegion(NULL, pRgnData->rdh.nRgnSize, pRgnData);
        if ( hRgn == NULL )
        {
            _GetLastError("ExtCreateRegion");
        }
        return hRgn;
    }
 
    bool Draw(HDC hdc, int x = 0, int y = 0) const
    {
        HBITMAP h = m_bmp;
        return CBitmapHandle::Draw(hdc, h, x, y);
    }
 
    bool Draw(HDC hdc, const POINT& po) const
    {
        return Draw(hdc, po.x, po.y);
    }
 
    bool DrawTile(HDC hdc, const RECT& rect) const
    {
        if ( ! IsEmpty() )
        {
            HBRUSH brush = ::CreatePatternBrush(m_bmp);
            bool r = !! ::FillRect(hdc, &rect, brush);
            _DeleteObject(brush);
            return r;
        }
        return false;
    }
 
    bool BitBlt(HDC hdc, int x, int y, DWORD raster = SRCCOPY) const
    {
        if ( ! IsEmpty() )
        {
            CTempBitmapDC dc(m_hWnd, m_bmp);
            return !! ::BitBlt(hdc, x, y, m_size.cx, m_size.cy, dc, 0, 0, raster);
        }
        return false;
    }
 
    bool StretchBlt(HDC hdc, int x, int y, DWORD raster = SRCCOPY, int cx = 0, int cy = 0) const
    {
        if ( ! IsEmpty() )
        {
            m_CheckSize(cx, cy);
            CTempBitmapDC dc(m_hWnd, m_bmp);
            return !! ::StretchBlt(hdc, x, y, cx, cy, dc, 0, 0, m_size.cx, m_size.cy, raster);
        }
        return false;
    }
 
    bool TransparentBit(HDC hdc, int x, int y, COLORREF color = CLR_AUTOSELECT, int cx = 0, int cy = 0) const
    {
        if ( ! IsEmpty() )
        {
            m_CheckSize(cx, cy);
            CTempBitmapDC dc(m_hWnd, m_bmp);
            color = m_CheckColor(dc, color);
            if ( ! IS_RGBVALUE(color) )
            {
                return !! ::StretchBlt(hdc, x, y, cx, cy, dc, 0, 0, m_size.cx, m_size.cy, SRCCOPY);
            }
            return !! ::TransparentBlt(hdc, x, y, cx, cy, dc, 0, 0, m_size.cx, m_size.cy, color);
        }
        return false;
    }
 
    bool AlphaBlend(HDC hdc, int x, int y, int parsent = 100, int cx = 0, int cy = 0) const
    {
        if ( ! IsEmpty() )
        {
            m_CheckSize(cx, cy);
            CTempBitmapDC dc(m_hWnd, m_bmp);
            BLENDFUNCTION blend;
            blend.BlendOp = AC_SRC_OVER;
            blend.BlendFlags = 0;
            if ( parsent >= 0 )
            {
                blend.SourceConstantAlpha = static_cast<BYTE>(parsent * 255 / 100);
                blend.AlphaFormat = 0;
            }
            else
            {
                blend.SourceConstantAlpha = 255;
                blend.AlphaFormat = AC_SRC_ALPHA; //アルファチャネル使用
            }
            #if ! defined(_WIN32_WCE) || (_WIN32_WCE > 0x500) 
                return !! ::AlphaBlend(hdc, x, y, cx, cy, dc, 0, 0, m_size.cx, m_size.cy, blend);
            #endif
        }
        return false;
    }
 
    bool SemitransparectBlt(HDC hdc, int x, int y, int parsent = 100, COLORREF color = CLR_AUTOSELECT) const
    {
        if ( parsent >= 0 )
        {
            if ( parsent >= 100 )
            {
                return TransparentBit(hdc, x, y, color);
            }
            else if ( color == CLR_INVALID )
            {
                return AlphaBlend(hdc, x, y, parsent);
            }
        }
        //
        CBitmapImage biBase;
        RECT rc = { x, y, x + m_size.cx, y + m_size.cy };
        biBase.SetFromDC(hdc, rc);
        CBitmapImage biOver;
        biOver.Set(*this);
        if ( ! biBase.m_CheckDib() || ! biOver.m_CheckDib() )
        {
            return false;
        }
        if ( parsent >= 0 )
        {
            parsent = parsent * 255 / 100;
        }
        loop ( py, biOver.m_size.cy )
        {
            const RGBQUAD* pOver = biOver.GetRgbDataPtr(py);
            RGBQUAD* pBase = biBase.GetRgbDataPtr(py);
            if ( py == 0 && color == CLR_AUTOSELECT )
            {
                color = RGB(pOver->rgbRed, pOver->rgbGreen, pOver->rgbBlue);
            }
            DWORD tmp;
            loop ( px, biOver.m_size.cx )
            {
                if ( ! IS_RGBVALUE(color) || color != RGB(pOver->rgbRed, pOver->rgbGreen, pOver->rgbBlue) )
                {
                    int d = parsent;
                    if ( d < 0 )
                    {
                        d = pOver->rgbReserved;
                    }
                    tmp = (pBase->rgbBlue * (255 - d)) + (pOver->rgbBlue * d);
                    pBase->rgbBlue = static_cast<BYTE>((tmp > 255 * 255) ? 255 : (tmp / 255));
                    tmp = (pBase->rgbGreen * (255 - d)) + (pOver->rgbGreen * d);
                    pBase->rgbGreen = static_cast<BYTE>((tmp > 255 * 255) ? 255 : (tmp / 255));
                    tmp = (pBase->rgbRed * (255 - d)) + (pOver->rgbRed * d);
                    pBase->rgbRed = static_cast<BYTE>((tmp > 255 * 255) ? 255 : (tmp / 255));
                }
                pBase++;
                pOver++;
            }
        }
        return biBase.BitBlt(hdc, x, y);
    }
 
    bool HasRgbData(void) const
    {
        return m_pRgb != NULL;
    }
 
    bool ToHaveRgbData(void)
    {
        if ( m_pRgb == NULL )
        {
            m_CheckDib();
        }
        return m_pRgb != NULL;
    }
 
    RGBQUAD* GetRgbDataPtr(INT_PTR y = -1)
    {
        if ( m_pRgb != NULL )
        {
            if ( y < 0 )
            {
                return m_pRgb;
            }
            INT_PTR yy = (m_size.cy - 1) - y;
            return &m_pRgb[yy * m_size.cx];
        }
        return NULL;
    }
 
    const RGBQUAD* GetRgbDataPtr(INT_PTR y = -1) const
    {
        if ( m_pRgb != NULL )
        {
            if ( y < 0 )
            {
                return m_pRgb;
            }
            INT_PTR yy = (m_size.cy - 1) - y;
            return &m_pRgb[yy * m_size.cx];
        }
        return NULL;
    }
 
    CBitmapImage CreateRotateImage(void) const
    {
        if ( m_pRgb == NULL )
        {
            return CBitmapHandle();
        }
        const SIZE& sz = m_size;
        CBitmapImage bi;
        bi.Set(sz.cy, sz.cx);
        bi.ToHaveRgbData();
        loop ( y1, sz.cy )
        {
            INDEX x2 = y1;
            const RGBQUAD* p1 = &m_pRgb[y1 * sz.cx];
            loop ( x1, sz.cx )
            {
                INDEX y2 = x1;
                RGBQUAD* p2 = bi.GetRgbDataPtr(y2);
                p2[x2] = *p1++;
            }
        }
        return bi;
    }
 
    CBitmapImage CreateReverseImage(bool isVertical, bool isHorizontal) const
    {
        if ( m_pRgb == NULL )
        {
            return CBitmapHandle();
        }
        const SIZE& sz = m_size;
        CBitmapImage bi;
        bi.Set(sz.cx, sz.cy);
        bi.ToHaveRgbData();
        loop ( y1, sz.cy )
        {
            INDEX y2 = isVertical ? (sz.cy - 1) - y1 : y1;
            const RGBQUAD* p1 = &m_pRgb[y1 * sz.cx];
            if ( isHorizontal )
            {
                loop_dn ( x1, sz.cx )
                {
                    bi.m_pRgb[y2 * sz.cx + x1] = *p1++;
                }
            }
            else
            {
                loop ( x1, sz.cx )
                {
                    bi.m_pRgb[y2 * sz.cx + x1] = *p1++;
                }
            }
        }
        return bi;
    }
 
    CBitmapImage CreateGrayscaleBitmap(void) const
    {
        if ( m_pRgb == NULL )
        {
            return CBitmapHandle();
        }
        const SIZE& sz = m_size;
        CBitmapImage bi;
        bi.Set(sz.cx, sz.cy);
        bi.ToHaveRgbData();
        loop ( y1, sz.cy )
        {
            const RGBQUAD* p = &m_pRgb[y1 * sz.cx];
            loop ( x1, sz.cx )
            {
                BYTE r = p->rgbRed;
                BYTE g = p->rgbGreen;
                BYTE b = p->rgbBlue;
                int a = (r * 30 + g * 59 + b * 11) / 100;
                if ( a > 255 )
                {
                    a = 255;
                }
                RGBQUAD q;
                q.rgbRed = static_cast<BYTE>(a);
                q.rgbGreen = static_cast<BYTE>(a);
                q.rgbBlue = static_cast<BYTE>(a);
                bi.m_pRgb[y1 * sz.cx + x1] = q;
                p++;
            }
        }
        return bi;
    }
 
    CBitmapImage CreateDilationBitmap(void) const
    {
        return m_DilationErosion(true);
    }
    
    CBitmapImage CreateErosionBitmap(void) const
    {
        return m_DilationErosion(false);
    }
 
    CBitmapImage MedianFilter(void) const
    {
        if ( m_pRgb == NULL )
        {
            return CBitmapHandle();
        }
        CBitmapImage br;
        SIZE sz = m_size;
        br.Set(sz.cx, sz.cy);
        br.ToHaveRgbData();
        BYTE vb[9];
        loop ( y, sz.cy )
        {
            const RGBQUAD* po = GetRgbDataPtr(y);
            const RGBQUAD* po1 = GetRgbDataPtr(y - 1);// y=0の時期待外の値が返るが以降でカバーしてる
            const RGBQUAD* po2 = GetRgbDataPtr(y + 1);// y=sz.cy-1の時期待外の値が返るが以降でカバーしてる
            RGBQUAD* pr = br.GetRgbDataPtr(y);
            loop ( x, sz.cx )
            {
                if ( x == 0 || y == 0 || static_cast<int>(x) == sz.cx - 1 || static_cast<int>(y) == sz.cy - 1 )
                {
                    pr[x] = po[x];
                }
                else
                {
                    vb[0] = po1[x - 1].rgbBlue;
                    vb[1] = po1[x].rgbBlue;
                    vb[2] = po1[x + 1].rgbBlue;
                    vb[3] = po[x - 1].rgbBlue;
                    vb[4] = po[x].rgbBlue;
                    vb[5] = po[x + 1].rgbBlue;
                    vb[6] = po2[x - 1].rgbBlue;
                    vb[7] = po2[x].rgbBlue;
                    vb[8] = po2[x + 1].rgbBlue;
                    ::qsort(vb, 9, sizeof(BYTE), ms_DeSub);
                    pr[x].rgbBlue = vb[5];
                    //
                    vb[0] = po1[x - 1].rgbRed;
                    vb[1] = po1[x].rgbRed;
                    vb[2] = po1[x + 1].rgbRed;
                    vb[3] = po[x - 1].rgbRed;
                    vb[4] = po[x].rgbRed;
                    vb[5] = po[x + 1].rgbRed;
                    vb[6] = po2[x - 1].rgbRed;
                    vb[7] = po2[x].rgbRed;
                    vb[8] = po2[x + 1].rgbRed;
                    ::qsort(vb, 9, sizeof(BYTE), ms_DeSub);
                    pr[x].rgbRed = vb[5];
                    //
                    vb[0] = po1[x - 1].rgbGreen;
                    vb[1] = po1[x].rgbGreen;
                    vb[2] = po1[x + 1].rgbGreen;
                    vb[3] = po[x - 1].rgbGreen;
                    vb[4] = po[x].rgbGreen;
                    vb[5] = po[x + 1].rgbGreen;
                    vb[6] = po2[x - 1].rgbGreen;
                    vb[7] = po2[x].rgbGreen;
                    vb[8] = po2[x + 1].rgbGreen;
                    ::qsort(vb, 9, sizeof(BYTE), ms_DeSub);
                    pr[x].rgbGreen = vb[5];
                }
            }
        }
        return br;
    }
 
    DWORD Paint(int x, int y, COLORREF c)
    {
        if ( ! HasRgbData() )
        {
            return 0;
        }
        if ( x < 0 || y < 0 || x >= m_size.cx || y >= m_size.cy )
        {
            return 0;
        }
        y = (m_size.cy - 1) - y;
        TPaintInfo pi;
        pi.size = m_size;
        pi.count = 0;
        pi.pRgb = m_pRgb;
        pi.rgbBase = m_pRgb[x + y * m_size.cx];
        pi.rgb.rgbBlue = GetBValue(c);
        pi.rgb.rgbRed = GetRValue(c);
        pi.rgb.rgbGreen = GetGValue(c);
        if ( ! pi.IsEqualBase(pi.rgb) )
        {
            while ( true )
            {
                DWORD i = m_PaintSub(x, y, &pi);
                if ( i == DWORD_MAX ) break;
                x = i & 0xFFFF;
                y = i / 0x10000;
            }
        }
        return pi.count;
    }
 
    DWORD Save(LPCTSTR lpszFileName, WORD bitsPixel = 0)
    {
        return CBitmapHandle::Save(lpszFileName, m_bmp, bitsPixel);
    }
 
 
    //-----------------
 
 
    static HBITMAP _deprecated Load(LPCTSTR lpszFileName, int cx = 0, int cy = 0, UINT fuLoad = LR_CREATEDIBSECTION)
    {
        return CBitmapHandle::Load(lpszFileName, cx, cy, fuLoad);
    }
 
    static HBITMAP _deprecated Load(UINT uBitmapResourceId, int cx = 0, int cy = 0, UINT fuLoad = LR_CREATEDIBSECTION)
    {
        return CBitmapHandle::Load(uBitmapResourceId, cx, cy, fuLoad);
    }
 
    static bool GetBitmapSize(SIZE& _size, HBITMAP hBitmap)
    {
        BITMAP bm;
        if ( ::GetObject(hBitmap, sizeof(BITMAP), &bm) > 0 )
        {
            _size.cx = bm.bmWidth;
            _size.cy = bm.bmHeight;
            return true;
        }
        _GetLastError("GetObject");
        _size.cx = 0;
        _size.cy = 0;
        return false;
    }
 
    static CBitmapHandle ChangeByDpi(CBitmapHandle bmp)
    {
        SIZE orgSize;
        if ( bmp.GetSize(orgSize) )
        {
            SIZE sz = { CalcScaleX(orgSize.cx), CalcScaleY(orgSize.cy) };
            if ( sz.cx != orgSize.cx || sz.cy != orgSize.cy )
            {
                CBitmapImage bi;
                bi.Set(sz.cx, sz.cy);
                bi.Insert(0, 0, bmp, 13369376, sz.cx, sz.cy);
                return bi;
            }
        }
        return bmp;
    }
 
    static void CalcAdjustRect(RECT& _rect, const SIZE& dstSize, const SIZE& srcSize)
    {
        int ly = srcSize.cy * dstSize.cx / srcSize.cx;
        if ( dstSize.cy >= ly )
        {
            int d = (dstSize.cy - ly) / 2;
            ::SetRect(&_rect, 0, d, dstSize.cx, ly + d);
            return;
        }
        int lx = srcSize.cx * dstSize.cy / srcSize.cy;
        int d = (dstSize.cx - lx) / 2;
        ::SetRect(&_rect, d, 0, lx + d, dstSize.cy);
    }
 
private:
 
    CBitmapHandle       m_bmp;          
    RGBQUAD*            m_pRgb;         
    SIZE                m_size;         
    HWND                m_hWnd;         
    HDC                 m_backDC;       
    HGDIOBJ             m_backBmp;      
    int                 m_nStretchMode; 
 
    class CWorkDC
    {
        HWND    m_hWnd;
        HDC     m_dc;
    public:
        CWorkDC(HWND hWnd) : m_hWnd(hWnd), m_dc(::GetDC(hWnd))
        {
            ASSERT0( m_dc != NULL, "GetDC", "失敗しました。" );
        }
        ~CWorkDC(void)
        {
            if ( ! ::ReleaseDC(m_hWnd, m_dc) ) { ASSERT0( false, "ReleaseDC", "失敗しました。" ); }
        }
        operator HDC(void) { return m_dc; }
    };
    class CTempDC
    {
        HDC     m_dc;
        HGDIOBJ m_bmp;
    public:
        CTempDC(HDC dc, HBITMAP bmp) : m_dc(::CreateCompatibleDC(dc)), m_bmp(::SelectObject(m_dc, bmp))
        {
            ASSERT0( m_dc != NULL, "CreateCompatibleDC", "失敗しました。" );
            ASSERT0( m_bmp != NULL, "SelectObject", "失敗しました。" );
        }
        ~CTempDC(void)
        {
            if ( ::SelectObject(m_dc, m_bmp) == NULL ) { ASSERT0( false, "SelectObject", "失敗しました。" ); }
            if ( ! ::DeleteDC(m_dc) ) { ASSERT0( false, "DeleteDC", "失敗しました。" ); }
        }
        operator HDC(void) { return m_dc; }
    };
    class CTempBitmapDC
    {
        CWorkDC m_workDC;
        CTempDC m_tempDC;
    public:
        CTempBitmapDC(HWND hWnd, HBITMAP bmp) : m_workDC(hWnd), m_tempDC(m_workDC, bmp) { }
        operator HDC(void) { return m_tempDC; }
    };
 
    struct TPaintInfo
    {
        DWORD           count;      
        SIZE            size;       
        RGBQUAD*        pRgb;       
        RGBQUAD         rgbBase;    
        RGBQUAD         rgb;        
        bool IsEqualBase(const RGBQUAD& q) const
        {
            if ( rgbBase.rgbBlue != q.rgbBlue ) return false;
            if ( rgbBase.rgbRed != q.rgbRed ) return false;
            if ( rgbBase.rgbGreen != q.rgbGreen ) return false;
            return true;
        }
        bool IsEqualBase(DWORD x, DWORD y) const
        {
            return IsEqualBase(pRgb[x + y * size.cx]);
        }
    };
 
    #ifndef _WIN32_WCE
        enum { DEFAULT_STRETCHMODE = STRETCH_HALFTONE };
    #else
        enum { DEFAULT_STRETCHMODE = BILINEAR };
    #endif
 
    //小さいほうを選択
    static size_t ms_ChoiceMin(size_t a, size_t b)
    {
        return (a < b) ? a : b;
    }
    // Bitmapヘッダ設定
    static void ms_SetBitmapInfoHeader(BITMAPINFOHEADER& _bi, int cx, int cy, WORD bit = 32)
    {
        Zero(_bi);
        _bi.biSize          = sizeof(BITMAPINFOHEADER);
        _bi.biWidth         = cx;
        _bi.biHeight        = cy;
        _bi.biPlanes        = 1;
        _bi.biBitCount      = bit;
        _bi.biCompression   = BI_RGB;
    }
    // 空のビットマップ作成
    static HBITMAP ms_CreateBitmap(RGBQUAD*& _pRgb, HDC dc, int cx, int cy)
    {
        _pRgb = NULL;
        if ( cx > 0 && cy > 0 )
        {
            BITMAPINFOHEADER bm = { 0 };
            ms_SetBitmapInfoHeader(bm, cx, cy, 32);
            return ::CreateDIBSection(dc, reinterpret_cast<BITMAPINFO*>(&bm), DIB_RGB_COLORS, reinterpret_cast<void **>(&_pRgb), NULL, 0);
        }
        return NULL;
    }
    // RECT → SIZE 
    static bool ms_CheckSize(SIZE& _size, const RECT& rect)
    {
        _size.cx = rect.right - rect.left;
        _size.cy = rect.bottom - rect.top;
        return (_size.cx > 0 && _size.cy > 0);
    }
    static void ms_CheckSize(int& _cx, int& _cy, const SIZE& s)
    {
        if ( _cx <= 0 ) { _cx = s.cx; }
        if ( _cy <= 0 ) { _cy = s.cy; }
    }
    void m_CheckSize(int& _cx, int& _cy) const
    {
        ms_CheckSize(_cx, _cy, m_size);
    }
    // リリース
    void m_ReleaseDC(void)
    {
        if ( m_backDC != NULL )
        {
            if ( ::SelectObject(m_backDC, m_backBmp) == NULL )
            {
                ASSERT0( false, "SelectObject", "失敗しました。" );
            }
            if ( ! ::DeleteDC(m_backDC) )
            {
                ASSERT0( false, "DeleteDC", "失敗しました。" );
            }
            m_backDC = NULL;
        }
    }
    COLORREF m_CheckColor(HDC hdc, COLORREF color) const
    {
        if ( color == CLR_AUTOSELECT )
        {
            color = ::GetPixel(hdc, 0, m_size.cy - 1);
        }
        return color;
    }
    //メンバに記憶
    bool m_Set(CBitmapHandle bmp, RGBQUAD* pRgb = NULL)
    {
        if ( bmp == m_bmp )
        {
            return true;
        }
        Empty();
        if ( bmp.GetSize(m_size) )
        {
            m_bmp = bmp;
            m_pRgb = pRgb;
            return true;
        }
        return false;
    }
 
    static int ms_DeSub(const void* a, const void* b)
    {
        return *(BYTE*)a - *(BYTE*)b;
    }
 
    static inline BYTE ms_GG(const RGBQUAD* p, int cx, int x)
    {
        return (x < 0 || x >= cx) ? static_cast<BYTE>(0) : p[x].rgbGreen;
    }
 
    static inline BYTE ms_max(size_t len, BYTE* p)
    {
        BYTE r = p[0];
        loop ( i, len - 1 )
        {
            if ( r < p[i + 1] ) r = p[i + 1];
        }
        return r;
    }
 
    static inline BYTE ms_min(size_t len, BYTE* p)
    {
        BYTE r = p[0];
        loop ( i, len - 1 )
        {
            if ( r > p[i + 1] ) r = p[i + 1];
        }
        return r;
    }
 
    CBitmapImage m_DilationErosion(bool isDilation = true) const
    {
        if ( m_pRgb == NULL )
        {
            return CBitmapHandle();
        }
        SIZE sz = m_size;
        CBitmapImage b2;
        b2.Set(sz.cx, sz.cy);
        b2.ToHaveRgbData();
        //ダミーライン作成
        CWorkMemT<RGBQUAD> dp(sz.cx);
        RGBQUAD rgb = { 0 };
        dp.Fill(rgb);
        //
        loop ( y, sz.cy )
        {
            RGBQUAD* q = b2.GetRgbDataPtr(y);
            const RGBQUAD* p0 = (y == 0) ? dp : GetRgbDataPtr(y - 1);
            const RGBQUAD* p1 = GetRgbDataPtr(y);
            const RGBQUAD* p2 = (static_cast<int>(y) == sz.cy - 1) ? dp : GetRgbDataPtr(y + 1);
            loop ( x, sz.cx )
            {
                BYTE b[9];
                b[0] = ms_GG(p0, sz.cx, x - 1);
                b[1] = ms_GG(p0, sz.cx, x + 0);
                b[2] = ms_GG(p0, sz.cx, x + 1);
                b[3] = ms_GG(p1, sz.cx, x - 1);
                b[4] = ms_GG(p1, sz.cx, x + 0);
                b[5] = ms_GG(p1, sz.cx, x + 1);
                b[6] = ms_GG(p2, sz.cx, x - 1);
                b[7] = ms_GG(p2, sz.cx, x + 0);
                b[8] = ms_GG(p2, sz.cx, x + 1);
                BYTE r = isDilation ? ms_max(9, b) : ms_min(9, b);
                q[x].rgbGreen = r;
                q[x].rgbBlue = r;
                q[x].rgbRed = r;
            }
        }
        return b2;
    }
 
    DWORD m_PaintSub(int x, int y, TPaintInfo* p)
    {
        if ( ! p->IsEqualBase(x, y) )
        {
            return DWORD_MAX;
        }
        int i, j;
        for ( i = 1;; i++ )
        {
            if ( p->size.cx <= x + i || ! p->IsEqualBase(x + i, y) )
            {
                break;
            }
        }
        for ( j = 1;; j++ )
        {
            if ( 0 > x - j || ! p->IsEqualBase(x - j, y) )
            {
                break;
            }
        }
        RGBQUAD* q = &(p->pRgb[y * p->size.cx]);
        loop ( xx , j + i - 1 )
        {
            q[x - j + 1 + xx] = p->rgb;
        }
        p->count += j + i - 1;
        //
        x = x - j + 1;
        j = j + i - 1;
        DWORD l = 0;
        if ( p->size.cy > y + 1 )
        {
            for( i = 0; i < j;)
            {
                if ( ! p->IsEqualBase(x + i, y + 1) )
                {
                    for( ;i < j; i++ )
                    {
                        if ( p->IsEqualBase(x + i, y + 1) )
                            break;
                    }
                } 
                else
                {
                    for( ; i < j; i++ )
                    {
                        if ( ! p->IsEqualBase(x + i, y + 1) )
                            break;
                    }
                    l++;
                }
            }
        }
        if ( 0 <= y - 1 )
        {
            for ( i = 0; i < j; )
            {
                if ( ! p->IsEqualBase(x + i, y - 1) )
                {
                    for ( ; i < j; i++ )
                    {
                        if ( p->IsEqualBase(x + i, y - 1) )
                            break;
                    }
                } 
                else
                {
                    for( ; i < j; i++ )
                    {
                        if ( ! p->IsEqualBase(x + i, y - 1) )
                            break;
                    }
                    l++;
                }
            }
        }
        DWORD k = 0;
        for ( i = 0; i < j; i++ )
        {
            if ( p->size.cy > y + 1 && p->IsEqualBase(x + i, y + 1) )
            {
                if ( ++k >= l ) 
                {
                    return (x + i) + (y + 1) * 0x10000;
                }
                int xx = x + i;
                int yy = y + 1;
                while ( true )
                {
                    DWORD i = m_PaintSub(xx, yy, p);
                    if ( i == DWORD_MAX ) break;
                    xx = i & 0xFFFF;
                    yy = i / 0x10000;
                }
            }
            if ( 0 <= y - 1 && p->IsEqualBase(x + i, y - 1) )
            {
                if ( ++k >= l )
                {
                    return (x + i) + (y - 1) * 0x10000;
                }
                int xx = x + i;
                int yy = y - 1;
                while ( true )
                {
                    DWORD i = m_PaintSub(xx, yy, p);
                    if ( i == DWORD_MAX ) break;
                    xx = i & 0xFFFF;
                    yy = i / 0x10000;
                }
            }
        }
        return DWORD_MAX;
    }
 
    bool m_CheckDib(void)
    {
        if ( ! IsEmpty() && m_pRgb == NULL )
        {
            CBitmapImage bi;
            bi.Set(*this);
            if ( bi.m_pRgb == NULL )
            {
                BITMAP bp;
                if ( ::GetObject(bi.m_bmp, sizeof(BITMAP), &bp) > 0 && bp.bmBitsPixel == 32 )
                {
                    bi.m_pRgb = static_cast<RGBQUAD*>(bp.bmBits);
                }
            }
            if ( bi.m_pRgb == NULL )
            {
                bi.Set(*this, m_size.cx, m_size.cy);
                ASSERT( bi.m_pRgb != NULL );
            }
            *this = bi;
        }
        return (m_pRgb != NULL);
    }
};
 
 
 
};