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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 图片显示 > 查看源码
CqOctree.cpp
资源名称：QuickImage.rar　[点击查看]
上传用户：gzboli
上传日期：2013-04-10
资源大小：471k
文件大小：5k
源码类别：

图片显示

开发平台：

Visual C++

CqOctree.cpp：源码内容
  1. // CqOctree.cpp: implementation of the CCqOctree class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "QuickImage.h"
  7. #include "CqOctree.h"
  9. #ifdef _DEBUG
  10. #undef THIS_FILE
  11. static char THIS_FILE[]=__FILE__;
  12. #define new DEBUG_NEW
  13. #endif
  15. //////////////////////////////////////////////////////////////////////
  16. // Construction/Destruction
  17. //////////////////////////////////////////////////////////////////////
  19. // local function to add a color to octree
  20. void AddColor (NODE** ppNode, BYTE r, BYTE g, BYTE b, UINT nColorBits,
  21.     UINT nLevel, UINT* pLeafCount, NODE** pReducibleNodes)
  22. {
  23.     int nIndex, shift;
  24.     static BYTE mask[8] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 };
  26.     // If the node doesn't exist, create it
  27.     if (*ppNode == NULL)
  28.         *ppNode = CreateNode (nLevel, nColorBits, pLeafCount,
  29.                               pReducibleNodes);
  31.     // Update color information if it's a leaf node
  32.     if ((*ppNode)->bIsLeaf) {
  33.         (*ppNode)->nPixelCount++;
  34.         (*ppNode)->nRedSum += r;
  35.         (*ppNode)->nGreenSum += g;
  36.         (*ppNode)->nBlueSum += b;
  37.     }
  39.     // Recurse a level deeper if the node is not a leaf
  40.     else {
  41.         shift = 7 - nLevel;
  42.         nIndex = (((r & mask[nLevel]) >> shift) << 2) |
  43.             (((g & mask[nLevel]) >> shift) << 1) |
  44.             ((b & mask[nLevel]) >> shift);
  45.         AddColor (&((*ppNode)->pChild[nIndex]), r, g, b, nColorBits,
  46.                   nLevel + 1, pLeafCount, pReducibleNodes);
  47.     }
  48. }
  50. // local function to create a new node in octree
  51. NODE* CreateNode (UINT nLevel, UINT nColorBits, UINT* pLeafCount,
  52.                   NODE** pReducibleNodes)
  53. {
  54.     NODE* pNode;
  56.     if ((pNode = (NODE*) HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY,
  57.         sizeof (NODE))) == NULL)
  58.         return NULL;
  60.     pNode->bIsLeaf = (nLevel == nColorBits) ? TRUE : FALSE;
  61.     if (pNode->bIsLeaf)
  62.         (*pLeafCount)++;
  63.     else { // Add the node to the reducible list for this level
  64.         pNode->pNext = pReducibleNodes[nLevel];
  65.         pReducibleNodes[nLevel] = pNode;
  66.     }
  67.     return pNode;
  68. }
  70. // local function to reduce the nodes of octree
  71. void ReduceTree (UINT nColorBits, UINT* pLeafCount, NODE** pReducibleNodes)
  72. {
  73.     int i;
  74.     NODE* pNode;
  75.     UINT nRedSum, nGreenSum, nBlueSum, nChildren;
  77.     // Find the deepest level containing at least one reducible node
  78.     for (i=nColorBits - 1; (i>0) && (pReducibleNodes[i] == NULL); i--);
  80.     // Reduce the node most recently added to the list at level i
  81.     pNode = pReducibleNodes[i];
  82.     pReducibleNodes[i] = pNode->pNext;
  84.     nRedSum = nGreenSum = nBlueSum = nChildren = 0;
  85.     for (i=0; i<8; i++) {
  86.         if (pNode->pChild[i] != NULL) {
  87.             nRedSum += pNode->pChild[i]->nRedSum;
  88.             nGreenSum += pNode->pChild[i]->nGreenSum;
  89.             nBlueSum += pNode->pChild[i]->nBlueSum;
  90.             pNode->nPixelCount += pNode->pChild[i]->nPixelCount;
  91.             HeapFree (GetProcessHeap (), 0, pNode->pChild[i]);
  92.             pNode->pChild[i] = NULL;
  93.             nChildren++;
  94.         }
  95.     }
  97.     pNode->bIsLeaf = TRUE;
  98.     pNode->nRedSum = nRedSum;
  99.     pNode->nGreenSum = nGreenSum;
  100.     pNode->nBlueSum = nBlueSum;
  101.     *pLeafCount -= (nChildren - 1);
  102. }
  104. // local function to delete a node of octree
  105. void DeleteTree (NODE** ppNode)
  106. {
  107.     int i;
  109.     for (i=0; i<8; i++) {
  110.         if ((*ppNode)->pChild[i] != NULL)
  111.             DeleteTree (&((*ppNode)->pChild[i]));
  112.     }
  113.     HeapFree (GetProcessHeap (), 0, *ppNode);
  114.     *ppNode = NULL;
  115. }
  117. // local function to get color entry from a palette
  118. void GetPaletteColors (NODE* pTree, PALETTEENTRY* pPalEntries, UINT* pIndex)
  119. {
  120.     int i;
  122.     if (pTree->bIsLeaf) {
  123.         pPalEntries[*pIndex].peRed =
  124.             (BYTE) ((pTree->nRedSum) / (pTree->nPixelCount));
  125.         pPalEntries[*pIndex].peGreen =
  126.             (BYTE) ((pTree->nGreenSum) / (pTree->nPixelCount));
  127.         pPalEntries[*pIndex].peBlue =
  128.             (BYTE) ((pTree->nBlueSum) / (pTree->nPixelCount));
  129.         (*pIndex)++;
  130.     }
  131.     else {
  132.         for (i=0; i<8; i++) {
  133.             if (pTree->pChild[i] != NULL)
  134.                 GetPaletteColors (pTree->pChild[i], pPalEntries, pIndex);
  135.         }
  136.     }
  137. }
  139. // local function to get pixel count
  140. int GetRightShiftCount (DWORD dwVal)
  141. {
  142.     int i;
  144.     for (i=0; i<sizeof (DWORD) * 8; i++) {
  145.         if (dwVal & 1)
  146.             return i;
  147.         dwVal >>= 1;
  148.     }
  149.     return -1;
  150. }
  152. // local function to get pixel count
  153. int GetLeftShiftCount (DWORD dwVal)
  154. {
  155.     int nCount, i;
  157.     nCount = 0;
  158.     for (i=0; i<sizeof (DWORD) * 8; i++) {
  159.         if (dwVal & 1)
  160.             nCount++;
  161.         dwVal >>= 1;
  162.     }
  163.     return (8 - nCount);
  164. }