dib.cpp

本程序根据用户不同的需求设计窗口的背景

				for(j=0; j < nWidth; j++,srcPtr++,destPtr++)
				{
					if(colors[*srcPtr]) *destPtr=*srcPtr;
				}
			}
		}
	}
}

unsigned char *CDIB::GetLinePtr(int line)
{
/*unsigned char *ptr;
	ptr = m_pBits + (height-line-1)*bytes;
	return ptr;*/
	return m_pLinePtr[line];
}
	
BOOL CDIB::CopyDIB(CDIB& dib)
{
	if(Create(dib.m_pInfo->bmiHeader))
	{
		SetPalette(dib.m_pRGB);
		memcpy(m_pBits,dib.m_pBits,height*bytes);
		return TRUE;
	}
	return FALSE;
}

void CDIB::ReplaceColor(unsigned char oldColor,unsigned char newColor)
{
int i,j;
unsigned char *ptr;	
	for(i=0; i < height; i++)
	{
		ptr = GetLinePtr(i);
		for(j=0; j < width; j++)
		{
			if(ptr[j] == oldColor) ptr[j] = newColor;
		}
	}
}


CDIB& CDIB::operator=(CDIB& dib)
{
	CopyDIB(dib);
	return *this;
}

HANDLE CDIB::GetDIBits(int nStartX,int nStartY,int nCx,int nCy)
{
	if(nStartX == -1)
	{
		nStartX = nStartY=0;
		nCx = width;
		nCy = height;
		CDIB dib;
		dib.Create(nCx,nCy,8);
		dib.BitBlt(0,0,nCx,nCy,*this,0,0);
		dib.SetPalette(m_pRGB);
		return dib.DIBHandle();
	}
	return DIBHandle();
}

DWORD CDIB::GetDIBSize()
{
	return sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD)*GetPaletteSize() + bytes*height;
}

HANDLE CDIB::DIBHandle()
{
int nSize;
HANDLE hMem;
	nSize = sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD)*GetPaletteSize() + bytes*height;
	hMem = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE,nSize);
	if(hMem  == NULL) return NULL;
UCHAR *lpVoid,*pBits;
LPBITMAPINFOHEADER pHead;
RGBQUAD *pRgb;
	lpVoid = (UCHAR *)GlobalLock(hMem);
	pHead = (LPBITMAPINFOHEADER )lpVoid;
	memcpy(pHead,&m_pInfo->bmiHeader,sizeof(BITMAPINFOHEADER));
	pRgb = (RGBQUAD *)(lpVoid + sizeof(BITMAPINFOHEADER) );
	memcpy(pRgb,m_pRGB,sizeof(RGBQUAD)*GetPaletteSize());
	pBits = lpVoid + sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD)*GetPaletteSize();
	memcpy(pBits,m_pBits,height*bytes);
	GlobalUnlock(lpVoid);
	return hMem;
}

BOOL CDIB::CreateFromHandle(HANDLE hMem,int bits)
{
	DestroyDIB();
UCHAR *lpVoid,*pBits;
LPBITMAPINFOHEADER pHead;
RGBQUAD *pRgb;
	lpVoid = (UCHAR *)GlobalLock(hMem);
	pHead = (LPBITMAPINFOHEADER )lpVoid;
	width = pHead->biWidth;
	height = pHead->biHeight;
	m_nBits = pHead->biBitCount;
	if(pHead->biCompression != BI_RGB) 
	{
		GlobalUnlock(lpVoid);
		return FALSE;
	}
	if(pHead->biBitCount >= 15)
	{
		if(pHead->biBitCount != 24) 
		{
			GlobalUnlock(lpVoid);
			return FALSE;
		}
	}
	if(!Create(*pHead))
	{
		GlobalUnlock(lpVoid);
		return FALSE;
	}
	pRgb = (RGBQUAD *)(lpVoid + sizeof(BITMAPINFOHEADER) );
	memcpy(m_pRGB,pRgb,sizeof(RGBQUAD)*GetPaletteSize());
	pBits = lpVoid + sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD)*GetPaletteSize();
	memcpy(m_pBits,pBits,height*bytes);
	GlobalUnlock(lpVoid);
	return TRUE;
}

void CDIB::UseGamma(float fg,BOOL bUse)
{
	m_bUseGamma = bUse;
	m_fOldGamma = m_fGamma;
	m_fGamma = fg;
	CreateGammaCurve();
}


void CDIB::CreateGammaCurve()
{
int i;
	for(i=0;i<256;++i)
	{
	    Gamma[i]=(int)(255 * pow((double)i/255,m_fGamma) + (double)0.5);
	}
}



void CDIB::GetPixel(UINT x,UINT y,int& pixel)
{
	ASSERT(x < (UINT)Width());
	ASSERT(y < (UINT)Height());
	if(x >= (UINT)Width()) return;
	if(y >= (UINT)Height()) return;
	pixel=(GetLinePtr(y))[x];
}

