关于调色板,求助

zhuifengs938 2007-09-02 12:15:47

--------------------Configuration: Photo - Win32 Debug--------------------
Compiling...
PhotoView.cpp
Linking...
PhotoView.obj : error LNK2001: unresolved external symbol "public: unsigned int __thiscall CDib::GetNumberOfColors(void)" (?GetNumberOfColors@CDib@@QAEIXZ)
PhotoView.obj : error LNK2001: unresolved external symbol "public: struct tagRGBQUAD * __thiscall CDib::GetRGB(void)" (?GetRGB@CDib@@QAEPAUtagRGBQUAD@@XZ)
Debug/Photo.exe : fatal error LNK1120: 2 unresolved externals
Error executing link.exe.
Creating browse info file...

Photo.exe - 3 error(s), 0 warning(s)

view类代码如下:
在view定义了一个
private:
CPalette* hPalette;
和
public:
CPalette* CreateBitmapPalette(CDib *pBitmpap);
其实函数实现为:
CPalette* CPhotoView::CreateBitmapPalette(CDib* pBitmap)
{
struct
{
WORD Version;
WORD NumberOfEntries;
PALETTEENTRY aEntries[256];
}palette={0X300,256};

LPRGBQUAD pRGBTable=pBitmap->GetRGB();
UINT numberOfColors=pBitmap->GetNumberOfColors();
for(UINT x=0;x<numberOfColors;++x)
{
palette.aEntries[x].peRed =pRGBTable[x].rgbRed;
palette.aEntries[x].peGreen =pRGBTable[x].rgbGreen;
palette.aEntries[x].peBlue =pRGBTable[x].rgbBlue;
palette.aEntries[x].peFlags =0;
}

hPalette->CreatePalette((LPLOGPALETTE)&palette);
return hPalette;
}

附:DIB.h和DIB.cpp
//DIB.h
#ifndef _CDIB_H
#define _CDIB_H

class CDib:public CObject
{
public:
RGBQUAD* m_pRGB;
BYTE* m_pData,*m_pData2;
UINT m_numberOfColors;
BOOL m_valid;
BITMAPFILEHEADER bitmapFileHeader;
BITMAPINFOHEADER *m_pBitmapInfoHeader;
BITMAPINFO * m_pBitmapInfo;
int byBitCount;
DWORD dwWidthBytes;
BYTE* pDib;
DWORD size;

public:
CDib();
~CDib();
char m_fileName[256];
char* GetFileName();
BOOL IsValid();
DWORD GetSize();
UINT GetWidth();
UINT GetHeight();
UINT GetNumberOfColors();
RGBQUAD* GetRGB();
BYTE* GetData();
BYTE* GetData2();
DWORD GetDibWidthBytes();
BITMAPINFO* GetInfo();
WORD PaletteSize(LPBYTE lpDIB);
WORD DIBNumColors(LPBYTE lpDIB);
void SaveFile(const CString filename);

public:
void GradetoRGB();
void RGBtoGrade();
void LoadFile(const char * dibFileName);
};

#endif

//DIB.cpp
#include "stdafx.h"
#include "DIB.h"
#include "windowsx.h"
#define WIDTHBYTES(bits) (((bits)+31/32*4)

CDib::CDib()
{
//size=0;
}

CDib::~CDib()
{
GlobalFreePtr(m_pBitmapInfo);
}

void CDib::LoadFile(const char* dibFileName)
{
strcpy(m_fileName,dibFileName);
CFile dibFile(m_fileName, CFile::modeRead);
dibFile.Read((void*)&bitmapFileHeader,sizeof(BITMAPFILEHEADER));
if (bitmapFileHeader.bfType == 0x4d42)
{
DWORD fileLength = dibFile.GetLength();
size = fileLength -sizeof(BITMAPFILEHEADER);
pDib =(BYTE*)GlobalAllocPtr(GMEM_MOVEABLE, size);
dibFile.Read((void*)pDib, size);
dibFile.Close();
m_pBitmapInfo = (BITMAPINFO*) pDib;
m_pBitmapInfoHeader = (BITMAPINFOHEADER*) pDib;
m_pRGB = (RGBQUAD*)(pDib +
m_pBitmapInfoHeader->biSize);
int m_numberOfColors = GetNumberOfColors();
if (m_pBitmapInfoHeader->biClrUsed == 0)
m_pBitmapInfoHeader->biClrUsed =
m_numberOfColors;
DWORD colorTableSize = m_numberOfColors *
sizeof(RGBQUAD);
m_pData = pDib + m_pBitmapInfoHeader->biSize
+ colorTableSize;
if (m_pRGB == (RGBQUAD*)m_pData) // No color table
m_pRGB = NULL;
m_pBitmapInfoHeader->biSizeImage = GetSize();
m_valid = TRUE;
}
else
{
m_valid = FALSE;
AfxMessageBox("This isn't a bitmap file!");
}
}

BOOL CDib::IsValid()
{
return m_valid;
}

char* CDib::GetFileName()
{
return m_fileName;
}

UINT CDib::GetWidth()
{
return (UINT) m_pBitmapInfoHeader->biWidth;
}

UINT CDib::GetHeight()
{
return (UINT) m_pBitmapInfoHeader->biHeight;
}

