dibapi.cpp

数字图像处理的灰度处理源代码.rar

//DIBAPI.cpp

#include "stdafx.h"
#include "DIBAPI.h"
#include "math.h"

WORD WINAPI DIBNumColors(LPSTR lpbi)
{
	WORD wBitCount;

	if(IS_WIN30_DIB(lpbi))
	{
		DWORD dwClrUsed;
		dwClrUsed=((LPBITMAPINFOHEADER)lpbi)->biClrUsed;

		if(dwClrUsed)
			return (WORD)dwClrUsed;
	}

	if(IS_WIN30_DIB(lpbi))
        wBitCount=((LPBITMAPINFOHEADER)lpbi)->biBitCount;
	else
		wBitCount=((LPBITMAPCOREHEADER)lpbi)->bcBitCount;

	switch(wBitCount)
	{
	case 1:
		return 2;
	case 4:
		return 16;
	case 8:
		return 256;
	default:
		return 0;
	}
}

WORD WINAPI PaletteSize(LPSTR lpbi)
{
	if(IS_WIN30_DIB(lpbi))
		return (WORD)(DIBNumColors(lpbi)*sizeof(RGBQUAD));
	else
		return (WORD)(DIBNumColors(lpbi)*sizeof(RGBTRIPLE));
}


LPSTR WINAPI FindDIBBits(LPSTR lpbi)
{
	return (lpbi+*(LPDWORD)lpbi+::PaletteSize(lpbi));
}

DWORD WINAPI DIBWidth(LPSTR lpDIB)
{
	LPBITMAPINFOHEADER lpbmi;
	LPBITMAPCOREHEADER lpbmc;

	lpbmi=(LPBITMAPINFOHEADER)lpDIB;
	lpbmc=(LPBITMAPCOREHEADER)lpDIB;

	if(IS_WIN30_DIB(lpDIB))
		return lpbmi->biWidth;
	else
		return (DWORD)lpbmc->bcWidth;
}

DWORD WINAPI DIBHeight(LPSTR lpDIB)
{
	LPBITMAPINFOHEADER lpbmi;
	LPBITMAPCOREHEADER lpbmc;

	lpbmi=(LPBITMAPINFOHEADER)lpDIB;
	lpbmc=(LPBITMAPCOREHEADER)lpDIB;

	if(IS_WIN30_DIB(lpDIB))
		return lpbmi->biHeight;
	else
		return (DWORD)lpbmc->bcHeight;
}

BOOL WINAPI PaintDIB(HDC hDC,LPRECT lpDCRect,HDIB hDIB,LPRECT lpDIBRect,CPalette* pPal)
{
	LPSTR lpDIBHdr;
	LPSTR lpDIBBits;
	BOOL bSuccess=FALSE;
	HPALETTE hPal=NULL;
	HPALETTE hOldPal=NULL;

	if(hDIB==NULL)
		return FALSE;

	lpDIBHdr=(LPSTR)::GlobalLock((HGLOBAL)hDIB);
	lpDIBBits=FindDIBBits(lpDIBHdr);

	if(pPal!=NULL)
	{
		hPal=(HPALETTE)pPal->m_hObject;
		hOldPal=::SelectPalette(hDC,hPal,TRUE);
	}

	::SetStretchBltMode(hDC,COLORONCOLOR);

    if((RECTWIDTH(lpDCRect)==RECTWIDTH(lpDIBRect))&&(RECTHEIGHT(lpDCRect)==RECTHEIGHT(lpDIBRect)))
	{
		bSuccess=::SetDIBitsToDevice(hDC,lpDCRect->left,lpDCRect->top,RECTWIDTH(lpDCRect),RECTHEIGHT(lpDCRect),lpDIBRect->left,\
		(int)DIBHeight(lpDIBHdr)-lpDIBRect->top-RECTHEIGHT(lpDIBRect),0,(WORD)DIBHeight(lpDIBHdr),\
		lpDIBBits,(LPBITMAPINFO)lpDIBHdr,DIB_RGB_COLORS);
	}
	else
	{
		bSuccess=::StretchDIBits(hDC,lpDCRect->left,lpDCRect->top,RECTWIDTH(lpDCRect),RECTHEIGHT(lpDCRect),lpDIBRect->left,\
		lpDIBRect->top,RECTWIDTH(lpDIBRect),RECTHEIGHT(lpDIBRect),\
		lpDIBBits,(LPBITMAPINFO)lpDIBHdr,DIB_RGB_COLORS,SRCCOPY);
	}

	::GlobalUnlock((HGLOBAL)hDIB);

	if(hOldPal)
		::SelectPalette(hDC,hOldPal,TRUE);

	GlobalUnlock(hDIB);

	return bSuccess;
}