BOOL CDIB::Make8Bit(CDIB& dib)
{
int nBits;	
	ASSERT(Width() == dib.Width());
	ASSERT(Height() == dib.Height());
	nBits = dib.GetBitCount();
	switch(nBits)
	{
	case 1:
		return SwitchFromOne(dib);
		break;
	case 4:
		return SwitchFromFour(dib);
		break;
	case 8:
		return SwitchPalette(dib);
		break;
	case 24:
		return SwitchFrom24(dib);
		break;
	default:
		return FALSE;
	}
	return FALSE;
}

/*
BOOL CDIB::SwitchFrom24(CDIB& dib)
{
int i,j,w,h;
unsigned char *sPtr,*dPtr;
	w = Width();
	h = Height();
	memset(CachePtr,0,sizeof(CachePtr));
	for(i=0; i < h; i++)
	{
		dPtr = GetLinePtr(i);
		sPtr = dib.GetLinePtr(i);
		for(j=0 ; j < w; j++,dPtr++,sPtr+=3)
		{
			*dPtr = ClosestColor((RGBQUAD *)sPtr);
		}
	}
	return TRUE;
}
*/


BOOL CDIB::SwitchFromOne(CDIB& dib)
{
int i,n,j,w,h;
unsigned char *sPtr,*dPtr;
unsigned char cols[2];
	w = Width();
	h = Height();
	memset(CachePtr,0,sizeof(CachePtr));
	cols[0]=ClosestColor(dib.m_pRGB);
	cols[1]=ClosestColor(dib.m_pRGB+1);
	for(i=0; i < h; i++)
	{
		dPtr = GetLinePtr(i);
		sPtr = dib.GetLinePtr(i);
		for(j=0 ; j < w; j++,dPtr++)
		{
			if(!(sPtr[j>>3] & masktable[j&7])) *dPtr = cols[0];
			else *dPtr = cols[1];
		}
	}
	return TRUE;
}

BOOL CDIB::SwitchFromFour(CDIB& dib)
{
int i,n,j,w,h;
unsigned char *sPtr,*dPtr;
unsigned char cols[16];
	w = Width();
	h = Height();
	memset(CachePtr,0,sizeof(CachePtr));
	for(i=0; i < 16; i++)
	{
		cols[i]=ClosestColor(dib.m_pRGB+i);
	}
	for(i=0; i < h; i++)
	{
		dPtr = GetLinePtr(i);
		sPtr = dib.GetLinePtr(i);
		for(j=0 ; j < w; j++,dPtr++)
		{
			if(!(j&1)) n = (*sPtr & 0xf0)>>4;
			else 
			{
				n = *sPtr & 0x0f;
				sPtr++;
			}
			*dPtr = cols[n];
		}
	}
	return TRUE;
}

BOOL CDIB::SwitchPalette(CDIB& dib)
{
int i,j,w,h;
unsigned char *sPtr,*dPtr;
unsigned char cols[256];
	w = Width();
	h = Height();
	memset(CachePtr,0,sizeof(CachePtr));
	for(i=0; i < 256; i++)
	{
		cols[i]=ClosestColor(dib.m_pRGB+i);
	}
	for(i=0; i < h; i++)
	{
		dPtr = GetLinePtr(i);
		sPtr = dib.GetLinePtr(i);
		for(j=0 ; j < w; j++,sPtr++,dPtr++)
		{
			*dPtr = cols[*sPtr];
		}
	}
	return TRUE;
}


int CDIB::ClosestColor(RGBQUAD *pRgb)
{
unsigned int dist=BIG_DISTANCE,i,d,c;
RGBQUAD *pQuad=m_pRGB;
int pSize=GetPaletteSize();
	for(i=0; i < pSize;i++)
	{
		if(CachePtr[i])
		{
			if(!memcmp((void *)&CacheQuad[i],(void *)pRgb,3)) 
			{
				return i;
			}
		}
	}
	for(i=0; i < pSize; i++,pQuad++)
	{
		d = Distance(*pRgb,*pQuad);
		if(!d) 
		{
			CacheQuad[i]=*pRgb;
			CachePtr[i]=1;
			return i;
		}		
		if(dist > d) 
		{
			c = i;
			dist = d;
		}
	}
	CacheQuad[c]=*pRgb;
	CachePtr[c]=1;
	return c;
}

unsigned int CDIB::Distance(RGBQUAD& rgb1,RGBQUAD& rgb2)
{
unsigned int d;
	d =  3*(unsigned)((rgb1.rgbRed)-(rgb2.rgbRed))*(unsigned)((rgb1.rgbRed)-(rgb2.rgbRed));
	d += 4*(unsigned)((rgb1.rgbGreen)-(rgb2.rgbGreen))*(unsigned)((rgb1.rgbGreen)-(rgb2.rgbGreen)) ;
	d += 2*(unsigned)((rgb1.rgbBlue)-(rgb2.rgbBlue))*(unsigned)((rgb1.rgbBlue)-(rgb2.rgbBlue));
	return d;
}

