wrapbitmap.cpp

LOG滤波器提取边缘；用形态学方法提取骨架线；由明暗度提取外形信息；

// WrapBitmap.cpp: implementation of the CWrapBitmap class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "Log.h"
#include "WrapBitmap.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CWrapBitmap::CWrapBitmap()
{
	m_hBitmap=NULL;
	m_pBuffer=NULL;
}

CWrapBitmap::~CWrapBitmap()
{
	if(m_hBitmap)
	{
		DeleteObject(m_hBitmap);
		m_hBitmap=NULL;
	}
	if(m_pBuffer)
	{
		delete[] m_pBuffer;
	}

}

BOOL CWrapBitmap::Load(LPCTSTR lpszPathName)
{
	if(m_hBitmap)	//已经载入过位图
	{
		m_Bitmap.Detach();
		DeleteObject(m_hBitmap);
		m_hBitmap=NULL;
	}
	m_hBitmap=(HBITMAP)::LoadImage(NULL,lpszPathName,IMAGE_BITMAP,0,0,LR_LOADFROMFILE|LR_CREATEDIBSECTION);
    
	if(m_hBitmap==NULL)
	{

		TRACE("Load Bitmap Error");
		return false;
	}
	
	m_Bitmap.Attach(m_hBitmap);
	return true;

}

BOOL CWrapBitmap::Save(LPCTSTR lpszPathName)
{
	HANDLE hDIB;
	
	if(!m_hBitmap)
		return FALSE;
	hDIB=DDBToDIB(m_Bitmap,BI_RGB,NULL);	//转化DDB2DIB

	if( hDIB == NULL )
		return FALSE;
	// Write it to file
	BITMAPFILEHEADER	hdr;	//位图文件头
	LPBITMAPINFOHEADER	lpbi;	//位图信息头

	CFile file;

	if( !file.Open( lpszPathName, CFile::modeWrite|CFile::modeCreate) )
		return FALSE;

	lpbi = (LPBITMAPINFOHEADER)hDIB;

	int nColors = 1 << lpbi->biBitCount;

	// Fill in the fields of the file header 
	hdr.bfType		= ((WORD) ('M' << 8) | 'B');	// is always "BM"
	hdr.bfSize		= GlobalSize (hDIB) + sizeof( hdr );
	hdr.bfReserved1 	= 0;	//保留字
	hdr.bfReserved2 	= 0;	//保留字
	hdr.bfOffBits		= (DWORD) (sizeof( hdr ) + lpbi->biSize +
						nColors * sizeof(RGBQUAD));

	// Write the file header 
	file.Write( &hdr, sizeof(hdr) );

	// Write the DIB header and the bits 
	file.Write( lpbi, GlobalSize(hDIB) );
	
	file.Flush();
	file.Close();

	// Free the memory allocated by DDBToDIB for the DIB
	GlobalFree( hDIB );
	return TRUE;
}