BOOL WINAPI CreateDIBPalette(HDIB hDIB,CPalette* pPal)
{
	LPLOGPALETTE lpPal;
	HANDLE hLogPal;
	HPALETTE hPal=NULL;
	LPSTR lpbi;
	LPBITMAPINFO lpbmi;
	LPBITMAPCOREINFO lpbmc;
	BOOL bWinStyleDIB;
	int i;
	WORD wNumColors;
	BOOL bResult=FALSE;

	if(hDIB==NULL)
		return FALSE;
    
	lpbi=(LPSTR)::GlobalLock((HGLOBAL)hDIB);
	lpbmi=(LPBITMAPINFO)lpbi;

	lpbmc=(LPBITMAPCOREINFO)lpbi;

	wNumColors=DIBNumColors(lpbi);

	bWinStyleDIB=IS_WIN30_DIB(lpbi);

	if(wNumColors!=0)
	{
		hLogPal=::GlobalAlloc(GHND,sizeof(LOGPALETTE)+sizeof(PALETTEENTRY)*wNumColors);

		if(hLogPal==0)
		{
			::GlobalUnlock((HGLOBAL)hDIB);
			return FALSE;
		}

		lpPal=(LPLOGPALETTE)::GlobalLock(hLogPal);

		lpPal->palVersion=PALVERSION;
		lpPal->palNumEntries=(WORD)wNumColors;
		bWinStyleDIB=IS_WIN30_DIB(lpbi);

		for(i=0;i<(int)wNumColors;i++)
		{
			if(bWinStyleDIB)
			{
				lpPal->palPalEntry[i].peRed=lpbmi->bmiColors[i].rgbRed;
				lpPal->palPalEntry[i].peGreen=lpbmi->bmiColors[i].rgbGreen;
				lpPal->palPalEntry[i].peBlue=lpbmi->bmiColors[i].rgbBlue;
				lpPal->palPalEntry[i].peFlags=0;
			}
			else
			{
				lpPal->palPalEntry[i].peRed=lpbmc->bmciColors[i].rgbtRed;
				lpPal->palPalEntry[i].peGreen=lpbmc->bmciColors[i].rgbtGreen;
				lpPal->palPalEntry[i].peBlue=lpbmc->bmciColors[i].rgbtBlue;
				lpPal->palPalEntry[i].peFlags=0;
			}
		}

		bResult=pPal->CreatePalette(lpPal);

		::GlobalUnlock((HGLOBAL)hLogPal);
		::GlobalFree((HGLOBAL)hLogPal);
	}

	::GlobalUnlock((HGLOBAL)hDIB);
	return bResult;
}



HGLOBAL WINAPI CopyHandle(HGLOBAL h)
{
	if(h==NULL)
		return NULL;

	DWORD dwLen=::GlobalSize((HGLOBAL)h);

	HGLOBAL hCopy=::GlobalAlloc(GHND,dwLen);

	if(hCopy!=NULL)
	{
		void* lpCopy=::GlobalLock((HGLOBAL)hCopy);
		void* lp=::GlobalLock((HGLOBAL)h);

		memcpy(lpCopy,lp,dwLen);

		::GlobalUnlock(hCopy);
		::GlobalUnlock(h);
	}
	return hCopy;
}