BOOL CDIB::OpenDIB(CString& csFileName)
{
CFile file;
	if(!file.Open(csFileName,CFile::modeRead | CFile::typeBinary))
	{
		return FALSE;
	}
	file.Close();
	if(OpenBMP(csFileName)) return TRUE;
	return FALSE;
}



BOOL CDIB::SaveDIB(CString& csFileName,BitmapType type)
{
CFile file;
	if(!file.Open(csFileName,CFile::modeCreate | CFile::typeBinary))
	{
		return FALSE;
	}
	file.Close();
	switch(type)
	{
	case BMP:
			return SaveBMP(csFileName);
	default:
			return FALSE;
	}
	return FALSE;
}

BOOL CDIB::SaveBMP(CString& csFileName)
{
BITMAPFILEHEADER bFile;
CFile file;
	if(!file.Open(csFileName,CFile::modeWrite | CFile::typeBinary))
	{
		return FALSE;
	}
	::ZeroMemory(&bFile,sizeof(bFile));
	memcpy((void *)&bFile.bfType,"BM",2);
	bFile.bfSize = GetDIBSize() + sizeof(bFile);
	bFile.bfOffBits = sizeof(BITMAPINFOHEADER) + GetPaletteSize()*sizeof(RGBQUAD) + sizeof(BITMAPFILEHEADER);
	file.Write(&bFile,sizeof(bFile));
	file.Write(m_pVoid,GetDIBSize());
	file.Close();
	return TRUE;

}

BOOL CDIB::OpenBMP(CString& csFileName)
{
BITMAPFILEHEADER bFile;
BITMAPINFOHEADER head;
CFile file;
	if(!file.Open(csFileName,CFile::modeRead | CFile::typeBinary))
	{
		return FALSE;
	}
	file.Read(&bFile,sizeof(bFile));
	if(memcmp((void *)&bFile.bfType,"BM",2))
	{
		file.Close();
		return FALSE;
	}
	file.Read(&head,sizeof(head));
	if(!Create(head))
	{
		file.Close();
		return FALSE;
	}
	file.Read(m_pRGB,sizeof(RGBQUAD)*GetPaletteSize());
	file.Seek(bFile.bfOffBits,CFile::begin);
	file.Read(m_pBits,height*bytes);
	file.Close();
	return TRUE;

}


int CDIB::CountColors()
{
	ASSERT(GetBitCount()==8);
BYTE colors[256],*ptr;
int nNum=0,i,j,w,d;
	w = Width();
	d = Height();
	memset(colors,0,256);
	for(i=0; i < d; i++)
	{
		ptr = GetLinePtr(i);
		for(j=0; j < w; j++,ptr++)
		{
			if(!colors[*ptr])
			{
				colors[*ptr]=1;
				nNum++;
			}
		}
	}
	return nNum;
}

int CDIB::EnumColors(BYTE *array)
{
	ASSERT(GetBitCount()==8);
BYTE *ptr;
int nNum=0,i,j,w,d;
	w = Width();
	d = Height();
	memset(array,0,256);
	for(i=0; i < d; i++)
	{
		ptr = GetLinePtr(i);
		for(j=0; j < w; j++,ptr++)
		{
			if(!array[*ptr])
			{
				array[*ptr]=1;
				nNum++;
			}
		}
	}
	return nNum;
}

COLORREF CDIB::PaletteColor(int nIndex)
{
	ASSERT(nIndex < 256);
RGBQUAD *pRGB= m_pRGB+nIndex;
	return RGB(pRGB->rgbRed,pRGB->rgbGreen,pRGB->rgbBlue);
}

BOOL CDIB::SwitchFrom24(CDIB& dib)
{
int i,j,w,h,c;
unsigned char *sPtr,*dPtr;
BYTE *index_ptr=NULL;
RGBQUAD rgb;
	w = Width();
	h = Height();
	index_ptr = (BYTE *)malloc(0x7FFF+1);
	if(!index_ptr) return FALSE;
	memset(CachePtr,0,sizeof(CachePtr));
	for(i=0; i <= 0x7FFF; i++)
	{
		rgb.rgbRed = (((i & 0x7C00)>>10) << 3) | 0x07;
		rgb.rgbGreen = (((i & 0x3e0)>>5) << 3) | 0x07;
		rgb.rgbBlue = ((i & 0x1F)<<3) | 0x07;
		index_ptr[i] = ClosestColor(&rgb);
	}
	for(i=0; i < h; i++)
	{
		dPtr = GetLinePtr(i);
		sPtr = dib.GetLinePtr(i);
		for(j=0 ; j < w; j++,dPtr++,sPtr+=3)
		{
			c = (*sPtr >> 3) | ((*(sPtr+1) >> 3) << 5) | ((*(sPtr+2) >> 3) << 10);
			*dPtr = index_ptr[c];
		}
	}
	free(index_ptr);
	return TRUE;
}