HANDLE CWrapBitmap::DDBToDIB(CBitmap &bitmap, DWORD dwCompression, CPalette *pPal)
{
	BITMAP			bm;
	BITMAPINFOHEADER	bi;
	LPBITMAPINFOHEADER 	lpbi;
	DWORD			dwLen;
	HANDLE			handle;
	HANDLE			hDIB;
	HDC 			hDC;
	HPALETTE		hPal;
	

	ASSERT( bitmap.GetSafeHandle() );

	// The function has no arg for bitfields
	if( dwCompression == BI_BITFIELDS )
		return NULL;

	// If a palette has not been supplied use defaul palette
	hPal = (HPALETTE) pPal->GetSafeHandle();
	if (hPal==NULL)
		hPal = (HPALETTE) GetStockObject(DEFAULT_PALETTE);

	// Get bitmap information
	bitmap.GetObject(sizeof(bm),(LPSTR)&bm);

	//>> 填充位图信息头 bitmapinfoheader
	bi.biSize		= sizeof(BITMAPINFOHEADER);
	bi.biWidth		= bm.bmWidth;
	bi.biHeight 		= bm.bmHeight;
	bi.biPlanes 		= 1;
	bi.biBitCount		= bm.bmPlanes * bm.bmBitsPixel;
	bi.biCompression	= dwCompression;
	bi.biSizeImage		= 0;
	bi.biXPelsPerMeter	= 0;
	bi.biYPelsPerMeter	= 0;
	bi.biClrUsed		= 0;
	bi.biClrImportant	= 0;
	//<<

	// Compute the size of the  infoheader and the color table
	int nColors = (1 << bi.biBitCount);
	if( nColors > 256 ) 
		nColors = 0;
	dwLen  = bi.biSize + nColors * sizeof(RGBQUAD);

	// We need a device context to get the DIB from
	hDC = GetDC(NULL);
	hPal = SelectPalette(hDC,hPal,FALSE);
	RealizePalette(hDC);

	// Allocate enough memory to hold bitmapinfoheader and color table
	hDIB = GlobalAlloc(GMEM_FIXED,dwLen);

	if (!hDIB){
		SelectPalette(hDC,hPal,FALSE);
		ReleaseDC(NULL,hDC);
		return NULL;
	}

	lpbi = (LPBITMAPINFOHEADER)hDIB;

	*lpbi = bi;

	// Call GetDIBits with a NULL lpBits param, so the device driver 
	// will calculate the biSizeImage field 
	GetDIBits(hDC, (HBITMAP)bitmap.GetSafeHandle(), 0L, (DWORD)bi.biHeight,
			(LPBYTE)NULL, (LPBITMAPINFO)lpbi, (DWORD)DIB_RGB_COLORS);

	bi = *lpbi;

	// If the driver did not fill in the biSizeImage field, then compute it
	// Each scan line of the image is aligned on a DWORD (32bit) boundary
	if (bi.biSizeImage == 0){
		bi.biSizeImage = ((((bi.biWidth * bi.biBitCount) + 31) & ~31) / 8) 
						* bi.biHeight;

		// If a compression scheme is used the result may infact be larger
		// Increase the size to account for this.
		if (dwCompression != BI_RGB)
			bi.biSizeImage = (bi.biSizeImage * 3) / 2;
	}

	// Realloc the buffer so that it can hold all the bits
	dwLen += bi.biSizeImage;
	if (handle = GlobalReAlloc(hDIB, dwLen, GMEM_MOVEABLE))
		hDIB = handle;
	else{
		GlobalFree(hDIB);

		// Reselect the original palette
		SelectPalette(hDC,hPal,FALSE);
		ReleaseDC(NULL,hDC);
		return NULL;
	}

	// Get the bitmap bits
	lpbi = (LPBITMAPINFOHEADER)hDIB;

	// FINALLY get the DIB
	BOOL bGotBits = GetDIBits( hDC, (HBITMAP)bitmap.GetSafeHandle(),
				0L,				// Start scan line
				(DWORD)bi.biHeight,		// # of scan lines
				(LPBYTE)lpbi 			// address for bitmap bits
				+ (bi.biSize + nColors * sizeof(RGBQUAD)),
				(LPBITMAPINFO)lpbi,		// address of bitmapinfo
				(DWORD)DIB_RGB_COLORS);		// Use RGB for color table

	if( !bGotBits )
	{
		GlobalFree(hDIB);
		
		SelectPalette(hDC,hPal,FALSE);
		ReleaseDC(NULL,hDC);
		return NULL;
	}

	SelectPalette(hDC,hPal,FALSE);
	ReleaseDC(NULL,hDC);
	return hDIB;
}

BYTE* CWrapBitmap::GetpBuffer()
{
	DWORD dwCount,dwValue;
	if(!m_hBitmap)
	{
		return NULL;
	}
	dwCount=GetWidthBytes()*GetHeight();	//得到buf大小
	if(m_pBuffer)
	{
		delete[] m_pBuffer;
		m_pBuffer=NULL;
	}
	m_pBuffer=new BYTE[dwCount];	//(BYTE*)GlobalAlloc(GPTR,dwCount);
	dwValue=m_Bitmap.GetBitmapBits(dwCount,m_pBuffer);
	return m_pBuffer;
}

CBitmap* CWrapBitmap::GetpBitmap()
{
	if(!m_hBitmap)
	{
		return NULL;
	}
	return &m_Bitmap;
}

BOOL CWrapBitmap::is256()
{
	BITMAP bm;
	if(!m_hBitmap)
	{
		return false;
	}
	m_Bitmap.GetBitmap(&bm);
		
	int nColors = (1 << bm.bmPlanes * bm.bmBitsPixel);
	if( nColors == 256 ) 
		return true;

	return false;

}

int CWrapBitmap::GetWidth()
{
	BITMAP bm;
	if(!m_hBitmap)
	{
		return false;
	}
	m_Bitmap.GetBitmap(&bm);
	return bm.bmWidth;
}

int CWrapBitmap::GetHeight()
{
	BITMAP bm;
	if(!m_hBitmap)
	{
		return false;
	}
	m_Bitmap.GetBitmap(&bm);
	return bm.bmHeight;
}

int CWrapBitmap::GetWidthBytes()
{
	BITMAP bm;
	if(!m_hBitmap)
	{
		return false;
	}
	m_Bitmap.GetBitmap(&bm);
	return bm.bmWidthBytes;
}

long CWrapBitmap::GetSize()
{
	BITMAP bm;
	if(!m_hBitmap)
	{
		return false;
	}
	m_Bitmap.GetBitmap(&bm);
	return bm.bmWidthBytes*bm.bmHeight;
}

void CWrapBitmap::YuZhi(BYTE btYu)
{
	GetpBuffer();
	if(!m_pBuffer)
	{
		return;
	}
	for(int i=0;i<GetSize();i++)
	{
		if(m_pBuffer[i]>btYu)
		m_pBuffer[i]=255;
		else m_pBuffer[i]=0;
	}
	m_Bitmap.SetBitmapBits(GetSize(),m_pBuffer);
}