BOOL WINAPI SaveDIB(HDIB hDib,CFile& file)
{
	BITMAPFILEHEADER bmfHdr;
	LPBITMAPINFOHEADER lpBI;
	DWORD dwDIBSize;

	if(!hDib)
		return FALSE;

	lpBI=(LPBITMAPINFOHEADER)::GlobalLock((HGLOBAL)hDib);

	if(lpBI==NULL)
		return FALSE;
     
	if(!IS_WIN30_DIB(lpBI))
	{
		::GlobalUnlock((HGLOBAL)hDib);
		return FALSE;
	}


	bmfHdr.bfType=DIB_HEADER_MARKER;

	dwDIBSize=*(LPDWORD)lpBI+::PaletteSize((LPSTR)lpBI);

	if((lpBI->biCompression==BI_RLE8)||(lpBI->biCompression==BI_RLE4))
		dwDIBSize+=lpBI->biSizeImage;
	else
	{
		DWORD dwBmBitsSize;
		dwBmBitsSize=WIDTHBYTES((lpBI->biWidth)*((DWORD)lpBI->biBitCount))*lpBI->biHeight;
		dwDIBSize+=dwBmBitsSize;

		lpBI->biSizeImage=dwBmBitsSize;
	}

	bmfHdr.bfSize=dwDIBSize+sizeof(BITMAPFILEHEADER);
	bmfHdr.bfReserved1=0;
	bmfHdr.bfReserved2=0;

	bmfHdr.bfOffBits=(DWORD)sizeof(BITMAPFILEHEADER)+lpBI->biSize+::PaletteSize((LPSTR)lpBI);

	TRY
	{
		file.Write((LPSTR)&bmfHdr,sizeof(BITMAPFILEHEADER));
		file.WriteHuge(lpBI,dwDIBSize);
	}
	CATCH(CFileException,e)
	{
		::GlobalUnlock((HGLOBAL)hDib);
		THROW_LAST();
	}
	END_CATCH

	::GlobalUnlock((HGLOBAL)hDib);

	return TRUE;
}

HDIB WINAPI ReadDIBFile(CFile& file)
{
	BITMAPFILEHEADER bmfHeader;
	DWORD dwBitsSize;
	HDIB hDIB;
    LPSTR pDIB;

    dwBitsSize=file.GetLength();

    if(file.Read((LPSTR)&bmfHeader,sizeof(bmfHeader))!=sizeof(bmfHeader))
		return NULL;

	if(bmfHeader.bfType!=DIB_HEADER_MARKER)
		return NULL;

	hDIB=(HDIB)::GlobalAlloc(GMEM_MOVEABLE|GMEM_ZEROINIT,dwBitsSize);

	if(hDIB==0)
		return NULL;

	pDIB=(LPSTR)::GlobalLock((HGLOBAL)hDIB);

	if(file.ReadHuge(pDIB,dwBitsSize-sizeof(BITMAPFILEHEADER))!=dwBitsSize-sizeof(BITMAPFILEHEADER))
	{
		::GlobalUnlock((HGLOBAL)hDIB);
		::GlobalFree((HGLOBAL)hDIB);
		return NULL;
	}

	::GlobalUnlock((HGLOBAL)hDIB);

	return hDIB;
}

//在此处输入自己的函数定义


BOOL WINAPI AverFilter(LPSTR lpDIBBits,LONG lWidth,LONG lHeight)
{
	//均值滤波
	unsigned char* lpSrc1,*lpSrc2,*lpSrc3,*lpSrc4,*lpSrc,*lpSrc6,*lpSrc7,*lpSrc8,*lpSrc9;

	LONG i;
	LONG j;

	LONG lLineBytes;

	LONG fTemp;
	LONG fBiex=20;

	lLineBytes=WIDTHBYTES(lWidth*8);

	for(i=1;i<lHeight-1;i++)
	{
		for(j=1;j<lWidth-1;j++)
		{
			lpSrc1=(unsigned char*)lpDIBBits+lLineBytes*(lHeight-1-(i-1))+j-1;
			lpSrc2=(unsigned char*)lpDIBBits+lLineBytes*(lHeight-1-i)+j-1;
			lpSrc3=(unsigned char*)lpDIBBits+lLineBytes*(lHeight-1-(i+1))+j-1;
			lpSrc4=(unsigned char*)lpDIBBits+lLineBytes*(lHeight-1-(i-1))+j;
			lpSrc=(unsigned char*)lpDIBBits+lLineBytes*(lHeight-1-i)+j;
			lpSrc6=(unsigned char*)lpDIBBits+lLineBytes*(lHeight-1-(i+1))+j;
			lpSrc7=(unsigned char*)lpDIBBits+lLineBytes*(lHeight-1-(i-1))+j+1;
			lpSrc8=(unsigned char*)lpDIBBits+lLineBytes*(lHeight-1-i)+j+1;
			lpSrc9=(unsigned char*)lpDIBBits+lLineBytes*(lHeight-1-(i+1))+j+1;

			fTemp=(*lpSrc1+*lpSrc2+*lpSrc3+*lpSrc4+*lpSrc6+*lpSrc7+*lpSrc8+*lpSrc9)/8;
			
			if(abs(fTemp-*lpSrc)>=fBiex)
			{
				fTemp=fTemp;
			}
			else
			{
				fTemp=*lpSrc;
			}

			if(fTemp>255)
			{
				*lpSrc=255;
			}
			else if(fTemp<0)
			{
				*lpSrc=0;
			}
			else
			{
				*lpSrc=(unsigned char)(fTemp+0.5);
			}
		}
	}

	return TRUE;
}