DWORD CDib::GetSize()
{
if (m_pBitmapInfoHeader->biSizeImage != 0)
return m_pBitmapInfoHeader->biSizeImage;
else
{
DWORD height = (DWORD) GetHeight();
DWORD width = (DWORD) GetWidth();
return height * width;
}
}

DWORD CDib::GetDibWidthBytes()
{
byBitCount=m_pBitmapInfoHeader->biBitCount;
LONG nWidth=m_pBitmapInfoHeader->biWidth;

dwWidthBytes = (DWORD)m_pBitmapInfoHeader->biWidth;
if(byBitCount == 1) dwWidthBytes = (nWidth + 7) / 8;
else if(byBitCount == 4) dwWidthBytes = (nWidth + 1) / 2;
else if(byBitCount == 24) dwWidthBytes = 3 * nWidth ;

while((dwWidthBytes & 3) != 0)dwWidthBytes++;

return dwWidthBytes;
}

UINT CDib::GetNumberOfColors()
{
int numberOfColors;

if ((m_pBitmapInfoHeader->biClrUsed == 0) &&
(m_pBitmapInfoHeader->biBitCount < 9))
{
switch (m_pBitmapInfoHeader->biBitCount)
{
case 1: numberOfColors = 2; break;
case 4: numberOfColors = 16; break;
case 8: numberOfColors = 256;
}
}
else
numberOfColors = (int) m_pBitmapInfoHeader->biClrUsed;

return numberOfColors;
}

BYTE* CDib::GetData()
{
return m_pData;
}

BYTE* CDib::GetData2()
{
if(GetRGB())
{
m_pData2=m_pData;
}
return m_pData2;
}

RGBQUAD* CDib::GetRGB()
{
return m_pRGB;
}

BITMAPINFO* CDib::GetInfo()
{
return m_pBitmapInfo;
}

WORD CDib::PaletteSize(LPBYTE lpDIB)
{
return (DIBNumColors(lpDIB) * sizeof(RGBTRIPLE));
}

WORD CDib::DIBNumColors(LPBYTE lpDIB)
{
WORD wBitCount; // DIB bit count
wBitCount = ((LPBITMAPCOREHEADER)lpDIB)->bcBitCount;
switch (wBitCount)
{
case 1:
return 2;
case 4:
return 16;
case 8:
return 256;
default:
return 0;
}
}

void CDib::SaveFile(const CString filename)
{
BITMAPFILEHEADER bmfHdr;
LPBITMAPINFOHEADER lpBI;
DWORD dwDIBSize;

bmfHdr.bfType=0x4d42;
lpBI=(BITMAPFILEHEADER)m_pBitmapInfoHeader;
dwDIBSize=*(LPDWORD)lpBI+PaletteSize((LPBYTE)lpBI);
if((lpBI->biCompression==BI_RLE8) || (lpBI->biCompression==BI_RLE4))
dwDIBSize+=lpBI->biSizeImage;
else
{
DWORD dwBmBitsSize=WIDTHBYTES((lpBI->biWidth)*((DWORD) lpBI->
biBitCount))*lpBI->biHeight;
dwDIBSize+=dwBmBitsSize;
}
bmfHdr.bfSize=dwDIBSize+sizeof(BITMAPFILEHEADER);
bmfHdr.bfReserved1=0;
bmfHdr.bfReserved2=0;
bmfHdr.bfOffBits=(DWORD)sizeof(BITMAPFILEHEADER)+lpBI->biSize
+PalettteSize((LPBYTE)lpBI);

CFile dibFile(filename,CFile::modeWrite | CFile::modeCreate);
dibFile.Write(&bmfHdr,sizeof(BITMAPFILEHEADER));
dibFile.WriteHuge(lpBI,dwDIBSize);
dibFile.Close();
}

void CDib::RGBtoGrade()
{
if(GetRGB())
m_pData2=m_pdata;
else
{
BYTE r,g,b;
int height,wide,size;
height=GetHeight();
wide=GetWidth();
size=height*wide;
m_pData2=(BYTE*)GlobalAllocPtr(GMEM_MOVEABLE,size);
LONG lLineBytes=GetDibWidthBytes();
for(int j=0;j<height;j++)
{
for(int i=0;i<wide;i++)
{
b=m_pData[j*lLineBytes+3*i];
g=m_pData[j*lLineBytes+3*i+1];
r=m_pData[j*lLineBytes+3*i+2];
m_pData2[j*wide+i]=(BYTE)(0.3*r+0.59*g+0.11*b);
}
}
}
}

void CDib::GradetoRGB()
{
if(GetRGB())
m_pData2=m_pData;
else
{
BYTE r,g,b;
int height,wide;
height=GetHeight();
wide=GetWidth();
LONG lLineBytes=GetDibWidthBytes();
for(int j=0;j<height;j++)
{
for(int i=0;i<wide;i++)
{
m_pData[(height-j-1)*lLineBytes+3*i]=
m_pData2[(height-1-j)*wide+i];
m_pData[(height-j-1)*lLineBytes+3*i+1]=
m_pData2[(height-1-j)*wide+i];
m_pData[(height-j-1)*lLineBytes+3*i+2]=
m_pData2[(height-1-j)*wide+i];
}
}

}
}

...全文