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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 图形图像处理 > 查看源码
cdib.cpp
资源名称：FINAL.rar　[点击查看]
上传用户：piaozanzhu
上传日期：2008-02-14
资源大小：212k
文件大小：38k
源码类别：

图形图像处理

开发平台：

Visual C++

cdib.cpp：源码内容
  1. // cdib.cpp
  3. #include "stdafx.h"
  4. #include "math.h"
  5. //  #include "process.h"      //后来删除，暂时不发现影响
  7. #include "cdib.h"
  8. #include "GlobalApi.h"
  10. #ifdef _DEBUG
  11. #define new DEBUG_NEW
  12. #undef THIS_FILE
  13. static char THIS_FILE[] = __FILE__;
  14. #endif
  16. // 声明串行化过程
  17. IMPLEMENT_SERIAL(CDib, CObject, 0);
  20. /*************************************************************************
  21.  *
  22.  * 函数名称：
  23.  *   CDib()
  24.  *
  25.  * 输入参数:
  26.  * 无
  27.  *
  28.  * 返回值:
  29.  *   无
  30.  *
  31.  * 说明:
  32.  *   构造函数
  33.  *
  34.  ************************************************************************
  35.  */
  36. CDib::CDib()
  37. {
  38. m_hFile      = NULL;
  39. m_hBitmap    = NULL;
  40. m_hPalette   = NULL;
  41. m_nBmihAlloc = m_nImageAlloc = noAlloc;
  42. Empty();
  43. }
  46. /*************************************************************************
  47.  *
  48.  * 函数名称：
  49.  *   CDib()
  50.  *
  51.  * 输入参数:
  52.  * CSize size - 位图尺寸
  53.  * int nBitCount - 象素位数
  54.  *
  55.  * 返回值:
  56.  *   无
  57.  *
  58.  * 说明:
  59.  *   构造函数
  60.  *   根据给定的位图尺寸和象素位数构造CDib对象，并对信息头和调色板分配内存
  61.  *   但并没有给位图数据分配内存
  62.  *
  63.  ************************************************************************
  64.  */
  65. CDib::CDib(CSize size, int nBitCount)
  66. {
  67. m_hFile      = NULL;
  68. m_hBitmap    = NULL;
  69. m_hPalette   = NULL;
  70. m_nBmihAlloc = m_nImageAlloc = noAlloc;
  71. Empty();
  73. // 根据象素位数计算调色板尺寸
  74. ComputePaletteSize(nBitCount);
  76. // 分配DIB信息头和调色板的内存
  77. m_lpBMIH = (LPBITMAPINFOHEADER) new 
  78. char[sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * m_nColorTableEntries];
  80. // 设置信息头内存分配状态
  81. m_nBmihAlloc = crtAlloc;
  83. // 设置信息头中的信息
  84. m_lpBMIH->biSize = sizeof(BITMAPINFOHEADER);
  85. m_lpBMIH->biWidth = size.cx;
  86. m_lpBMIH->biHeight = size.cy;
  87. m_lpBMIH->biPlanes = 1;
  88. m_lpBMIH->biBitCount = nBitCount;
  89. m_lpBMIH->biCompression = BI_RGB;
  90. m_lpBMIH->biSizeImage = 0;
  91. m_lpBMIH->biXPelsPerMeter = 0;
  92. m_lpBMIH->biYPelsPerMeter = 0;
  93. m_lpBMIH->biClrUsed = m_nColorTableEntries;
  94. m_lpBMIH->biClrImportant= m_nColorTableEntries;
  96. // 计算图象数据内存的大小，并设置此DIB的调色板的指针
  97. ComputeMetrics();
  99. // 将此DIB的调色板初始化为0
  100. memset(m_lpvColorTable, 0, sizeof(RGBQUAD) * m_nColorTableEntries);
  102. // 暂时不分配图象数据内存
  103. m_lpImage = NULL; 
  104. }
  107. /*************************************************************************
  108.  *
  109.  * 函数名称：
  110.  *   ~CDib()
  111.  *
  112.  * 输入参数:
  113.  * 无
  114.  *
  115.  * 返回值:
  116.  *   无
  117.  *
  118.  * 说明:
  119.  *   析构函数，并释放所有分配的DIB内存
  120.  *
  121.  ************************************************************************
  122.  */
  123. CDib::~CDib()
  124. {
  125. Empty();
  126. }
  129. /*************************************************************************
  130.  *
  131.  * 函数名称：
  132.  *   GetDimensions()
  133.  *
  134.  * 输入参数:
  135.  *   无
  136.  *
  137.  * 返回值:
  138.  *   CSize - DIB的宽度和高度
  139.  *
  140.  * 说明:
  141.  *   返回以象素表示的DIB的宽度和高度
  142.  *
  143.  ************************************************************************
  144.  */
  145. CSize CDib::GetDimensions()
  146. {
  147. if(m_lpBMIH == NULL) return CSize(0, 0);
  148. return CSize((int) m_lpBMIH->biWidth, (int) m_lpBMIH->biHeight);
  149. }
  152. /*************************************************************************
  153.  *
  154.  * 函数名称：
  155.  *   AttachMapFile()
  156.  *
  157.  * 输入参数:
  158.  *   const char* strPathname - 映射文件的路径名
  159.  *   BOOL bShare - 如果文件以共享形式打开，设置为TRUE
  160.  * - 默认值为FALSE
  161.  *
  162.  * 返回值:
  163.  *   BOOL - 如果成功，则为TRUE 
  164.  *
  165.  * 说明:
  166.  *   以读模式打开内存映射文件，并将其与CDib对象进行关联。因为在文件使用之前并没有读入内存，
  167.  *   所以它立即返回。不过，当访问这个DIB的时候，可能会有一些延迟，因为文件是分页的。
  168.  *   DetachMapFile函数可以释放现有的已分配的内存，并关闭以前关联的任何内存映射文件。
  169.  *   用内存中的DIB与已有的CDib对象关联。此内存可能是程序的资源，或者是可能是剪贴板
  170.  *   或者OLE数据对象内存。内存可能已经由CRT堆栈用new运算符分配了，或者可能已经由
  171.  *   Windows堆栈用GlobalAlloc分配了。
  172.  *   如果打开相同的文件两次，则Windows以另一个文件来对待 
  173.  *
  174.  ************************************************************************
  175.  */
  176. BOOL CDib::AttachMapFile(const char* strPathname, BOOL bShare) // for reading
  177. {
  178. // 获取文件句柄，并设置打开模式为共享
  179. HANDLE hFile = ::CreateFile(strPathname, GENERIC_WRITE | GENERIC_READ,
  180. bShare ? FILE_SHARE_READ : 0,
  181. NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
  182. ASSERT(hFile != INVALID_HANDLE_VALUE);
  184. // 获取文件的尺寸
  185. DWORD dwFileSize = ::GetFileSize(hFile, NULL);
  187. // 创建文件映射对象，并设置文件映射的模式为读写
  188. HANDLE hMap = ::CreateFileMapping(hFile, NULL, PAGE_READWRITE, 0, 0, NULL);
  189. DWORD dwErr = ::GetLastError();
  190. if(hMap == NULL) {
  191. AfxMessageBox("Empty bitmap file");
  192. return FALSE;
  193. }
  195. // 映射整个文件，注意FILE_MAP_WRITE为读写模式
  196. LPVOID lpvFile = ::MapViewOfFile(hMap, FILE_MAP_WRITE, 0, 0, 0); // map whole file
  197. ASSERT(lpvFile != NULL);
  199. // 确认为bmp格式文件
  200. if(((LPBITMAPFILEHEADER) lpvFile)->bfType != 0x4d42) {
  201. AfxMessageBox("Invalid bitmap file");
  202. DetachMapFile();
  203. return FALSE;
  204. }
  206. // 将内存中的DIB与已有的CDib对象关联
  207. AttachMemory((LPBYTE) lpvFile + sizeof(BITMAPFILEHEADER));
  209. // 将这些有用的句柄设置为类数据成员
  210. m_lpvFile = lpvFile;
  211. m_hFile   = hFile;
  212. m_hMap    = hMap;
  214. // 返回
  215. return TRUE;
  216. }
  219. /*************************************************************************
  220.  *
  221.  * 函数名称：
  222.  *   CopyToMapFile()
  223.  *
  224.  * 输入参数:
  225.  *   const char* strPathname - 映射文件的路径名
  226.  *
  227.  * 返回值:
  228.  *   BOOL - 如果成功，则为TRUE 
  229.  *
  230.  * 说明:
  231.  *   该函数可以创建一个新的内存映射文件，并将现有的CDib数据复制到该文件的内存
  232.  *   释放以前的所有内存。并关闭现有的所有内存映射文件。实际上，直到新文件
  233.  *   关闭的时候，才将这个数据写到磁盘，但是，当CDib对象被重复使用或被破坏
  234.  *   时，也会发生写磁盘操作
  235.  *
  236.  ************************************************************************
  237.  */
  238. BOOL CDib::CopyToMapFile(const char* strPathname)
  239. {
  240. BITMAPFILEHEADER bmfh;
  242. // 设置文件头信息
  243. bmfh.bfType = 0x4d42;  
  244. bmfh.bfSize = m_dwSizeImage + sizeof(BITMAPINFOHEADER) +
  245. sizeof(RGBQUAD) * m_nColorTableEntries + sizeof(BITMAPFILEHEADER);
  246. bmfh.bfReserved1= bmfh.bfReserved2 = 0;
  247. bmfh.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) +
  248. sizeof(RGBQUAD) * m_nColorTableEntries;
  250. // 创建接收数据的文件
  251. HANDLE hFile = ::CreateFile(strPathname, GENERIC_WRITE | GENERIC_READ, 0, NULL,
  252. CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
  253. ASSERT(hFile != INVALID_HANDLE_VALUE);
  255. // 计算文件的大小尺寸
  256. int nSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) +
  257. sizeof(RGBQUAD) * m_nColorTableEntries +  m_dwSizeImage;
  259. // 创建内存映射文件对象
  260. HANDLE hMap = ::CreateFileMapping(hFile, NULL, PAGE_READWRITE, 0, nSize, NULL);
  261. DWORD dwErr = ::GetLastError();
  262. ASSERT(hMap != NULL);
  264. // 映射整个文件
  265. LPVOID lpvFile = ::MapViewOfFile(hMap, FILE_MAP_WRITE, 0, 0, 0); 
  266. ASSERT(lpvFile != NULL);
  268. // 临时文件指针
  269. LPBYTE lpbCurrent = (LPBYTE) lpvFile;
  271. // 拷贝文件头信息到内存映射文件中
  272. memcpy(lpbCurrent, &bmfh, sizeof(BITMAPFILEHEADER)); 
  274. // 计算信息头在文件中的地址，并拷贝信息头信息
  275. lpbCurrent += sizeof(BITMAPFILEHEADER);
  276. LPBITMAPINFOHEADER lpBMIH = (LPBITMAPINFOHEADER) lpbCurrent;
  277. memcpy(lpbCurrent, m_lpBMIH,
  278. sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * m_nColorTableEntries); 
  280. // 计算调色板在文件中的地址，并拷贝调色板
  281. lpbCurrent += sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * m_nColorTableEntries;
  282. memcpy(lpbCurrent, m_lpImage, m_dwSizeImage); 
  284. // 暂时存放图象数据尺寸变量
  285. DWORD dwSizeImage = m_dwSizeImage;
  287. // 释放一起分配的所有内存
  288. Empty();
  290. // 设置图象数据尺寸并设置内存分配状态
  291. m_dwSizeImage = dwSizeImage;
  292. m_nBmihAlloc  = m_nImageAlloc = noAlloc;
  294. // 信息头指针重新指向文件中的位置
  295. m_lpBMIH = lpBMIH;
  297. // 图象数据指针重新指向文件中的数据地址
  298. m_lpImage = lpbCurrent;
  300. // 设置文件句柄
  301. m_hFile = hFile;
  303. // 设置映射对象句柄
  304. m_hMap = hMap;
  306. // 设置映射文件指针
  307. m_lpvFile = lpvFile;
  309. // 重新计算得到调色板尺寸
  310. ComputePaletteSize(m_lpBMIH->biBitCount);
  312. // 重新计算图象数据块大小，并设置调色板指针
  313. ComputeMetrics();
  315. // 如果调色板存在的话，读取并创建一个Windows调色板
  316. MakePalette();
  318. // 返回
  319. return TRUE;
  320. }
  323. /*************************************************************************
  324.  *
  325.  * 函数名称：
  326.  *   AttachMemory()
  327.  *
  328.  * 输入参数:
  329.  *   LPVOID lpvMem - 要关联的内存地址
  330.  *   BOOL bMustDelete - 如果CDib类负责删除这个内存，标记为TRUE
  331.  * - 默认值为FALSE
  332.  *   HGLOBAL hGlobal - 如果内存是通过Win32 GlobalAlloc得到的，
  333.  * - 则CDib对象必须保存该句柄，这样，以后
  334.  * - 可以释放句柄。这里假设bMustDelete设置为TRUE
  335.  *
  336.  * 返回值:
  337.  *   BOOL - 如果成功，则为TRUE 
  338.  *
  339.  * 说明:
  340.  *   用内存中的DIB与已有的CDib对象关联。此内存可能是程序的资源，或者是可能是剪贴板
  341.  *   或者OLE数据对象内存。内存可能已经由CRT堆栈用new运算符分配了，或者可能已经由
  342.  *   Windows堆栈用GlobalAlloc分配了。
  343.  *
  344.  ************************************************************************
  345.  */
  346. BOOL CDib::AttachMemory(LPVOID lpvMem, BOOL bMustDelete, HGLOBAL hGlobal)
  347. {
  348. // 首先释放已经分配的内存
  349. Empty();
  351. m_hGlobal = hGlobal;
  353. // bMustDelete为TRUE表示此CDib类分配的内存，负责删除
  354. // 否则的设置信息头分配状态为noAlloc
  355. if(bMustDelete == FALSE) {
  356. m_nBmihAlloc = noAlloc;
  357. }
  358. else {
  359. m_nBmihAlloc = ((hGlobal == NULL) ? crtAlloc : heapAlloc);
  360. }
  361. try {
  362. // 设置信息头指针
  363. m_lpBMIH = (LPBITMAPINFOHEADER) lpvMem;
  365. // 重新计算得到图象数据块的大小，并设置调色板的指针
  366. ComputeMetrics();
  368. // 计算调色板的尺寸
  369. ComputePaletteSize(m_lpBMIH->biBitCount);
  371. // 设置图象数据指针
  372. m_lpImage = (LPBYTE) m_lpvColorTable + sizeof(RGBQUAD) * m_nColorTableEntries;
  374. // 如果调色板存在的话，读取它，并创建一个Windows调色板，
  375. // 并将调色板的句柄存放在数据成员中
  376. MakePalette();
  377. }
  379. // 错误处理
  380. catch(CException* pe) {
  381. AfxMessageBox("AttachMemory error");
  382. pe->Delete();
  383. return FALSE;
  384. }
  386. // 返回
  387. return TRUE;
  388. }
  391. /*************************************************************************
  392.  *
  393.  * 函数名称：
  394.  *   UsePalette()
  395.  *
  396.  * 输入参数:
  397.  *   CDC* pDC - 要实现调色板的设备上下文指针
  398.  *   BOOL bBackground - 如果标记为FALSE（默认值），并且应用
  399.  * - 程序正在前台运行，则Windows将把该调
  400.  * - 色板作为前台调色板来实现（向系统调色
  401.  * - 板中复制尽可能多的颜色）。如果标记为
  402.  * - TURE，则Windows将把该调色板作为后台
  403.  * - 调色板来实现（尽可能相系统调色板映射
  404.  * - 逻辑调色板）
  405.  *
  406.  * 返回值:
  407.  *   UINT - 如果成功，则返回映射到系统调色板的逻
  408.  * - 辑调色板的表项数，否则返回GDI_ERROR 
  409.  *
  410.  * 说明:
  411.  *   该函数将CDib对象的逻辑调色板选入设备上下文，然后实现该调色板。Draw成员函
  412.  *   数在绘制DIB之前调用UsePalette。
  413.  *
  414.  ************************************************************************
  415.  */
  416. UINT CDib::UsePalette(CDC* pDC, BOOL bBackground /* = FALSE */)
  417. {
  418. // 判断是否存在调色板
  419. if(m_hPalette == NULL) return 0;
  421. // 得到设备上下文句柄
  422. HDC hdc = pDC->GetSafeHdc();
  424. // 选择调色板到设备上下文
  425. ::SelectPalette(hdc, m_hPalette, bBackground);
  427. // 实现该调色板
  428. return ::RealizePalette(hdc);
  429. }
  432. /*************************************************************************
  433.  *
  434.  * 函数名称：
  435.  *   Draw()
  436.  *
  437.  * 输入参数:
  438.  *   CDC* pDC - 指向将要接收DIB图象的设备上下文指针
  439.  *   CPoint origin - 显示DIB的逻辑坐标
  440.  *   CSize size - 显示矩形的宽度和高度
  441.  *
  442.  * 返回值:
  443.  *   BOOL - 如果成功，则为TRUE，
  444.  *
  445.  * 说明:
  446.  *   通过调用Win32 SDK的StretchDIBits函数将CDib对象输出到显示器（或者打印机）。
  447.  *   为了适合指定的矩形，位图可以进行必要的拉伸
  448.  *
  449.  ************************************************************************
  450.  */
  451. BOOL CDib::Draw(CDC* pDC, CPoint origin, CSize size)
  452. {
  453. // 如果信息头为空，表示尚未有数据，返回FALSE
  455. if(m_lpBMIH == NULL) return FALSE;
  457. // 如果调色板不为空，则将调色板选入设备上下文
  458. if(m_hPalette != NULL) {
  459. ::SelectPalette(pDC->GetSafeHdc(), m_hPalette, TRUE);
  461. }
  463. // 设置显示模式
  464. pDC->SetStretchBltMode(COLORONCOLOR);
  465.     
  466. // 在设备的origin位置上画出大小为size的图象
  467. ::StretchDIBits(pDC->GetSafeHdc(), origin.x, origin.y,size.cx,size.cy,
  468. 0, 0, m_lpBMIH->biWidth, m_lpBMIH->biHeight,
  469. m_lpImage, (LPBITMAPINFO) m_lpBMIH, DIB_RGB_COLORS, SRCCOPY);
  471. // 返回
  472. return TRUE;
  473. }
  476. /*************************************************************************
  477.  *
  478.  * 函数名称：
  479.  *   CreateSection()
  480.  *
  481.  * 输入参数:
  482.  *   CDC* pDC - 设备上下文指针
  483.  *
  484.  * 返回值:
  485.  *   HBITMAP - 到GDI位图的句柄。如果不成功，则为NULL。
  486.  * - 该句柄也是作为公共数据成员存储的
  487.  *
  488.  * 说明:
  489.  *   通过调用Win32 SDK的CreateDIBSection函数创建一个DIB段。图象内存将不被初始化
  490.  *
  491.  ************************************************************************
  492.  */
  493. HBITMAP CDib::CreateSection(CDC* pDC /* = NULL */)
  494. {
  495. // 如果信息头为空，不作任何处理
  496. if(m_lpBMIH == NULL) return NULL;
  498. // 如果图象数据不存在，不作任何处理
  499. if(m_lpImage != NULL) return NULL; 
  501. // 创建一个DIB段
  502. m_hBitmap = ::CreateDIBSection(pDC->GetSafeHdc(), (LPBITMAPINFO) m_lpBMIH,
  503. DIB_RGB_COLORS, (LPVOID*) &m_lpImage, NULL, 0);
  504. ASSERT(m_lpImage != NULL);
  506. // 返回HBIMAP句柄
  507. return m_hBitmap;
  508. }
  511. /*************************************************************************
  512.  *
  513.  * 函数名称：
  514.  *   MakePalette()
  515.  *
  516.  * 输入参数:
  517.  *   无
  518.  *
  519.  * 返回值:
  520.  *   BOOL - 如果成功，则为TRUE
  521.  *
  522.  * 说明:
  523.  *   如果颜色表存在的话，该函数将读取它，并创建一个Windows调色板。
  524.  *   HPALETTE存储在一个数据成员中。
  525.  *
  526.  ************************************************************************
  527.  */
  528. BOOL CDib::MakePalette()
  529. {
  530. // 如果不存在调色板，则返回FALSE
  531. if(m_nColorTableEntries == 0) return FALSE;
  533. if(m_hPalette != NULL) ::DeleteObject(m_hPalette);
  534. TRACE("CDib::MakePalette -- m_nColorTableEntries = %dn", m_nColorTableEntries);
  536. // 给逻辑调色板分配内存
  537. LPLOGPALETTE pLogPal = (LPLOGPALETTE) new char[2 * sizeof(WORD) +
  538. m_nColorTableEntries * sizeof(PALETTEENTRY)];
  540. // 设置逻辑调色板的信息
  541. pLogPal->palVersion = 0x300;
  542. pLogPal->palNumEntries = m_nColorTableEntries;
  544. // 拷贝DIB中的颜色表到逻辑调色板
  545. LPRGBQUAD pDibQuad = (LPRGBQUAD) m_lpvColorTable;
  546. for(int i = 0; i < m_nColorTableEntries; i++) {
  547. pLogPal->palPalEntry[i].peRed = pDibQuad->rgbRed;
  548. pLogPal->palPalEntry[i].peGreen = pDibQuad->rgbGreen;
  549. pLogPal->palPalEntry[i].peBlue = pDibQuad->rgbBlue;
  550. pLogPal->palPalEntry[i].peFlags = 0;
  551. pDibQuad++;
  552. }
  554. // 创建逻辑调色板
  555. m_hPalette = ::CreatePalette(pLogPal);
  557. // 删除临时变量并返回TRUE
  558. delete pLogPal;
  559. return TRUE;
  560. }
  563. /*************************************************************************
  564.  *
  565.  * 函数名称：
  566.  *   SetSystemPalette()
  567.  *
  568.  * 输入参数:
  569.  *   CDC* pDC - 设备上下文指针
  570.  *
  571.  * 返回值:
  572.  *   BOOL - 如果成功，则为TRUE，
  573.  *
  574.  * 说明:
  575.  *   如果16bpp、24bpp或32bppDIB不具备调色板，则该函数可以为CDib对象创建一个逻辑调色板，
  576.  *   它与由CreatehalftonePalette函数返回的调色板相匹配。如果程序在256色调色板显示器上
  577.  *   运行，而你又没有调用SetSystemPalette，那么，你将不具有任何调色板，只有20中标准的
  578.  *   Windows颜色出现在DIB中
  579.  *
  580.  ************************************************************************
  581.  */
  582. BOOL CDib::SetSystemPalette(CDC* pDC)
  583. {
  584. // 如果DIB不具备调色板，则需要利用系统的调色板
  585. if(m_nColorTableEntries != 0) return FALSE;
  587. // 为设备上下文创建中间调色板，并将其与CPalette对象连接
  588. m_hPalette = ::CreateHalftonePalette(pDC->GetSafeHdc());
  590. // 返回
  591. return TRUE;
  592. }
  595. /*************************************************************************
  596.  *
  597.  * 函数名称：
  598.  *   CreateBitmap()
  599.  *
  600.  * 输入参数:
  601.  *   CDC* pDC - 设备上下文指针
  602.  *
  603.  * 返回值:
  604.  *   HBITMAP - 到GDI位图的句柄；如果不成功，则为NULL
  605.  * - 该句柄不是作为公共数据成员存储的
  606.  *
  607.  * 说明:
  608.  *   从已有的DIB中创建DDB位图。不要将这个函数与CreateSection
  609.  *   弄混了，后者的作用是生成DIB并保存句柄
  610.  *
  611.  ************************************************************************
  612.  */
  613. HBITMAP CDib::CreateBitmap(CDC* pDC)
  614. {
  615. // 如果不存在图象数据，则返回NULL
  616. if (m_dwSizeImage == 0) return NULL;
  618. // 用指定的DIB来创建DDB，并用DIB信息初始化位图的图象位
  619. HBITMAP hBitmap = ::CreateDIBitmap(pDC->GetSafeHdc(), m_lpBMIH,
  620. CBM_INIT, m_lpImage, (LPBITMAPINFO) m_lpBMIH, DIB_RGB_COLORS);
  621. ASSERT(hBitmap != NULL);
  623. // 返回DDB位图句柄
  624. return hBitmap;
  625. }
  628. /*************************************************************************
  629.  *
  630.  * 函数名称：
  631.  *   ConvertDDBToDIB()
  632.  *
  633.  * 输入参数:
  634.  *   HBITMAP hBitmap - 指向源数据的BITMAP句柄
  635.  *   CDib* pDibDst - 指向转换目标的CDib对象指针
  636.  *
  637.  * 返回值:
  638.  *   BOOL - 如果操作成功，则返回TRUE
  639.  *
  640.  * 说明:
  641.  *   该函数将源BITMAP类pDibSrc中的数据拷贝到pDibDst中，并对相应的数据成员赋值
  642.  *
  643.  *************************************************************************
  644.  */
  646. BOOL CDib::ConvertFromDDB(HBITMAP hBitmap, HPALETTE hPal)
  647. {
  648. // 声明一个BITMAP结构
  649. BITMAP bm;
  651. // 设备上下文
  652. HDC hDC;
  654. // 象素位数
  655. WORD biBitCount;
  657. // 调色板表项数
  658. int nColorTableEntries;
  660. // 如果hBitmap句柄无效，则返回
  661. if(!hBitmap){
  662. return FALSE;
  663. }
  666. // 释放已分配的内存
  667. Empty();
  669. // 填充图象数据到bm中，其中最后一个参数表示接收这个指定的对象的指针
  670. if(!GetObject(hBitmap,sizeof(BITMAP),(LPBYTE)&bm)){
  671. return FALSE;
  672. }
  674. // 计算象素位数
  675. biBitCount=bm.bmPlanes*bm.bmBitsPixel;
  676. if(biBitCount<=1)
  677. biBitCount=1;
  678. else if(biBitCount<=4)
  679. biBitCount=4;
  680. else if(biBitCount<=8)
  681. biBitCount=8;
  682. else 
  683. biBitCount=24;
  685. // 计算调色板的尺寸
  686. // 如果biClrUsed为零，则用到的颜色数为2的biBitCount次方
  687. switch(biBitCount) {
  688. case 1:
  689. nColorTableEntries = 2;
  690. break;
  691. case 4:
  692. nColorTableEntries = 16;
  693. break;
  694. case 8:
  695. nColorTableEntries = 256;
  696. break;
  697. case 16:
  698. case 24:
  699. case 32:
  700. nColorTableEntries = 0;
  701. break;
  702. default:
  703. ASSERT(FALSE);
  704. }
  705. ASSERT((nColorTableEntries >= 0) && (nColorTableEntries <= 256)); 
  706. m_nColorTableEntries = nColorTableEntries;
  708. // 分配DIB信息头和调色板的内存
  709. m_lpBMIH = (LPBITMAPINFOHEADER) new char
  710. [sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * nColorTableEntries];
  711. m_nBmihAlloc = m_nImageAlloc = crtAlloc;
  713. m_lpBMIH->biSize = sizeof(BITMAPINFOHEADER); 
  714. m_lpBMIH->biWidth = bm.bmWidth; 
  715. m_lpBMIH->biHeight = bm.bmHeight; 
  716. m_lpBMIH->biPlanes = 1; 
  717. m_lpBMIH->biBitCount = biBitCount; 
  718. m_lpBMIH->biCompression = BI_RGB; 
  719. m_lpBMIH->biSizeImage = 0; 
  720. m_lpBMIH->biXPelsPerMeter = 0; 
  721. m_lpBMIH->biYPelsPerMeter = 0; 
  722. m_lpBMIH->biClrUsed = nColorTableEntries;
  723. m_lpBMIH->biClrImportant = nColorTableEntries;
  725. // 获得设备上下文句柄
  726. hDC=GetDC(NULL);
  727.    
  728. // 如果没有指定调色板，则从系统中获得当前的系统调色板
  729. if(hPal==NULL){
  730. hPal = GetSystemPalette();
  731. }
  732. hPal = SelectPalette(hDC, hPal, FALSE); 
  733. RealizePalette(hDC); 
  734.  
  736. // 调用GetDIBits填充信息头，并获得图象数据的尺寸。注意这里图象数据指针为NULL
  737. GetDIBits( hDC, hBitmap, 0, (UINT)m_lpBMIH->biHeight, NULL, (LPBITMAPINFO)m_lpBMIH, DIB_RGB_COLORS);
  739. // 如果没有正确的获得图象数据尺寸，则重新计算
  740. if( m_lpBMIH->biSizeImage == 0 ){
  741. m_lpBMIH->biSizeImage=(((bm.bmWidth*biBitCount) + 31) / 32 * 4)*bm.bmHeight;
  742. }
  744. // 分配存放图象数据的内存
  745. m_lpImage = (LPBYTE) new char[m_lpBMIH->biSizeImage];
  747. // 调用GetDIBits加载图象数据，注意这里给出了图象数据指针
  749. // 如果加载图象数据不成功，则释放已经分配的内存，并返回FALSE
  750. if( GetDIBits( hDC, hBitmap, 0, (UINT)m_lpBMIH->biHeight, (LPBYTE)m_lpImage,
  751. (LPBITMAPINFO)m_lpBMIH, DIB_RGB_COLORS) == 0 ){
  752. //clean up and return NULL
  753. Empty();
  755. SelectPalette( hDC, hPal, TRUE );
  756. RealizePalette( hDC );
  757. ReleaseDC( NULL, hDC );
  759. return FALSE;
  760. }
  762. // 删除临时变量
  763. SelectPalette(hDC, hPal, TRUE); 
  764. RealizePalette(hDC); 
  765. ReleaseDC(NULL, hDC); 
  766. return TRUE;
  767. }
  769. /*************************************************************************
  770.  *
  771.  * 函数名称：
  772.  *   Compress()
  773.  *
  774.  * 输入参数:
  775.  *   CDC* pDC - 设备上下文指针
  776.  *   BOOL bCompress - TRUE对应于压缩的DIB，FALSE对应于不压缩的DIB
  777.  *
  778.  * 返回值:
  779.  *   BOOL - 如果成功，则返回TRUE
  780.  *
  781.  * 说明:
  782.  *   该函数将DIB重新生成为压缩或者不压缩的DIB。在内部，它转换已有的DIB为DDB位图
  783.  *   然后生成一个新的压缩或者不压缩的DIB。压缩仅为4bpp和8bpp的DIB所支持。不能
  784.  *   压缩DIB段
  785.  *
  786.  ************************************************************************
  787.  */
  788. BOOL CDib::Compress(CDC* pDC, BOOL bCompress /* = TRUE */)
  789. {
  790. // 判断是否为4bpp或者8bpp位图，否则，不进行压缩，返回FALSE
  791. if((m_lpBMIH->biBitCount != 4) && (m_lpBMIH->biBitCount != 8)) return FALSE;
  793. // 如果为DIB段，也不能支持压缩，返回FALSE
  794. if(m_hBitmap) return FALSE; 
  796. TRACE("Compress: original palette size = %dn", m_nColorTableEntries); 
  798. // 获得设备上下文句柄
  799. HDC hdc = pDC->GetSafeHdc();
  801. // 将此DIB的调色板选入设备上下文，并保存以前的调色板句柄
  802. HPALETTE hOldPalette = ::SelectPalette(hdc, m_hPalette, FALSE);
  804. HBITMAP hBitmap;  
  806. // 创建一个DDB位图，如果不成功，则返回FALSE
  807. if((hBitmap = CreateBitmap(pDC)) == NULL) return FALSE;
  809. // 计算信息头加上调色板的大小尺寸，并给它们分配内存
  810. int nSize = sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * m_nColorTableEntries;
  811. LPBITMAPINFOHEADER lpBMIH = (LPBITMAPINFOHEADER) new char[nSize];
  813. // 将信息头和调色板拷贝到内存中
  814. memcpy(lpBMIH, m_lpBMIH, nSize);  // new header
  816. // 如果需要进行压缩，设置相应的信息，并创建压缩格式的DIB
  817. if(bCompress) {
  818. switch (lpBMIH->biBitCount) {
  819. case 4:
  820. lpBMIH->biCompression = BI_RLE4;
  821. break;
  822. case 8:
  823. lpBMIH->biCompression = BI_RLE8;
  824. break;
  825. default:
  826. ASSERT(FALSE);
  827. }
  829. // 设置位图数据指针为NULL，调用GetDIBits来得到压缩格式的DIB的尺寸
  830. // 如果不能创建DIB，则进行相应的错误处理。
  831. if(!::GetDIBits(pDC->GetSafeHdc(), hBitmap, 0, (UINT) lpBMIH->biHeight,
  832. NULL, (LPBITMAPINFO) lpBMIH, DIB_RGB_COLORS)) {
  833. AfxMessageBox("Unable to compress this DIB");
  835. // 删除临时变量，并释放已分配内存
  836.   ::DeleteObject(hBitmap);
  837. delete [] lpBMIH;
  839. // 重新将以前的调色板选入，并返回FALSE
  840. ::SelectPalette(hdc, hOldPalette, FALSE);
  841. return FALSE; 
  842. }
  844. // 如果位图数据为空，则进行相应的错误处理
  845. if (lpBMIH->biSizeImage == 0) {
  846. AfxMessageBox("Driver can't do compression");
  848. // 删除临时变量，并释放已分配内存
  849.   ::DeleteObject(hBitmap);
  850. delete [] lpBMIH;
  852. // 重新将以前的调色板选入，并返回FALSE
  853. ::SelectPalette(hdc, hOldPalette, FALSE);
  854. return FALSE; 
  855. }
  857. // 将位图数据尺寸赋值给类的成员变量
  858. else {
  859. m_dwSizeImage = lpBMIH->biSizeImage;
  860. }
  861. }
  863. // 如果是解压缩，进行相应的处理
  864. else {
  866. // 设置压缩格式为不压缩
  867. lpBMIH->biCompression = BI_RGB; 
  869. // 根据位图的宽度和高度计算位图数据内存的大小
  870. DWORD dwBytes = ((DWORD) lpBMIH->biWidth * lpBMIH->biBitCount) / 32;
  871. if(((DWORD) lpBMIH->biWidth * lpBMIH->biBitCount) % 32) {
  872. dwBytes++;
  873. }
  874. dwBytes *= 4;
  876. // 将得到位图数据的大小尺寸保存在类的成员变量中
  877. m_dwSizeImage = dwBytes * lpBMIH->biHeight; 
  879. // 将位图数据内存的大小赋值给临时的信息头中的相应的变量
  880. lpBMIH->biSizeImage = m_dwSizeImage;
  881. } 
  883. // 再次调用GetDIBits来生成DIB数据
  885. // 分配临时存放位图数据
  886. LPBYTE lpImage = (LPBYTE) new char[m_dwSizeImage];
  888. // 再次调用GetDIBits来生成DIB数据，注意此时位图数据指针不为空
  889. VERIFY(::GetDIBits(pDC->GetSafeHdc(), hBitmap, 0, (UINT) lpBMIH->biHeight,
  890.      lpImage, (LPBITMAPINFO) lpBMIH, DIB_RGB_COLORS));
  891. TRACE("dib successfully created - height = %dn", lpBMIH->biHeight);
  893. // 压缩转换完毕，进行相应的其他处理
  895. // 删除临时的DDB位图
  896. ::DeleteObject(hBitmap);
  898. // 释放原来的DIB分配的内存
  899. Empty();
  901. // 重新设置图象信息头和图象数据内存分配状态
  902. m_nBmihAlloc = m_nImageAlloc = crtAlloc;
  904. // 重新定位信息头和图象数据指针
  905. m_lpBMIH = lpBMIH;
  906. m_lpImage = lpImage;
  908. // 计算图象数据尺寸，并设置DIB中调色板的指针
  909. ComputeMetrics();
  911. // 计算DIB中调色板的尺寸
  912. ComputePaletteSize(m_lpBMIH->biBitCount);
  914. // 如果DIB中调色板存在的话，读取并创建一个Windows调色板
  915. MakePalette();
  917. // 恢复以前的调色板
  918. ::SelectPalette(hdc, hOldPalette, FALSE);
  919. TRACE("Compress: new palette size = %dn", m_nColorTableEntries); 
  921. // 返回
  922. return TRUE;
  923. }
  926. /*************************************************************************
  927.  *
  928.  * 函数名称：
  929.  *   Read()
  930.  *
  931.  * 输入参数:
  932.  *   CFile* pFile - 指向CFile对象的指针
  933.  *
  934.  * 返回值:
  935.  *   BOOL - 如果成功，则返回TRUE
  936.  *
  937.  * 说明:
  938.  *   该函数DIB从一个文件读入CDib对象。该文件必须成功打开。如果该文件是BMP文件
  939.  *   读取工作从文件头开始。如果该文件是一个文档，读取工作则从当前文件指针处开始 
  940.  *
  941.  ************************************************************************
  942.  */
  943. BOOL CDib::Read(CFile* pFile)
  944. {
  945. // 释放已经分配的内存
  946. Empty();
  948. // 临时存放信息的变量
  949. int nCount, nSize;
  950. BITMAPFILEHEADER bmfh;
  952. // 进行读操作
  953. try 
  954. {
  955. // 读取文件头
  956. nCount = pFile->Read((LPVOID) &bmfh, sizeof(BITMAPFILEHEADER));
  957. if(nCount != sizeof(BITMAPFILEHEADER)) {
  958. throw new CException;
  959. }
  961. // 如果文件类型部位"BM"，则返回并进行相应错误处理
  962. if(bmfh.bfType != 0x4d42) {
  963. throw new CException;
  964. }
  966. // 计算信息头加上调色板的大小，并分配相应的内存
  967. nSize = bmfh.bfOffBits - sizeof(BITMAPFILEHEADER);
  968. m_lpBMIH = (LPBITMAPINFOHEADER) new char[nSize];
  969. m_nBmihAlloc = m_nImageAlloc = crtAlloc;
  971. // 读取信息头和调色板
  972. nCount = pFile->Read(m_lpBMIH, nSize); 
  974. // 计算图象数据大小并设置调色板指针
  975. ComputeMetrics();
  977. // 计算调色板的表项数
  978. ComputePaletteSize(m_lpBMIH->biBitCount);
  980. // 如果DIB中存在调色板，则创建一个Windows调色板
  981. MakePalette();
  983. // 分配图象数据内存，并从文件中读取图象数据
  984. m_lpImage = (LPBYTE) new char[m_dwSizeImage];
  985. nCount = pFile->Read(m_lpImage, m_dwSizeImage); 
  986. }
  988. // 错误处理
  989. catch(CException* pe) 
  990. {
  991. AfxMessageBox("Read error");
  992. pe->Delete();
  993. return FALSE;
  994. }
  996. // 返回
  997. return TRUE;
  998. }
  1001. /*************************************************************************
  1002.  *
  1003.  * 函数名称：
  1004.  *   ReadSection()
  1005.  *
  1006.  * 输入参数:
  1007.  *   CFile* pFile - 指向CFile对象的指针；对应的磁盘
  1008.  * - 文件中包含DIB
  1009.  *   CDC* pDC - 设备上下文指针
  1010.  *
  1011.  * 返回值:
  1012.  *   BOOL - 如果成功，则返回TRUE
  1013.  *
  1014.  * 说明:
  1015.  *   该函数从BMP文件中读取信息头，调用CreateDIBSection来分配图象内存，然后将
  1016.  *   图象从该文件读入刚才分配的内存。如果你想从磁盘读取一个DIB，然后通过调用
  1017.  *   GDI函数编辑它的话，可以使用该函数。你可以用Write或CopyToMapFile将DIB写
  1018.  *   回到磁盘
  1019.  *
  1020.  ************************************************************************
  1021.  */
  1022. BOOL CDib::ReadSection(CFile* pFile, CDC* pDC /* = NULL */)
  1023. {
  1025. // 释放已经分配的内存
  1026. Empty();
  1028. // 临时变量
  1029. int nCount, nSize;
  1030. BITMAPFILEHEADER bmfh;
  1032. // 从文件中读取数据
  1033. try {
  1034. // 读取文件头
  1035. nCount = pFile->Read((LPVOID) &bmfh, sizeof(BITMAPFILEHEADER));
  1036. if(nCount != sizeof(BITMAPFILEHEADER)) {
  1037. throw new CException;
  1038. }
  1040. // 如果文件类型部位"BM"，则返回并进行相应错误处理
  1041. if(bmfh.bfType != 0x4d42) {
  1042. throw new CException;
  1043. }
  1045. // 计算信息头加上调色板的大小，并分配相应的内存
  1046. nSize = bmfh.bfOffBits - sizeof(BITMAPFILEHEADER);
  1047. m_lpBMIH = (LPBITMAPINFOHEADER) new char[nSize];
  1048. m_nBmihAlloc = crtAlloc;
  1049. m_nImageAlloc = noAlloc;
  1051. // 读取信息头和调色板
  1052. nCount = pFile->Read(m_lpBMIH, nSize); 
  1054. // 如果图象为压缩格式，则不进行后续处理
  1055. if(m_lpBMIH->biCompression != BI_RGB) {
  1056. throw new CException;
  1057. }
  1059. // 计算图象数据大小并设置调色板指针
  1060. ComputeMetrics();
  1062. // 计算调色板的表项数
  1063. ComputePaletteSize(m_lpBMIH->biBitCount);
  1065. // 如果DIB中存在调色板，则创建一个Windows调色板
  1066. MakePalette();
  1068. // 将CDib对象的逻辑调色板选入设备上下文
  1069. UsePalette(pDC);
  1071. // 创建一个DIB段，并分配图象内存
  1072. m_hBitmap = ::CreateDIBSection(pDC->GetSafeHdc(), (LPBITMAPINFO) m_lpBMIH,
  1073. DIB_RGB_COLORS, (LPVOID*) &m_lpImage, NULL, 0);
  1074. ASSERT(m_lpImage != NULL);
  1076. // 从文件中读取图象数据
  1077. nCount = pFile->Read(m_lpImage, m_dwSizeImage); 
  1078. }
  1080. // 错误处理
  1081. catch(CException* pe) {
  1082. AfxMessageBox("ReadSection error");
  1083. pe->Delete();
  1084. return FALSE;
  1085. }
  1086. return TRUE;
  1087. }
  1090. /*************************************************************************
  1091.  *
  1092.  * 函数名称：
  1093.  *   Write()
  1094.  *
  1095.  * 输入参数:
  1096.  *   CFile* pFile - 指向CFile对象的指针
  1097.  *
  1098.  * 返回值:
  1099.  *   BOOL - 如果成功，则返回TRUE
  1100.  *
  1101.  * 说明:
  1102.  *   该函数把DIB从CDib对象写进文件中。该文件必须成功打开或者创建
  1103.  *
  1104.  ************************************************************************
  1105.  */
  1106. BOOL CDib::Write(CFile* pFile)
  1107. {
  1108. BITMAPFILEHEADER bmfh;
  1110. // 设置文件头中文件类型为"BM"
  1111. bmfh.bfType = 0x4d42;  
  1113. // 计算信息头和调色板的大小尺寸
  1114. int nSizeHdr = sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * m_nColorTableEntries;
  1116. // 设置文件头信息
  1117. bmfh.bfSize = sizeof(BITMAPFILEHEADER) + nSizeHdr + m_dwSizeImage;
  1118. bmfh.bfReserved1 = bmfh.bfReserved2 = 0;
  1119. bmfh.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) +
  1120. sizeof(RGBQUAD) * m_nColorTableEntries;
  1122. // 进行写操作
  1123. try {
  1124. pFile->Write((LPVOID) &bmfh, sizeof(BITMAPFILEHEADER));
  1125. pFile->Write((LPVOID) m_lpBMIH,  nSizeHdr);
  1126. pFile->Write((LPVOID) m_lpImage, m_dwSizeImage);
  1127. }
  1129. // 错误处理
  1130. catch(CException* pe) {
  1131. pe->Delete();
  1132. AfxMessageBox("write error");
  1133. return FALSE;
  1134. }
  1136. // 返回
  1137. return TRUE;
  1138. }
  1141. /*************************************************************************
  1142.  *
  1143.  * 函数名称：
  1144.  *   Serialize()
  1145.  *
  1146.  * 输入参数:
  1147.  *   CArchive& ar - 指向应用程序归档对象
  1148.  *
  1149.  * 返回值:
  1150.  *   无
  1151.  *
  1152.  * 说明:
  1153.  *   该函数进行串行化过程，将CDib数据进行读入或者写出
  1154.  *
  1155.  ************************************************************************
  1156.  */
  1157. void CDib::Serialize(CArchive& ar)
  1158. {
  1159. DWORD dwPos;
  1161. // 获得此归档文件的CFile对象指针
  1162. dwPos = ar.GetFile()->GetPosition();
  1163. TRACE("CDib::Serialize -- pos = %dn", dwPos);
  1165. // 从归档文件缓冲区中冲掉未写入数据
  1166. ar.Flush();
  1168. // 重新获得此归档文件的CFile对象指针
  1169. dwPos = ar.GetFile()->GetPosition();
  1170. TRACE("CDib::Serialize -- pos = %dn", dwPos);
  1172. // 确定归档文件是否被存储，是则进行存储
  1173. if(ar.IsStoring()) {
  1174. Write(ar.GetFile());
  1175. }
  1177. // 否则进行加载
  1178. else {
  1179. Read(ar.GetFile());
  1180. }
  1181. }
  1184. /*************************************************************************
  1185.  *
  1186.  * 函数名称：
  1187.  *   ComputePaletteSize()
  1188.  *
  1189.  * 输入参数:
  1190.  *   int nBitCount - 指向CFile对象的指针
  1191.  *
  1192.  * 返回值:
  1193.  *   无
  1194.  *
  1195.  * 说明:
  1196.  *   该函数根据位图象素位数计算调色板的尺寸
  1197.  *
  1198.  ************************************************************************
  1199.  */
  1200. void CDib::ComputePaletteSize(int nBitCount)
  1201. {
  1202. // 如果biClrUsed为零，则用到的颜色数为2的biBitCount次方
  1203. if((m_lpBMIH == NULL) || (m_lpBMIH->biClrUsed == 0)) {
  1204. switch(nBitCount) {
  1205. case 1:
  1206. m_nColorTableEntries = 2;
  1207. break;
  1208. case 4:
  1209. m_nColorTableEntries = 16;
  1210. break;
  1211. case 8:
  1212. m_nColorTableEntries = 256;
  1213. break;
  1214. case 16:
  1215. case 24:
  1216. case 32:
  1217. m_nColorTableEntries = 0;
  1218. break;
  1219. default:
  1220. ASSERT(FALSE);
  1221. }
  1222. }
  1224. // 否则调色板的表项数就是用到的颜色数目
  1225. else {
  1226. m_nColorTableEntries = m_lpBMIH->biClrUsed;
  1227. }
  1229. ASSERT((m_nColorTableEntries >= 0) && (m_nColorTableEntries <= 256)); 
  1230. }
  1233. /*************************************************************************
  1234.  *
  1235.  * 函数名称：
  1236.  *   ComputeMetrics()
  1237.  *
  1238.  * 输入参数:
  1239.  *   无
  1240.  *
  1241.  * 返回值:
  1242.  *   无
  1243.  *
  1244.  * 说明:
  1245.  *   该函数计算图象位图的尺寸，并对DIB中的调色板的指针进行赋值
  1246.  *
  1247.  ************************************************************************
  1248.  */
  1249. void CDib::ComputeMetrics()
  1250. {
  1251. // 如果结构的长度不对，则进行错误处理
  1252. if(m_lpBMIH->biSize != sizeof(BITMAPINFOHEADER)) {
  1253. TRACE("Not a valid Windows bitmap -- probably an OS/2 bitmapn");
  1254. throw new CException;
  1255. }
  1257. // 保存图象数据内存大小到CDib对象的数据成员中
  1258. m_dwSizeImage = m_lpBMIH->biSizeImage;
  1260. // 如果图象数据内存大小为0，则重新计算
  1261. if(m_dwSizeImage == 0) {
  1262. DWORD dwBytes = ((DWORD) m_lpBMIH->biWidth * m_lpBMIH->biBitCount) / 32;
  1263. if(((DWORD) m_lpBMIH->biWidth * m_lpBMIH->biBitCount) % 32) {
  1264. dwBytes++;
  1265. }
  1266. dwBytes *= 4;
  1267. m_dwSizeImage = dwBytes * m_lpBMIH->biHeight;
  1268. }
  1270. // 设置DIB中的调色板指针
  1271. m_lpvColorTable = (LPBYTE) m_lpBMIH + sizeof(BITMAPINFOHEADER);
  1272. }
  1275. /*************************************************************************
  1276.  *
  1277.  * 函数名称：
  1278.  *   Empty()
  1279.  *
  1280.  * 输入参数:
  1281.  *   无
  1282.  *
  1283.  * 返回值:
  1284.  *   无
  1285.  *
  1286.  * 说明:
  1287.  *   该函数清空DIB，释放已分配的内存，并且必要的时候关闭映射文件
  1288.  *
  1289.  ************************************************************************
  1290.  */
  1291. void CDib::Empty()
  1292. {
  1293. // 关闭内存映射文件的连接
  1294. DetachMapFile();
  1296. // 根据内存分配的状态，调用相应的函数释放信息头
  1297. if(m_nBmihAlloc == crtAlloc) {
  1298. delete [] m_lpBMIH;
  1299. }
  1300. else if(m_nBmihAlloc == heapAlloc) {
  1301. ::GlobalUnlock(m_hGlobal);
  1302. ::GlobalFree(m_hGlobal);
  1303. }
  1305. // 释放图象数据内存
  1306. if(m_nImageAlloc == crtAlloc) delete [] m_lpImage;
  1308. // 释放调色板句柄
  1309. if(m_hPalette != NULL) ::DeleteObject(m_hPalette);
  1311. // 如果创建了BITMAP，则进行释放
  1312. if(m_hBitmap != NULL) ::DeleteObject(m_hBitmap);
  1314. // 重新设置内存分配状态
  1315. m_nBmihAlloc = m_nImageAlloc = noAlloc;
  1317. // 释放内存后，还需要将指针设置为NULL并将相应的数据设置为0
  1318. m_hGlobal = NULL;
  1319. m_lpBMIH = NULL;
  1320. m_lpImage = NULL;
  1321. m_lpvColorTable = NULL;
  1322. m_nColorTableEntries = 0;
  1323. m_dwSizeImage = 0;
  1324. m_lpvFile = NULL;
  1325. m_hMap = NULL;
  1326. m_hFile = NULL;
  1327. m_hBitmap = NULL;
  1328. m_hPalette = NULL;
  1329. }
  1332. /*************************************************************************
  1333.  *
  1334.  * 函数名称：
  1335.  *   DetachMapFile()
  1336.  *
  1337.  * 输入参数:
  1338.  *   无
  1339.  *
  1340.  * 返回值:
  1341.  *   无
  1342.  *
  1343.  * 说明:
  1344.  *   函数可以释放现有的已分配的内存，并关闭以前关联的任何内存映射文件。
  1345.  *
  1346.  ************************************************************************
  1347.  */
  1348. void CDib::DetachMapFile()
  1349. {
  1350. // 如果没有进行内存映射，则不进行处理
  1351. if(m_hFile == NULL) return;
  1353. // 关闭内存映射
  1354. ::UnmapViewOfFile(m_lpvFile);
  1356. // 关闭内存映射对象和文件
  1357. ::CloseHandle(m_hMap);
  1358. ::CloseHandle(m_hFile);
  1359. m_hFile = NULL;
  1360. }
  1363. /*************************************************************************
  1364.  *
  1365.  * 函数名称：
  1366.  *   PaletteSize()
  1367.  *
  1368.  * 输入参数:
  1369.  *   无
  1370.  *
  1371.  * 返回值:
  1372.  *   DWORD - 返回调色板的尺寸
  1373.  *
  1374.  * 说明:
  1375.  *   该函数计算机调色板所需的尺寸
  1376.  *
  1377.  ************************************************************************
  1378.  */
  1379. WORD CDib::PaletteSize()
  1380. {
  1381. // 临时变量
  1382. WORD        NumColors;
  1383. LPBITMAPINFOHEADER lpbi=m_lpBMIH;
  1385. // 如果biClrUsed为零，且图象象素位数小于等于8，则计算调色板用到的表项数
  1386. NumColors =  ((lpbi)->biClrUsed == 0 && (lpbi)->biBitCount <= 8 
  1387.                                     ? (int)(1 << (int)(lpbi)->biBitCount)          
  1388.                                     : (int)(lpbi)->biClrUsed);
  1390. // 根据颜色表示的字节数计算调色板的尺寸
  1391. if (lpbi->biSize == sizeof(BITMAPCOREHEADER))
  1392. return NumColors * sizeof(RGBTRIPLE);
  1393. else 
  1394. return NumColors * sizeof(RGBQUAD);
  1396. }
  1399. /*************************************************************************
  1400.  *
  1401.  * 函数名称：
  1402.  *   IsEmpty()
  1403.  *
  1404.  * 输入参数:
  1405.  *   无
  1406.  *
  1407.  * 返回值:
  1408.  *   BOOL - 如果信息头和图象数据为空，则返回TRUE
  1409.  *
  1410.  * 说明:
  1411.  *   判断信息头和图象数据是否为空
  1412.  *
  1413.  ************************************************************************
  1414.  */
  1415. BOOL CDib::IsEmpty()
  1416. {
  1418. if( m_lpBMIH == NULL&&m_lpImage == NULL)
  1419. return TRUE;
  1420. else
  1421. return FALSE;
  1423. }
  1426. /*************************************************************************
  1427.  *
  1428.  * 函数名称：
  1429.  *   GetDibSaveDim()
  1430.  *
  1431.  * 输入参数:
  1432.  *   无
  1433.  *
  1434.  * 返回值:
  1435.  *   CSize - DIB实际存储的高度和宽度
  1436.  *
  1437.  * 说明:
  1438.  *   该函数函数用来得到dib的实际存储宽度（DWORD对齐）
  1439.  *
  1440.  ************************************************************************
  1441.  */
  1443. CSize CDib::GetDibSaveDim()
  1444. {
  1445. CSize sizeSaveDim;
  1446. sizeSaveDim.cx = ( m_lpBMIH->biWidth * m_lpBMIH->biBitCount + 31)/32 * 4;
  1447. sizeSaveDim.cy = m_lpBMIH->biHeight; 
  1448. return sizeSaveDim;
  1450. }
  1453. /*************************************************************************
  1454.  *
  1455.  * 函数名称：
  1456.  *   GetPixelOffset()
  1457.  *
  1458.  * 输入参数:
  1459.  *   int x - 象素在X轴的坐标
  1460.  *   int y - 象素在Y轴的坐标
  1461.  *
  1462.  * 返回值:
  1463.  *   int - 返回象素在图象数据块中的真实地址
  1464.  *
  1465.  * 说明:
  1466.  *   该函数得到坐标为(x,y)的象素点的真实地址。由于DIB结构中对图象数据排列的
  1467.  *   方式为从下到上，从左到右的，所以需要进行转换。
  1468.  *
  1469.  ************************************************************************
  1470.  */
  1471. LONG CDib::GetPixelOffset(int  x, int y)
  1472. {
  1473. CSize sizeSaveDim;
  1474. sizeSaveDim = GetDibSaveDim();
  1476. LONG lOffset = (LONG) (sizeSaveDim.cy - y - 1) * sizeSaveDim.cx +
  1477. x  / (8 / m_lpBMIH->biBitCount);
  1478. return lOffset;
  1479. }
  1482. /*************************************************************************
  1483.  *
  1484.  * 函数名称：
  1485.  *   GetPixel()
  1486.  *
  1487.  * 输入参数:
  1488.  *   int x - 象素在X轴的坐标
  1489.  *   int y - 象素在Y轴的坐标
  1490.  *
  1491.  * 返回值:
  1492.  *   RGBQUAD - 返回DIB在该点真实的颜色
  1493.  *
  1494.  * 说明:
  1495.  *   该函数得到DIB图象在该点真是的颜色。
  1496.  *
  1497.  ************************************************************************
  1498.  */
  1499. RGBQUAD CDib::GetPixel(int x, int y)
  1500. {
  1501. // 颜色结构
  1502. RGBQUAD cColor;
  1504. // 根据每象素比特数得到此点的象素值
  1505. switch (m_lpBMIH->biBitCount)
  1506. {
  1507. case 1 :
  1508. if (1<<(7-x%8) & *(LPBYTE)(m_lpImage+GetPixelOffset(x, y)))
  1509. {
  1510. cColor.rgbBlue  = 255;
  1511. cColor.rgbGreen = 255;
  1512. cColor.rgbRed   = 255;
  1513. cColor.rgbReserved =0;
  1514. }
  1515. else
  1516. {
  1517. cColor.rgbBlue  = 0;
  1518. cColor.rgbGreen = 0;
  1519. cColor.rgbRed   = 0;
  1520. cColor.rgbReserved =0;
  1521. }
  1522. break;
  1523. case 4 :
  1524. {
  1525. int nIndex = (*(LPBYTE)(m_lpImage+GetPixelOffset(x, y)) & 
  1526.    (x%2 ? 0x0f : 0xf0)) >> (x%2 ? 0 : 4);
  1527. LPRGBQUAD pDibQuad = (LPRGBQUAD) (m_lpvColorTable) + nIndex;
  1528. cColor.rgbBlue  = pDibQuad->rgbBlue;
  1529. cColor.rgbGreen = pDibQuad->rgbGreen;
  1530. cColor.rgbRed   = pDibQuad->rgbRed;
  1531. cColor.rgbReserved =0;
  1532. }
  1533. break;
  1534. case 8 :
  1535. {
  1536. int nIndex = *(BYTE*)(m_lpImage+GetPixelOffset(x, y));
  1537. LPRGBQUAD pDibQuad = (LPRGBQUAD) (m_lpvColorTable) + nIndex;
  1538. cColor.rgbBlue  = pDibQuad->rgbBlue;
  1539. cColor.rgbGreen = pDibQuad->rgbGreen;
  1540. cColor.rgbRed   = pDibQuad->rgbRed;
  1541. cColor.rgbReserved =0;
  1542. }
  1543. break;
  1544. default:
  1545. int nIndex = *(BYTE*)(m_lpImage+GetPixelOffset(x, y));
  1546. cColor.rgbRed   = m_lpImage[nIndex];
  1547. cColor.rgbGreen = m_lpImage[nIndex + 1];
  1548. cColor.rgbBlue  = m_lpImage[nIndex + 2];
  1549. cColor.rgbReserved =0;
  1550. break;
  1551. }
  1553. // 返回颜色结构
  1554. return cColor;
  1555. }