BOOL WINAPI REVERSE(LPSTR lpDIBBits,LONG lWidth,LONG lHeight)
{
	unsigned char* lpSrc;

	int i;
	int j;

	LONG lLineBytes;

	LONG fTemp;
	LONG fBiex=20;

	lLineBytes=WIDTHBYTES(lWidth*8);

	for(i=1;i<lHeight-1;i++)
	{
		for(j=1;j<lWidth-1;j++)
		{
			//lpSrc1=(unsigned char*)lpDIBBits+lLineBytes*(lHeight-1-(i-1))+j-1;
			//lpSrc2=(unsigned char*)lpDIBBits+lLineBytes*(lHeight-1-i)+j-1;
			//lpSrc3=(unsigned char*)lpDIBBits+lLineBytes*(lHeight-1-(i+1))+j-1;
	    	//lpSrc4=(unsigned char*)lpDIBBits+lLineBytes*(lHeight-1-(i-1))+j;
			lpSrc=(unsigned char*)lpDIBBits+lLineBytes*(lHeight-1-i)+j;
	    	//lpSrc6=(unsigned char*)lpDIBBits+lLineBytes*(lHeight-1-(i+1))+j;
			//lpSrc7=(unsigned char*)lpDIBBits+lLineBytes*(lHeight-1-(i-1))+j+1;
	     	//lpSrc8=(unsigned char*)lpDIBBits+lLineBytes*(lHeight-1-i)+j+1;
		    //lpSrc9=(unsigned char*)lpDIBBits+lLineBytes*(lHeight-1-(i+1))+j+1;

			//fTemp=(*lpSrc1+*lpSrc2+*lpSrc3+*lpSrc4+*lpSrc6+*lpSrc7+*lpSrc8+*lpSrc9)/8;
			 
			fTemp=256-*lpSrc;

			if(abs(fTemp-*lpSrc)>=fBiex)
			{
				fTemp=fTemp;
			}
			else
			{
				fTemp=*lpSrc;
			}

			if(fTemp>255)
			{
				*lpSrc=255;
			}
			else if(fTemp<0)
			{
				*lpSrc=0;
			}
			else
			{
				*lpSrc=(unsigned char)(fTemp+0.5);
			}
		}
	}


	return true;
}

/*************************************************************************   
    *   
    *   函数名称：   
    *       SaltNoiseDIB()   
    *   
    *   参数:   
    *       LPSTR   lpDIBBits         -   指向源DIB图像指针   
    *       LONG     lWidth               -   源图像宽度（象素数，必须是4的倍数）   
    *       LONG     lHeight             -   源图像高度（象素数）   
    *   
    *   返回值:   
    *       BOOL                               -   模糊操作成功返回TRUE，否则返回FALSE。   
    *   
    *   说明:   
    *       该函数用来对DIB图像进行模糊操作。   
    *   
    ************************************************************************/   
    
 BOOL WINAPI SaltNoiseDIB(LPSTR lpDIBBits,LONG lWidth,LONG   lHeight) 
  {   
  //   指向源图像的指针   
  LPSTR lpSrc;   
    
  //循环变量   
  int   i;   
  int   j;   
    
  //   图像每行的字节数   
  LONG   lLineBytes;   
    
  //   计算图像每行的字节数   
  lLineBytes   =   WIDTHBYTES(lWidth   *   8);   
    
  //生成伪随机种子   
  srand((unsigned)time(NULL));   
    
  //在图像中加噪   
  for   (j   =   0;j   <   lHeight   ;j++)   
  {   
  for(i   =   0;i   <   lLineBytes   ;i++)   
  {   
  if(rand()>31500)   
  {   
  //   指向源图像倒数第j行，第i个象素的指针   
  lpSrc   =   (char   *)lpDIBBits   +   lLineBytes   *   j   +   i;   
    
  //图像中当前点置为黑   
  *lpSrc   =   0;   
  }   
  }   
  }   
  //   返回   
  return   true;   
  } 
 BOOL WINAPI GradSharp(LPSTR lpDIBBits,LONG lWidth,LONG lHeight)
{
	//梯度锐化
	unsigned char* lpSrc1,*lpSrc2,*lpSrc;