• Win32 位图直接绘制

    CBitmapDraw.h

    1. #pragma once
    2. #include 
    3. #include 
    4.  
    5. #define COLOR_RGB_TO_BGR(_rgb) ( (_rgb & 0xFF) << 16)  |  (_rgb & 0x00FF00)  | ( (_rgb >> 16) & 0xFF)
    6.  
    7. typedef struct _BITMAP_DRAW_DATA
    8. {
    9.     BITMAPINFO binfo = { 0 };       //位图原始信息
    10.     HBITMAP hBitmap = nullptr;      //位图句柄
    11.     LONG width = 0;                 //位图宽度
    12.     LONG height = 0;                //位图高度
    13.     LPDWORD lpBits = nullptr;       //位图全部数据缓冲 宽度 * 高度 * sizeof(DWORD)
    14.     LPDWORD lpLineBuf = nullptr;    //位图单行数据缓冲 宽度 * sizeof(DWORD)
    15.  
    16.     _BITMAP_DRAW_DATA(const _BITMAP_DRAW_DATA&) = delete;
    17.  
    18.     _BITMAP_DRAW_DATA()
    19.     {
    20.         ZeroMemory(this, sizeof(_BITMAP_DRAW_DATA));
    21.     }
    22.  
    23.     ~_BITMAP_DRAW_DATA()
    24.     {
    25.         this->Release();
    26.     }
    27.  
    28.     _BITMAP_DRAW_DATA(_BITMAP_DRAW_DATA&& r) noexcept
    29.     {
    30.         this->binfo = r.binfo;
    31.         this->hBitmap = r.hBitmap;
    32.         this->width = r.width;
    33.         this->height = r.height;
    34.         this->lpBits = r.lpBits;
    35.         this->lpLineBuf = r.lpLineBuf;
    36.         
    37.         *this = std::move(r);
    38.     }
    39.  
    40.     _BITMAP_DRAW_DATA operator = (const _BITMAP_DRAW_DATA&) = delete;
    41.     _BITMAP_DRAW_DATA& operator = (_BITMAP_DRAW_DATA&& r) noexcept
    42.     {
    43.         this->binfo = r.binfo;
    44.         this->hBitmap = r.hBitmap;
    45.         this->width = r.width;
    46.         this->height = r.height;
    47.         this->lpBits = r.lpBits;
    48.         this->lpLineBuf = r.lpLineBuf;
    49.  
    50.         r.lpBits = nullptr;
    51.         r.lpLineBuf = nullptr;
    52.         r.hBitmap = nullptr;
    53.  
    54.         return *this;
    55.     }
    56.  
    57.     void Release()
    58.     {
    59.         if (nullptr != lpBits)
    60.         {
    61.             delete[] lpBits;
    62.             lpBits = nullptr;
    63.         }
    64.         if (nullptr != lpLineBuf)
    65.         {
    66.             delete[] lpLineBuf;
    67.             lpLineBuf = nullptr;
    68.         }
    69.  
    70.         ZeroMemory(this, sizeof(_BITMAP_DRAW_DATA));
    71.     }
    72. }BITMAP_DRAW_DATA, * PBITMAP_DRAW_DATA;
    73.  
    74. class CBitmapDraw
    75. {
    76. public:
    77.  
    78.     CBitmapDraw(HDC hdc);
    79.  
    80.     ~CBitmapDraw();
    81.  
    82.     //获取位图宽度
    83.     LONG GetWidth() const;
    84.  
    85.     //获取位图高度
    86.     LONG GetHeight() const;
    87.  
    88.     //获取位图左上坐标
    89.     POINT GetLeftTop() const;
    90.  
    91.     //获取位图右下坐标
    92.     POINT GetRightBottom() const;
    93.  
    94.     //准备绘制
    95.     bool BeginDraw();
    96.  
    97.     //结束绘制
    98.     bool EndDraw();
    99.  
    100.     //绘制矩形边框
    101.     void DrawRect(POINT ptLT, POINT ptRB, DWORD dwColor, bool bDotMode = false);
    102.  
    103.     //绘制线条
    104.     void DrawLine(POINT ptLT, POINT ptRB, DWORD dwColor, bool bDotMode = false);
    105.  
    106.     //绘制圆形
    107.     void DrawCircle(POINT ptLT, POINT ptRB, DWORD dwColor, bool bDotMode = false);
    108.  
    109.     //绘制网格
    110.     void DrawGrid(POINT ptSrcLT, POINT ptSrcRB, DWORD dwColor, LONG xCount = 1, LONG yCount = 1, bool bDotMode = false);
    111.  
    112.     //填充网格
    113.     void FillGrid(POINT ptSrcLT, POINT ptSrcRB, DWORD dwColor, LONG xCount = 1, LONG yCount = 1, POINT pt = { 0, 0 });
    114.  
    115.     //填充矩形区域
    116.     void FillRect(POINT ptSrcLT, POINT ptSrcRB, DWORD dwColor);
    117.  
    118.     //限制坐标
    119.     void LimitPiont(POINT& ptLT, POINT& ptRB);
    120.  
    121. public:
    122.  
    123.     //调节起始坐标点, 确保起始点坐标在终止坐标的左上方
    124.     static void AdjustPiont(POINT& ptLT, POINT& ptRB);
    125.  
    126.     //网格命中测试
    127.     static bool GridHitTest(POINT ptLT, POINT ptRB, DWORD xCount, DWORD yCount, POINT ptCheck, POINT& ptOut);
    128.  
    129. private:
    130.  
    131.     BITMAP_DRAW_DATA m_DrawData;    //绘制数据
    132.     HDC m_hDC = nullptr;            //DC句柄
    133. };
    134.

    CBitmapDraw.cpp

    1. #include "CBitmapDraw.h"
    2. #include 
    3. #include 
    4. #include 
    5.  
    6. #pragma intrinsic(memcpy)
    7.  
    8. CBitmapDraw::CBitmapDraw(HDC hdc)
    9. {
    10.     if (nullptr == hdc)
    11.     {
    12.         return;
    13.     }
    14.  
    15.     do
    16.     {
    17.         m_hDC = hdc;
    18.         int nScanlines = 0;
    19.  
    20.         //获取位图句柄
    21.         m_DrawData.hBitmap = (HBITMAP)::GetCurrentObject(hdc, OBJ_BITMAP);
    22.         if (nullptr == m_DrawData.hBitmap)
    23.         {
    24.             break;
    25.         }
    26.  
    27.         //获取位图信息
    28.         m_DrawData.binfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    29.         nScanlines = ::GetDIBits(hdc, m_DrawData.hBitmap, 0, 0, nullptr, &m_DrawData.binfo, DIB_RGB_COLORS);
    30.         if (0 == nScanlines)
    31.         {
    32.             break;
    33.         }
    34.  
    35.         m_DrawData.binfo.bmiHeader.biPlanes = 1;
    36.         m_DrawData.binfo.bmiHeader.biBitCount = 32;
    37.  
    38.         //取得位图尺寸, 分配位图数据缓冲
    39.         m_DrawData.width = m_DrawData.binfo.bmiHeader.biWidth;
    40.         m_DrawData.height = ::abs(m_DrawData.binfo.bmiHeader.biHeight);
    41.  
    42.         //高度方向矫正
    43.         m_DrawData.binfo.bmiHeader.biCompression = BI_RGB;
    44.         if (m_DrawData.binfo.bmiHeader.biHeight > 0)
    45.         {
    46.             m_DrawData.binfo.bmiHeader.biHeight = 0 - m_DrawData.binfo.bmiHeader.biHeight;
    47.         }
    48.  
    49.         m_DrawData.binfo.bmiHeader.biCompression = BI_RGB;
    50.  
    51.     } while (false);
    52. }
    53.  
    54. CBitmapDraw::~CBitmapDraw()
    55. {
    56.     m_DrawData.Release();
    57. }
    58.  
    59. LONG CBitmapDraw::GetWidth() const
    60. {
    61.     return m_DrawData.width;
    62. }
    63.  
    64. LONG CBitmapDraw::GetHeight() const
    65. {
    66.     return m_DrawData.height;
    67. }
    68.  
    69. POINT CBitmapDraw::GetLeftTop() const
    70. {
    71.     return {0, 0};
    72. }
    73.  
    74. POINT CBitmapDraw::GetRightBottom() const
    75. {
    76.     return { m_DrawData.width - 1, m_DrawData.height - 1 };
    77. }
    78.  
    79. bool CBitmapDraw::BeginDraw()
    80. {
    81.     if (nullptr == m_hDC)
    82.     {
    83.         return false;
    84.     }
    85.  
    86.     bool bRes = false;
    87.     do
    88.     {
    89.         m_DrawData.Release();
    90.  
    91.         //获取位图句柄
    92.         m_DrawData.hBitmap = (HBITMAP)::GetCurrentObject(m_hDC, OBJ_BITMAP);
    93.         if (nullptr == m_DrawData.hBitmap)
    94.         {
    95.             break;
    96.         }
    97.  
    98.         //获取位图信息
    99.         m_DrawData.binfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    100.         if (0 == ::GetDIBits(m_hDC, m_DrawData.hBitmap, 0, 0, nullptr, &m_DrawData.binfo, DIB_RGB_COLORS))
    101.         {
    102.             break;
    103.         }
    104.  
    105.         m_DrawData.binfo.bmiHeader.biPlanes = 1;
    106.         m_DrawData.binfo.bmiHeader.biBitCount = 32;
    107.  
    108.         //取得位图尺寸, 分配位图数据缓冲
    109.         m_DrawData.width = m_DrawData.binfo.bmiHeader.biWidth;
    110.         m_DrawData.height = ::abs(m_DrawData.binfo.bmiHeader.biHeight);
    111.         m_DrawData.lpBits = new (std::nothrow) DWORD[m_DrawData.width * m_DrawData.height];
    112.         if (nullptr == m_DrawData.lpBits)
    113.         {
    114.             break;
    115.         }
    116.  
    117.         memset(m_DrawData.lpBits, 0, (m_DrawData.width * m_DrawData.height) * sizeof(DWORD));
    118.  
    119.         //分配单行缓冲
    120.         m_DrawData.lpLineBuf = new (std::nothrow) DWORD[m_DrawData.width];
    121.         if (nullptr == m_DrawData.lpLineBuf)
    122.         {
    123.             break;
    124.         }
    125.         memset(m_DrawData.lpLineBuf, 0, m_DrawData.width * sizeof(DWORD));
    126.  
    127.         //高度方向矫正
    128.         m_DrawData.binfo.bmiHeader.biCompression = BI_RGB;
    129.         if (m_DrawData.binfo.bmiHeader.biHeight > 0)
    130.         {
    131.             m_DrawData.binfo.bmiHeader.biHeight = 0 - m_DrawData.binfo.bmiHeader.biHeight;
    132.         }
    133.  
    134.         //取得位图数据
    135.         int nScanlines = ::GetDIBits(m_hDC, m_DrawData.hBitmap, 0, m_DrawData.height, m_DrawData.lpBits, &m_DrawData.binfo, DIB_RGB_COLORS);
    136.         if (0 == nScanlines)
    137.         {
    138.             break;
    139.         }
    140.  
    141.         m_DrawData.binfo.bmiHeader.biCompression = BI_RGB;
    142.  
    143.         bRes = true;
    144.  
    145.     } while (false);
    146.  
    147.     return bRes;
    148. }
    149.  
    150. bool CBitmapDraw::EndDraw()
    151. {
    152.     if (nullptr == m_DrawData.lpBits)
    153.     {
    154.         return false;
    155.     }
    156.  
    157.     if (m_DrawData.lpBits)
    158.     {
    159.         //设置兼容位图中的像素。
    160.         int nScanlines = ::SetDIBits(m_hDC, m_DrawData.hBitmap, 0, m_DrawData.height, m_DrawData.lpBits, &m_DrawData.binfo, DIB_RGB_COLORS);
    161.         if (0 != nScanlines)
    162.         {
    163.             return true;
    164.         }
    165.     }
    166.  
    167.     return false;
    168. }
    169.  
    170. void CBitmapDraw::LimitPiont(POINT& ptLT, POINT& ptRB)
    171. {
    172.     LONG nWidth = m_DrawData.width;
    173.     LONG nHeight = m_DrawData.height;
    174.  
    175.     //起点坐标限制
    176.     if (ptLT.x < 0) ptLT.x = 0;
    177.     if (ptLT.y < 0) ptLT.y = 0;
    178.     if (ptLT.x > nWidth - 1) ptLT.x = nWidth - 1;
    179.     if (ptLT.y > nHeight - 1) ptLT.y = nHeight - 1;
    180.  
    181.     //终点坐标限制
    182.     if (ptRB.x < 0) ptRB.x = 0;
    183.     if (ptRB.y < 0) ptRB.y = 0;
    184.     if (ptRB.x > nWidth - 1) ptRB.x = nWidth - 1;
    185.     if (ptRB.y > nHeight - 1) ptRB.y = nHeight - 1;
    186. }
    187.  
    188. void CBitmapDraw::AdjustPiont(POINT& ptLT, POINT& ptRB)
    189. {
    190.     LONG x0 = ptLT.x < ptRB.x ? ptLT.x : ptRB.x;
    191.     LONG y0 = ptLT.y < ptRB.y ? ptLT.y : ptRB.y;
    192.     LONG x1 = ptLT.x > ptRB.x ? ptLT.x : ptRB.x;
    193.     LONG y1 = ptLT.y > ptRB.y ? ptLT.y : ptRB.y;
    194.     ptLT = { x0 , y0 };
    195.     ptRB = { x1 , y1 };
    196. }
    197. bool CBitmapDraw::GridHitTest(POINT ptLT, POINT ptRB, DWORD xCount, DWORD yCount, POINT ptCheck, POINT& ptOut)
    198. {
    199.     //调节限制位置
    200.     (void)AdjustPiont(ptLT, ptRB);
    201.  
    202.     //计算绘制区域宽高, 单行线条字节长度
    203.     int nDrawWidth = ptRB.x - ptLT.x + 1;
    204.     int nDrawHeight = ptRB.y - ptLT.y + 1;
    205.  
    206.     //格子数量限定
    207.     if (xCount < 1) xCount = 1;
    208.     if (yCount < 1) yCount = 1;
    209.  
    210.     //计算格子宽度
    211.     int xGridWidth = nDrawWidth / xCount;
    212.     int yGridHeight = nDrawHeight / yCount;
    213.  
    214.     //检查是否位于指定区域内(包含边框)
    215.     if (!((ptCheck.x >= ptLT.x && ptCheck.x <= ptRB.x) && (ptCheck.y >= ptLT.y && ptCheck.y <= ptRB.y)))
    216.     {
    217.         return false;
    218.     }
    219.  
    220.     ptOut.x = (ptCheck.x - ptLT.x) / xGridWidth;
    221.     ptOut.y = (ptCheck.y - ptLT.y) / yGridHeight;
    222.  
    223.     return true;
    224. }
    225.  
    226. void CBitmapDraw::DrawGrid(POINT ptSrcLT, POINT ptSrcRB, DWORD dwColor, LONG xCount/* = 1*/, LONG yCount/* = 1*/, bool bDotMode/* = false*/)
    227. {
    228.     dwColor = COLOR_RGB_TO_BGR(dwColor);
    229.     if (nullptr == m_DrawData.lpBits)
    230.     {
    231.         return;
    232.     }
    233.  
    234.     LPDWORD lpBits = m_DrawData.lpBits;
    235.     LPDWORD lpLineBuf = m_DrawData.lpLineBuf;
    236.     LONG nWidth = m_DrawData.width;
    237.     LONG nHeight = m_DrawData.height;
    238.  
    239.     //调节限制位置
    240.     (void)AdjustPiont(ptSrcLT, ptSrcRB);
    241.  
    242.     //填充单行颜色
    243.     if (lpLineBuf[0] != dwColor)
    244.     {
    245.         LPDWORD lpBuf = lpLineBuf;
    246.         for (int i = 0; i < nWidth; i++)
    247.         {
    248.             *lpBuf++ = dwColor;
    249.         }
    250.     }
    251.  
    252.     //计算绘制区域宽高, 单行线条字节长度
    253.     int nDrawWidth = ptSrcRB.x - ptSrcLT.x + 1;
    254.     int nDrawHeight = ptSrcRB.y - ptSrcLT.y + 1;
    255.  
    256.     //格子数量限定
    257.     if (xCount < 1) xCount = 1;
    258.     if (yCount < 1) yCount = 1;
    259.  
    260.     //计算格子宽度
    261.     int xGridSize = nDrawWidth / xCount;
    262.     int yGridSize = nDrawHeight / yCount;
    263.  
    264.     LPDWORD lpData = nullptr;
    265.  
    266.     LONG nLineXBegin = ptSrcLT.x;
    267.     LONG nLineXEnd = ptSrcRB.x;
    268.     LONG nLineYBegin = ptSrcLT.y;
    269.     LONG nLineYEnd = ptSrcRB.y;
    270.     LONG nLineXSize = 0;
    271.  
    272.     if (nLineXBegin < 0) nLineXBegin = 0;
    273.     if (nLineXEnd >= nWidth) nLineXEnd = nWidth - 1;
    274.     if (nLineYBegin < 0) nLineYBegin = 0;
    275.     if (nLineYEnd >= nHeight) nLineYEnd = nHeight - 1;
    276.     nLineXSize = (nLineXEnd - nLineXBegin) * sizeof(DWORD);
    277.  
    278.     //左边竖线
    279.     {
    280.         if (bDotMode)
    281.         {
    282.             int nIndex = 0;
    283.             LONG nCount = 0;
    284.             for (LONG i = ptSrcLT.x; i < ptSrcRB.x && nCount < xCount; i += xGridSize, nCount++)
    285.             {
    286.                 if (i >= 0 && i < nWidth)
    287.                 {
    288.                     lpData = lpBits + nLineYBegin * nWidth + i;
    289.                     for (LONG j = nLineYBegin; j < nLineYEnd; j++)
    290.                     {
    291.                         if (nIndex & 0x01)
    292.                         {
    293.                             *lpData = dwColor;
    294.                         }
    295.                         lpData += nWidth;
    296.                         nIndex++;
    297.                     }
    298.                 }
    299.             }
    300.         }
    301.         else
    302.         {
    303.             LONG nCount = 0;
    304.             for (LONG i = ptSrcLT.x; i < ptSrcRB.x && nCount < xCount; i += xGridSize, nCount++)
    305.             {
    306.                 if (i >= 0 && i < nWidth)
    307.                 {
    308.                     lpData = lpBits + nLineYBegin * nWidth + i;
    309.                     for (LONG j = nLineYBegin; j < nLineYEnd; j++)
    310.                     {
    311.                         *lpData = dwColor;
    312.                         lpData += nWidth;
    313.                     }
    314.                 }
    315.             }
    316.         }
    317.     }
    318.  
    319.     //顶部横线
    320.     {
    321.         if (bDotMode)
    322.         {
    323.             LONG nCount = 0;
    324.             int nSize = nLineXEnd - nLineXBegin;
    325.             for (LONG i = ptSrcLT.y; i < ptSrcRB.y && nCount < yCount; i += yGridSize, nCount++)
    326.             {
    327.                 if (i >= 0 && i < nHeight)
    328.                 {
    329.                     lpData = lpBits + i * nWidth + nLineXBegin;
    330.  
    331.                     int nIndex = 0;
    332.                     for (int j = 0; j < nSize; j++)
    333.                     {
    334.                         if (nIndex & 0x01)
    335.                         {
    336.                             lpData[j] = dwColor;
    337.                         }
    338.                         nIndex++;
    339.                     }
    340.  
    341.                 }
    342.             }
    343.         }
    344.         else
    345.         {
    346.             LONG nCount = 0;
    347.             for (LONG i = ptSrcLT.y; i < ptSrcRB.y && nCount < yCount; i += yGridSize, nCount++)
    348.             {
    349.                 if (i >= 0 && i < nHeight)
    350.                 {
    351.                     lpData = lpBits + i * nWidth + nLineXBegin;
    352.                     ::memcpy_s(lpData, nLineXSize, lpLineBuf, nLineXSize);
    353.                 }
    354.             }
    355.         }
    356.     }
    357.  
    358.     //右边竖线
    359.     if (bDotMode)
    360.     {
    361.         if (ptSrcRB.x >= 0 && ptSrcRB.x < nWidth)
    362.         {
    363.             int nIndex = 0;
    364.             lpData = lpBits + nLineYBegin * nWidth + ptSrcRB.x;
    365.             for (LONG i = nLineYBegin; i <= nLineYEnd; i++)
    366.             {
    367.                 if (nIndex & 0x01)
    368.                 {
    369.                     *lpData = dwColor;
    370.                 }
    371.  
    372.                 lpData += nWidth;
    373.                 nIndex++;
    374.             }
    375.         }
    376.     }
    377.     else
    378.     {
    379.         if (ptSrcRB.x >= 0 && ptSrcRB.x < nWidth)
    380.         {
    381.             lpData = lpBits + nLineYBegin * nWidth + ptSrcRB.x;
    382.             for (LONG i = nLineYBegin; i <= nLineYEnd; i++)
    383.             {
    384.                 *lpData = dwColor;
    385.                 lpData += nWidth;
    386.             }
    387.         }
    388.     }
    389.  
    390.     //底部横线
    391.     if (ptSrcRB.y >= 0 && ptSrcRB.y < nHeight)
    392.     {
    393.         lpData = lpBits + nLineYEnd * nWidth + nLineXBegin;
    394.         if (bDotMode)
    395.         {
    396.             int nIndex = 0;
    397.             int nSize = nLineXEnd - nLineXBegin;
    398.             for (int i = 0; i < nSize; i++)
    399.             {
    400.                 if (nIndex & 0x01)
    401.                 {
    402.                     lpData[i] = dwColor;
    403.                 }
    404.                 nIndex++;
    405.             }
    406.         }
    407.         else
    408.         {
    409.             ::memcpy_s(lpData, nLineXSize, lpLineBuf, nLineXSize);
    410.         }
    411.     }
    412. }
    413.  
    414. void CBitmapDraw::FillGrid(POINT ptLT, POINT ptRB, DWORD dwColor, LONG xCount/* = 1*/, LONG yCount/* = 1*/, POINT pt/* = { 0, 0 }*/)
    415. {
    416.     dwColor = COLOR_RGB_TO_BGR(dwColor);
    417.     if (nullptr == m_DrawData.lpBits)
    418.     {
    419.         return;
    420.     }
    421.  
    422.     LPDWORD lpBits = m_DrawData.lpBits;
    423.     LPDWORD lpLineBuf = m_DrawData.lpLineBuf;
    424.     LONG nWidth = m_DrawData.width;
    425.  
    426.     //调节限制位置
    427.     (void)AdjustPiont(ptLT, ptRB);
    428.     (void)LimitPiont(ptLT, ptRB);
    429.  
    430.     //填充单行颜色
    431.     if (lpLineBuf[0] != dwColor)
    432.     {
    433.         LPDWORD lpBuf = lpLineBuf;
    434.         for (int i = 0; i < nWidth; i++)
    435.         {
    436.             *lpBuf++ = dwColor;
    437.         }
    438.     }
    439.  
    440.     //计算绘制区域宽高, 单行线条字节长度
    441.     int nDrawWidth = ptRB.x - ptLT.x + 1;
    442.     int nDrawHeight = ptRB.y - ptLT.y + 1;
    443.  
    444.     //格子数量限定
    445.     if (xCount < 1) xCount = 1;
    446.     if (yCount < 1) yCount = 1;
    447.  
    448.     //限定目标格子坐标
    449.     if (pt.x < 0) pt.x = 0;
    450.     if (pt.y < 0) pt.y = 0;
    451.     if (pt.x >= xCount) pt.x = xCount - 1;
    452.     if (pt.y >= yCount) pt.y = yCount - 1;
    453.  
    454.     //计算格子宽度
    455.     int xGridWidth = nDrawWidth / xCount;
    456.     int yGridHeight = nDrawHeight / yCount;
    457.     int xGridWidthSize = xGridWidth * sizeof(DWORD);
    458.  
    459.     //填充单行颜色
    460.     if (lpLineBuf[0] != dwColor)
    461.     {
    462.         LPDWORD lpBuf = lpLineBuf;
    463.         for (int i = 0; i < nWidth; i++)
    464.         {
    465.             *lpBuf++ = dwColor;
    466.         }
    467.     }
    468.  
    469.     //填充
    470.     LPDWORD lpData = lpBits + (ptLT.y + pt.y * yGridHeight) * nWidth + ptLT.x + pt.x * xGridWidth;
    471.     for (int i = 0; i < yGridHeight; i++)
    472.     {
    473.         memcpy_s(lpData, xGridWidthSize, lpLineBuf, xGridWidthSize);
    474.         lpData += nWidth;
    475.     }
    476. }
    477.  
    478. void CBitmapDraw::FillRect(POINT ptSrcLT, POINT ptSrcRB, DWORD dwColor)
    479. {
    480.     dwColor = COLOR_RGB_TO_BGR(dwColor);
    481.     if (nullptr == m_DrawData.lpBits)
    482.     {
    483.         return;
    484.     }
    485.  
    486.     LPDWORD lpBits = m_DrawData.lpBits;
    487.     LPDWORD lpLineBuf = m_DrawData.lpLineBuf;
    488.     LONG nWidth = m_DrawData.width;
    489.  
    490.     POINT ptLT = ptSrcLT;
    491.     POINT ptRB = ptSrcRB;
    492.  
    493.     //调节限制位置
    494.     (void)AdjustPiont(ptLT, ptRB);
    495.     (void)LimitPiont(ptLT, ptRB);
    496.  
    497.     //填充单行颜色
    498.     if (lpLineBuf[0] != dwColor)
    499.     {
    500.         LPDWORD lpBuf = lpLineBuf;
    501.         for (int i = 0; i < nWidth; i++)
    502.         {
    503.             *lpBuf++ = dwColor;
    504.         }
    505.     }
    506.  
    507.     //计算绘制区域宽高, 单行线条字节长度
    508.     int nDrawWidth = ptRB.x - ptLT.x + 1;
    509.     int nDrawHeight = ptRB.y - ptLT.y + 1;
    510.     int nDrawLineSize = nDrawWidth * sizeof(DWORD);
    511.  
    512.     LPDWORD lpData = lpBits + (ptLT.y) * nWidth + ptLT.x;
    513.     for (int i = 0; i < nDrawHeight; i++)
    514.     {
    515.         memcpy_s(lpData, nDrawLineSize, lpLineBuf, nDrawLineSize);
    516.         lpData += nWidth;
    517.     }
    518. }
    519.  
    520. void CBitmapDraw::DrawRect(POINT ptSrcLT, POINT ptSrcRB, DWORD dwColor, bool bDotMode/* = true*/)
    521. {
    522.     dwColor = COLOR_RGB_TO_BGR(dwColor);
    523.     if (nullptr == m_DrawData.lpBits)
    524.     {
    525.         return;
    526.     }
    527.  
    528.     LPDWORD lpBits = m_DrawData.lpBits;
    529.     LPDWORD lpLineBuf = m_DrawData.lpLineBuf;
    530.     LONG nWidth = m_DrawData.width;
    531.     LONG nHeight = m_DrawData.height;
    532.  
    533.     //调节限制位置
    534.     (void)AdjustPiont(ptSrcLT, ptSrcRB);
    535.  
    536.     //填充单行颜色
    537.     if (lpLineBuf[0] != dwColor)
    538.     {
    539.         LPDWORD lpBuf = lpLineBuf;
    540.         for (int i = 0; i < nWidth; i++)
    541.         {
    542.             *lpBuf++ = dwColor;
    543.         }
    544.     }
    545.  
    546.     LONG nLineXBegin = ptSrcLT.x;
    547.     LONG nLineXEnd = ptSrcRB.x;
    548.     LONG nLineYBegin = ptSrcLT.y;
    549.     LONG nLineYEnd = ptSrcRB.y;
    550.     LONG nLineXSize = 0;
    551.  
    552.     if (nLineXBegin < 0) nLineXBegin = 0;
    553.     if (nLineXEnd >= nWidth) nLineXEnd = nWidth - 1;
    554.     if (nLineYBegin < 0) nLineYBegin = 0;
    555.     if (nLineYEnd >= nHeight) nLineYEnd = nHeight - 1;
    556.     nLineXSize = (nLineXEnd - nLineXBegin) * sizeof(DWORD);
    557.  
    558.     LPDWORD lpData = nullptr;
    559.  
    560.     //顶部横线
    561.     if (ptSrcLT.y >= 0 && ptSrcLT.y < nHeight && nLineXSize > 0)
    562.     {
    563.         lpData = lpBits + nLineYBegin * nWidth + nLineXBegin;
    564.  
    565.         if (bDotMode)
    566.         {
    567.             int nIndex = 0;
    568.             int nSize = nLineXEnd - nLineXBegin;
    569.             for (int i = 0; i < nSize; i++)
    570.             {
    571.                 if (nIndex & 0x01)
    572.                 {
    573.                     lpData[i] = dwColor;
    574.                 }
    575.                 nIndex++;
    576.             }
    577.         }
    578.         else
    579.         {
    580.             ::memcpy_s(lpData, nLineXSize, lpLineBuf, nLineXSize);
    581.         }
    582.  
    583.     }
    584.  
    585.     //底部横线
    586.     if (ptSrcRB.y >= 0 && ptSrcRB.y < nHeight && nLineXSize > 0)
    587.     {
    588.         lpData = lpBits + nLineYEnd * nWidth + nLineXBegin;
    589.         if (bDotMode)
    590.         {
    591.             int nIndex = 0;
    592.             int nSize = nLineXEnd - nLineXBegin;
    593.             for (int i = 0; i < nSize; i++)
    594.             {
    595.                 if (nIndex & 0x01)
    596.                 {
    597.                     lpData[i] = dwColor;
    598.                 }
    599.                 nIndex++;
    600.             }
    601.         }
    602.         else
    603.         {
    604.             ::memcpy_s(lpData, nLineXSize, lpLineBuf, nLineXSize);
    605.         }
    606.     }
    607.  
    608.     //左边竖线
    609.     if (ptSrcLT.x >= 0 && ptSrcLT.x < nWidth)
    610.     {
    611.         lpData = lpBits + nLineYBegin * nWidth + nLineXBegin;
    612.  
    613.         if (bDotMode)
    614.         {
    615.             int nIndex = 0;
    616.             for (LONG i = nLineYBegin; i < nLineYEnd; i++)
    617.             {
    618.                 if (nIndex & 0x01)
    619.                 {
    620.                     *lpData = dwColor;
    621.                 }
    622.                 lpData += nWidth;
    623.                 nIndex++;
    624.             }
    625.         }
    626.         else
    627.         {
    628.             for (LONG i = nLineYBegin; i < nLineYEnd; i++)
    629.             {
    630.                 *lpData = dwColor;
    631.                 lpData += nWidth;
    632.             }
    633.         }
    634.     }
    635.  
    636.     //右边竖线
    637.     if (ptSrcRB.x >= 0 && ptSrcRB.x < nWidth)
    638.     {
    639.         lpData = lpBits + nLineYBegin * nWidth + nLineXEnd;
    640.  
    641.         if (bDotMode)
    642.         {
    643.             int nIndex = 0;
    644.             for (LONG i = nLineYBegin; i <= nLineYEnd; i++)
    645.             {
    646.                 if (nIndex & 0x01)
    647.                 {
    648.                     *lpData = dwColor;
    649.                 }
    650.                 lpData += nWidth;
    651.                 nIndex++;
    652.             }
    653.         }
    654.         else
    655.         {
    656.             for (LONG i = nLineYBegin; i <= nLineYEnd; i++)
    657.             {
    658.                 *lpData = dwColor;
    659.                 lpData += nWidth;
    660.             }
    661.         }
    662.     }
    663. }
    664.  
    665. void CBitmapDraw::DrawLine(POINT ptSrcLT, POINT ptSrcRB, DWORD dwColor, bool bDotMode/* = true*/)
    666. {
    667.     dwColor = COLOR_RGB_TO_BGR(dwColor);
    668.     if (nullptr == m_DrawData.lpBits)
    669.     {
    670.         return;
    671.     }
    672.  
    673.     LPDWORD lpBits = m_DrawData.lpBits;
    674.     LONG nWidth = m_DrawData.width;
    675.     LONG nHeight = m_DrawData.height;
    676.  
    677.     POINT ptLT = ptSrcLT;
    678.     POINT ptRB = ptSrcRB;
    679.  
    680.     //计算绘制区域内相交点
    681.  
    682.     /*{
    683.         int x0 = ptLT.x;
    684.         int y0 = ptLT.y;
    685.         int x1 = ptRB.x;
    686.         int y1 = ptRB.y;
    688.         int dx = abs(x1 - x0), sx = x0 < x1 ? 1 : -1;
    689.         int dy = abs(y1 - y0), sy = y0 < y1 ? 1 : -1;
    690.         int erro = (dx > dy ? dx : -dy) / 2;
    692.         do
    693.         {
    694.             lpBits[y0 * nWidth + x0] = dwColor;
    696.             int e2 = erro;
    697.             if (e2 > -dx)
    698.             {
    699.                 erro -= dy;
    700.                 x0 += sx;
    701.             }
    703.             if (e2 < dy)
    704.             {
    705.                 erro += dx;
    706.                 y0 += sy;
    707.             }
    709.         } while (x0 != x1 || y0 != y1);
    710.     }*/
    711.  
    712.     //画任意斜率的直线（基于 Bresenham 算法）
    713.     
    714.     {
    715.         int x1 = ptLT.x;
    716.         int y1 = ptLT.y;
    717.         int x2 = ptRB.x;
    718.         int y2 = ptRB.y;
    719.  
    720.         int x = ptLT.x;
    721.         int y = ptLT.y;
    722.  
    723.         int dx = ::abs(x2 - x1);
    724.         int dy = ::abs(y2 - y1);
    725.         int s1 = x2 > x1 ? 1 : -1;
    726.         int s2 = y2 > y1 ? 1 : -1;
    727.  
    728.         bool interchange = false;// 默认不互换 dx、dy
    729.         if (dy > dx)// 当斜率大于 1 时，dx、dy 互换
    730.         {
    731.             int temp = dx;
    732.             dx = dy;
    733.             dy = temp;
    734.             interchange = true;
    735.         }
    736.  
    737.         int p = 2 * dy - dx;
    738.  
    739.         if (!interchange)
    740.         {
    741.             if (bDotMode)
    742.             {
    743.                 int nIndex = 0;
    744.                 for (int i = 0; i <= dx; i++)
    745.                 {
    746.                     if (y >= 0 && y < nHeight && x >= 0 && x < nWidth)
    747.                     {
    748.                         if (nIndex & 0x01)
    749.                         {
    750.                             lpBits[y * nWidth + x] = dwColor;
    751.                         }
    752.                         nIndex++;
    753.                     }
    754.  
    755.                     if (p >= 0)
    756.                     {
    757.                         y += s2;
    758.                         p -= 2 * dx;
    759.                     }
    760.  
    761.                     x += s1;// 当斜率 < 1 时，选取 x 为步长
    762.                     p += 2 * dy;
    763.                 }
    764.             }
    765.             else
    766.             {
    767.                 for (int i = 0; i <= dx; i++)
    768.                 {
    769.                     if (y >= 0 && y < nHeight && x >= 0 && x < nWidth)
    770.                     {
    771.                         lpBits[y * nWidth + x] = dwColor;
    772.                     }
    773.  
    774.                     if (p >= 0)
    775.                     {
    776.                         y += s2;
    777.                         p -= 2 * dx;
    778.                     }
    779.  
    780.                     x += s1;// 当斜率 < 1 时，选取 x 为步长
    781.                     p += 2 * dy;
    782.                 }
    783.             }
    784.         }
    785.         else
    786.         {
    787.             if (bDotMode)
    788.             {
    789.                 int nIndex = 0;
    790.                 for (int i = 0; i <= dx; i++)
    791.                 {
    792.                     if (y >= 0 && y < nHeight && x >= 0 && x < nWidth)
    793.                     {
    794.                         if (nIndex & 0x01)
    795.                         {
    796.                             lpBits[y * nWidth + x] = dwColor;
    797.                         }
    798.                         nIndex++;
    799.                     }
    800.  
    801.                     if (p >= 0)
    802.                     {
    803.                         x += s1;
    804.                         p -= 2 * dx;
    805.                     }
    806.  
    807.                     y += s2;// 当斜率 > 1 时，选取 y 为步长
    808.                     p += 2 * dy;
    809.                 }
    810.             }
    811.             else
    812.             {
    813.                 for (int i = 0; i <= dx; i++)
    814.                 {
    815.                     if (y >= 0 && y < nHeight && x >= 0 && x < nWidth)
    816.                     {
    817.                         lpBits[y * nWidth + x] = dwColor;
    818.                     }
    819.  
    820.                     if (p >= 0)
    821.                     {
    822.                         x += s1;
    823.                         p -= 2 * dx;
    824.                     }
    825.  
    826.                     y += s2;// 当斜率 > 1 时，选取 y 为步长
    827.                     p += 2 * dy;
    828.                 }
    829.             }
    830.         }
    831.     }
    832. }
    833.  
    834. void CBitmapDraw::DrawCircle(POINT ptLT, POINT ptRB, DWORD dwColor, bool bDotMode/* = true*/)
    835. {
    836.     dwColor = COLOR_RGB_TO_BGR(dwColor);
    837.     if (nullptr == m_DrawData.lpBits)
    838.     {
    839.         return;
    840.     }
    841.  
    842.     LPDWORD lpBits = m_DrawData.lpBits;
    843.     LONG nWidth = m_DrawData.width;
    844.     LONG nHeight = m_DrawData.height;
    845.  
    846.     //调节限制位置
    847.     (void)AdjustPiont(ptLT, ptRB);
    848.  
    849.     LONG nW = ptRB.x - ptLT.x;
    850.     LONG nH = ptRB.y - ptLT.y;
    851.  
    852.     LONG r = (LONG)::sqrt((nW * nW) + (nH * nH)) / 2;
    853.  
    854.     LONG x = ptLT.x;
    855.     LONG y = ptLT.y;
    856.  
    857.     x += nW / 2;
    858.     y += nH / 2;
    859.  
    860.     {
    861.         int  xi;
    862.         int  yi;
    863.         int  di;
    864.         di = 1 - r;
    865.         xi = 0;
    866.         yi = r;
    867.         LONGLONG dwOffset = 0;
    868.         
    869.         int nXPox = 0;
    870.         int nYPos = 0;
    871.  
    872.         if (bDotMode)
    873.         {
    874.             int nIndex = 0;
    875.             while (yi >= xi)
    876.             {
    877.                 //右下 1/4
    878.                 nXPox = y + yi;
    879.                 nYPos = x + xi;
    880.                 dwOffset = nXPox * nWidth + nYPos;
    881.                 if (nXPox >= 0 && nXPox < nHeight && nYPos >= 0 && nYPos < nWidth && nIndex & 0x01) lpBits[dwOffset] = dwColor;
    882.  
    883.                 nXPox = y + xi;
    884.                 nYPos = x + yi;
    885.                 dwOffset = nXPox * nWidth + nYPos;
    886.                 if (nXPox >= 0 && nXPox < nHeight && nYPos >= 0 && nYPos < nWidth && nIndex & 0x01) lpBits[dwOffset] = dwColor;
    887.  
    888.                 //左下 1/4
    889.                 nXPox = y + yi;
    890.                 nYPos = x - xi;
    891.                 dwOffset = nXPox * nWidth + nYPos;
    892.                 if (nXPox >= 0 && nXPox < nHeight && nYPos >= 0 && nYPos < nWidth && nIndex & 0x01) lpBits[dwOffset] = dwColor;
    893.  
    894.                 nXPox = y + xi;
    895.                 nYPos = x - yi;
    896.                 dwOffset = nXPox * nWidth + nYPos;
    897.                 if (nXPox >= 0 && nXPox < nHeight && nYPos >= 0 && nYPos < nWidth && nIndex & 0x01) lpBits[dwOffset] = dwColor;
    898.  
    899.                 //左上 1/4
    900.                 nXPox = y - yi;
    901.                 nYPos = x - xi;
    902.                 dwOffset = nXPox * nWidth + nYPos;
    903.                 if (nXPox >= 0 && nXPox < nHeight && nYPos >= 0 && nYPos < nWidth && nIndex & 0x01) lpBits[dwOffset] = dwColor;
    904.  
    905.                 nXPox = y - xi;
    906.                 nYPos = x - yi;
    907.                 dwOffset = nXPox * nWidth + nYPos;
    908.                 if (nXPox >= 0 && nXPox < nHeight && nYPos >= 0 && nYPos < nWidth && nIndex & 0x01) lpBits[dwOffset] = dwColor;
    909.  
    910.                 //右上 1/4
    911.                 nXPox = y - yi;
    912.                 nYPos = x + xi;
    913.                 dwOffset = nXPox * nWidth + nYPos;
    914.                 if (nXPox >= 0 && nXPox < nHeight && nYPos >= 0 && nYPos < nWidth && nIndex & 0x01) lpBits[dwOffset] = dwColor;
    915.  
    916.                 nXPox = y - xi;
    917.                 nYPos = x + yi;
    918.                 dwOffset = nXPox * nWidth + nYPos;
    919.                 if (nXPox >= 0 && nXPox < nHeight && nYPos >= 0 && nYPos < nWidth && nIndex & 0x01) lpBits[dwOffset] = dwColor;
    920.  
    921.                 if (di < 0)
    922.                 {
    923.                     di += 3 + (xi << 1);
    924.                 }
    925.                 else
    926.                 {
    927.                     di += 5 + ((xi - yi) << 1);
    928.                     yi--;
    929.                 }
    930.                 xi++;
    931.                 nIndex++;
    932.             }
    933.         }
    934.         else
    935.         {
    936.             while (yi >= xi)
    937.             {
    938.                 //右下 1/4
    939.                 nXPox = y + yi;
    940.                 nYPos = x + xi;
    941.                 dwOffset = nXPox * nWidth + nYPos;
    942.                 if (nXPox >= 0 && nXPox < nHeight && nYPos >= 0 && nYPos < nWidth) lpBits[dwOffset] = dwColor;
    943.  
    944.                 nXPox = y + xi;
    945.                 nYPos = x + yi;
    946.                 dwOffset = nXPox * nWidth + nYPos;
    947.                 if (nXPox >= 0 && nXPox < nHeight && nYPos >= 0 && nYPos < nWidth) lpBits[dwOffset] = dwColor;
    948.  
    949.                 //左下 1/4
    950.                 nXPox = y + yi;
    951.                 nYPos = x - xi;
    952.                 dwOffset = nXPox * nWidth + nYPos;
    953.                 if (nXPox >= 0 && nXPox < nHeight && nYPos >= 0 && nYPos < nWidth) lpBits[dwOffset] = dwColor;
    954.  
    955.                 nXPox = y + xi;
    956.                 nYPos = x - yi;
    957.                 dwOffset = nXPox * nWidth + nYPos;
    958.                 if (nXPox >= 0 && nXPox < nHeight && nYPos >= 0 && nYPos < nWidth) lpBits[dwOffset] = dwColor;
    959.  
    960.                 //左上 1/4
    961.                 nXPox = y - yi;
    962.                 nYPos = x - xi;
    963.                 dwOffset = nXPox * nWidth + nYPos;
    964.                 if (nXPox >= 0 && nXPox < nHeight && nYPos >= 0 && nYPos < nWidth) lpBits[dwOffset] = dwColor;
    965.  
    966.                 nXPox = y - xi;
    967.                 nYPos = x - yi;
    968.                 dwOffset = nXPox * nWidth + nYPos;
    969.                 if (nXPox >= 0 && nXPox < nHeight && nYPos >= 0 && nYPos < nWidth) lpBits[dwOffset] = dwColor;
    970.  
    971.                 //右上 1/4
    972.                 nXPox = y - yi;
    973.                 nYPos = x + xi;
    974.                 dwOffset = nXPox * nWidth + nYPos;
    975.                 if (nXPox >= 0 && nXPox < nHeight && nYPos >= 0 && nYPos < nWidth) lpBits[dwOffset] = dwColor;
    976.  
    977.                 nXPox = y - xi;
    978.                 nYPos = x + yi;
    979.                 dwOffset = nXPox * nWidth + nYPos;
    980.                 if (nXPox >= 0 && nXPox < nHeight && nYPos >= 0 && nYPos < nWidth) lpBits[dwOffset] = dwColor;
    981.  
    982.                 if (di < 0)
    983.                 {
    984.                     di += 3 + (xi << 1);
    985.                 }
    986.                 else
    987.                 {
    988.                     di += 5 + ((xi - yi) << 1);
    989.                     yi--;
    990.                 }
    991.                 xi++;
    992.             }
    993.         }
    994.     }
    995. }

    be468fac3d7844ceba488d08aa36c289.png

    CBitmapPaint: 位图操作绘制图形 1.绘制线条 2.绘制矩形边框 3.填充矩形区域 4.绘制圆形边框 5.绘制网格线条 并比较使用位图操作与使用GDI绘制的速度 (gitee.com)

     

  • 相关阅读:
    【Jmeter 简单使用】
    换低挡装置（Kickdown, ACM/ICPC NEERC 2006, UVa1588）rust解法
    flink学习-容错机制
    golang程序能不能用LD_PRELOAD进行hook？
    我的Go并发之旅、01 并发哲学与并发原语
    基于Keras搭建LSTM网络实现文本情感分类
    金和OA C6任意文件读取漏洞 复现[附POC]
    UFS Power Management 介绍
    [JS] canvas 详解
    mybatis的简单使用
  • 原文地址：https://blog.csdn.net/Flame_Cyclone/article/details/133162340