imageobject.cpp

分水岭算法

// ImageObject.cpp: implementation of the CImageObject class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "ImageObject.h"
#include "ImageLoad.h"

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

IMPLEMENT_DYNCREATE( CImageObject, CObject ) 

char *CImageObject::pszExtensions[] = { ".bmp", ".gif", ".pcx", ".tga", ".jpg", ".tif", "" };

//////////////////////////////////////////////////
// Constructor and destructor
//
CImageObject::CImageObject()
{
	m_nWidth = m_nHeight = m_nBits = m_nColors = m_nImageType = 0;
	m_nX = m_nY = 0;
	m_nLastError = 0;
	m_hDib = NULL;
	m_nPaletteCreationType = JGPT_FIXED_PALETTE;
    m_pszFileName = NULL;
    m_pLogPalette = NULL;
	m_nQuality = 80;
	m_pDib = NULL;
	m_lBufSize = 0;
}

CImageObject::CImageObject( const char *pszFileName, CDC *pDC, int nX, int nY )
{
	m_nWidth = m_nHeight = m_nBits = m_nColors = m_nImageType = 0;
	m_nX = m_nY = 0;
	m_nLastError = 0;
	m_hDib = NULL;
	m_nPaletteCreationType = JGPT_FIXED_PALETTE;
	m_pszFileName = NULL;
	m_pLogPalette = NULL;
	m_nQuality = 80;
	m_pDib = NULL;
	m_lBufSize = 0;
	LoadFromFile( pszFileName, pDC, nX, nY );
}

void CImageObject::operator=( const CImageObject &ImageObject )
{
	DestroyImage();

	m_nLastError = ImageObject.m_nLastError;

    m_nWidth = ImageObject.m_nWidth;
	m_nHeight = ImageObject.m_nHeight;
	m_nPlanes = ImageObject.m_nPlanes;
	m_nBits = ImageObject.m_nBits;
	m_nColors = ImageObject.m_nColors;
	m_nImageType = ImageObject.m_nImageType;
	
	m_nX = ImageObject.m_nX;
	m_nY = ImageObject.m_nY;

	m_nScreenPlanes = ImageObject.m_nScreenPlanes;
	m_nScreenBits = ImageObject.m_nScreenBits;
	m_nPaletteInBytes = ImageObject.m_nPaletteInBytes;
	m_nQuality = ImageObject.m_nQuality;
	m_nPaletteCreationType = ImageObject.m_nPaletteCreationType;
	
	int nNumColors = m_nColors;
	int nWidthBytes = GetWidthInBytes( m_nBits, m_nWidth );
	
	if( ImageObject.m_hDib != NULL )
	{
		DWORD dwSize = ::GlobalSize( ImageObject.m_hDib );
		char *pData = ( char * )::GlobalLock( ImageObject.m_hDib );
		if( pData != NULL )
		{
			HGLOBAL hGlobal = ::GlobalAlloc( GMEM_MOVEABLE | GMEM_ZEROINIT, dwSize );
			if( hGlobal != NULL )
			{
				char *pDestData = ( char * )::GlobalLock( hGlobal );
				if( pDestData != NULL )
				{
					memcpy( pDestData, pData, dwSize );
					if( nNumColors != 0 )
						CreatePaletteFromDIB( ( RGBQUAD * )&pData[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)], nNumColors );
					else if( ImageObject.m_pLogPalette != NULL )
					{
						m_pLogPalette = (LOGPALETTE *) new char[ sizeof( LOGPALETTE ) + ImageObject.m_pLogPalette->palNumEntries * sizeof( PALETTEENTRY ) ];
						if( m_pLogPalette != NULL )
						{
							for( int i=0; i<ImageObject.m_pLogPalette->palNumEntries; i++ )
								m_pLogPalette[i] = ImageObject.m_pLogPalette[i];
							m_Palette.CreatePalette( m_pLogPalette );
						}
					}
					::GlobalUnlock( hGlobal );
					m_hDib = hGlobal;
				}
				else ::GlobalFree( hGlobal );
			}
			::GlobalUnlock( ImageObject.m_hDib );
		}
	}
	if( ImageObject.m_pszFileName != NULL )
	{
		m_pszFileName = new char [strlen( ImageObject.m_pszFileName ) + 1 ];
		strcpy( m_pszFileName, ImageObject.m_pszFileName );
	}
}

CImageObject::~CImageObject()
{
	if(m_pDib)
		::GlobalUnlock(m_hDib);
	if(m_hDib)
		::GlobalFree( m_hDib );
	if(m_pszFileName != NULL )
	{
		delete[] m_pszFileName;
		m_pszFileName = NULL;
	}
}

//////////////////////////////////////////
// Get/set member functions
//
int CImageObject::GetExtensionIndex( const char *pszFileName )
{
	int Index = 0;
	char *pszExt;
	pszExt = ( char * )&pszFileName[ strlen( pszFileName ) - 4 ];
	while( pszExtensions[ Index ][ 0 ] )
	{
		if( !stricmp( pszExt, pszExtensions[ Index ] ) ) 
			return( Index + 1 );
		Index++;
	}
	return( -1 );
}

int CImageObject::GetLastError( void )
{
	return( m_nLastError );
}

bool CImageObject::IsLoaded( void )
{
	return( m_hDib != NULL );
}

int CImageObject::GetWidth( void )
{
	return( m_nWidth );
}

int CImageObject::GetHeight( void )
{
	return( m_nHeight );
}

int CImageObject::GetBits( void )
{
	return( m_nBits );
}

int CImageObject::GetColors( void )
{
	return( m_nColors );
}

HGLOBAL CImageObject::GetDib( void )
{
	return( m_hDib );
}

void CImageObject::SetDib( HGLOBAL hDib )
{
	m_hDib = hDib;
}


long CImageObject::GetSize()
{
   return (long) sizeof(BITMAPFILEHEADER)
        +sizeof(BITMAPINFOHEADER)
		+m_nColors*sizeof(RGBQUAD)
		+GetWidthInBytes(m_nBits,m_nWidth)*m_nHeight;
}

int CImageObject::GetDestX()
{
	return m_nX;
}

int CImageObject::GetDestY()
{
	return m_nY;
}

BYTE * CImageObject::GetDibPoint(void)
{
	return(m_pDib);
}
// Palette
int CImageObject::GetPaletteInBytes( void )
{
	return( m_nPaletteInBytes );
}

CPalette *CImageObject::GetPalette( void )
{
	return( &m_Palette );
}

LOGPALETTE *CImageObject::GetLogPalette( void )
{
	return( m_pLogPalette );
}

void CImageObject::SetLogPalette( LOGPALETTE *pLogPalette )
{
	m_pLogPalette = pLogPalette;
}

void CImageObject::SetPaletteCreationType( int nType )
{
	m_nPaletteCreationType = nType;
}

int CImageObject::GetPaletteCreationType( void )
{
	return( m_nPaletteCreationType );
}

void CImageObject::SetQuality( int nQuality )
{
	m_nQuality = nQuality;
}

/*
int CImageObject::GetImageType( const char *pszFileName )
{
	return( ::FileType( pszFileName ) );
}
*/
char *CImageObject::GetImageName()
{
  return( m_pszFileName );
}

int CImageObject::GetImageType( void )
{
	return( m_nImageType );
}

//////////////////////////////////////////
// Get/set member functions
//
/*
bool CImageObject::GetImageInfo( const char *pszFileName, int *pnWidth,
	int *pnHeight, int *pnPlanes, int *pnBitsPerPixel, int *pnNumColors )
{
	int nImageType;
	nImageType = ::FileType( pszFileName );
	if( nImageType == 0 )
	{
		m_nLastError = GL_UNSUPPORTED_FILETYPE;
		return( false );
	}
	switch( nImageType )
	{
		case GT_BMP:
			if( ::GetBMPInfo( pszFileName, pnWidth, pnHeight, pnPlanes, pnBitsPerPixel, pnNumColors ) )
				return( true );
		  break;
		case GT_GIF:
			if( ::GetGIFInfo( pszFileName, pnWidth, pnHeight, pnPlanes, pnBitsPerPixel, pnNumColors ) )
				return( true );
		  break;
		case GT_JPG:
			if( ::GetJPGInfo( pszFileName, pnWidth, pnHeight, pnPlanes, pnBitsPerPixel, pnNumColors ) )
				return( true );
		  break;
		case GT_PCX:
			if( ::GetPCXInfo( pszFileName, pnWidth, pnHeight, pnPlanes, pnBitsPerPixel, pnNumColors ) )
				return( true );
		  break;
		case GT_TGA:
			if( ::GetTGAInfo( pszFileName, pnWidth, pnHeight, pnPlanes, pnBitsPerPixel, pnNumColors ) )
				return( true );
		  break;
		case GT_TIF:
			if( ::GetTIFInfo( pszFileName, pnWidth, pnHeight, pnPlanes, pnBitsPerPixel, pnNumColors ) )
				return( true );
		  break;
	}
	return( false );
}
*/
bool CImageObject::GetImageInfo( ImageINFO *gi )
{
	int nWidth, nHeight, nPlanes, nColorDepth, nColorNumber;

	if( m_nImageType == 0 )
	{
		m_nLastError = GL_UNSUPPORTED_FILETYPE;
		return( false );
	}
	switch( m_nImageType )
	{
		case GT_BMP:
			if( ::GetBMPInfo( m_pszFileName, &nWidth, &nHeight, &nPlanes, &nColorDepth, &nColorNumber ) )
			{
			  gi->nWidth = nWidth;
			  gi->nHeight = nHeight;
			  gi->nPlanes = nPlanes;
			  gi->nColorDepth = nColorDepth;
			  gi->nColorNumber = nColorNumber;
				return( true );
			}
		  break;
		case GT_GIF:
			if( ::GetGIFInfo( m_pszFileName, &nWidth, &nHeight, &nPlanes, &nColorDepth, &nColorNumber ) )
			{
			  gi->nWidth = nWidth;
			  gi->nHeight = nHeight;
			  gi->nPlanes = nPlanes;
			  gi->nColorDepth = nColorDepth;
			  gi->nColorNumber = nColorNumber;
				return( true );
			}
		  break;
		case GT_JPG:
			if( ::GetJPGInfo( m_pszFileName, &nWidth, &nHeight, &nPlanes, &nColorDepth, &nColorNumber ) )
			{
			  gi->nWidth = nWidth;
			  gi->nHeight = nHeight;
			  gi->nPlanes = nPlanes;
			  gi->nColorDepth = nColorDepth;
			  gi->nColorNumber = nColorNumber;
				return( true );
			}
		  break;
		case GT_PCX:
			if( ::GetPCXInfo( m_pszFileName, &nWidth, &nHeight, &nPlanes, &nColorDepth, &nColorNumber ) )
			{
			  gi->nWidth = nWidth;
			  gi->nHeight = nHeight;
			  gi->nPlanes = nPlanes;
			  gi->nColorDepth = nColorDepth;
			  gi->nColorNumber = nColorNumber;
				return( true );
			}
		  break;
		case GT_TGA:
			if( ::GetTGAInfo( m_pszFileName, &nWidth, &nHeight, &nPlanes, &nColorDepth, &nColorNumber ) )
			{
			  gi->nWidth = nWidth;
			  gi->nHeight = nHeight;
			  gi->nPlanes = nPlanes;
			  gi->nColorDepth = nColorDepth;
			  gi->nColorNumber = nColorNumber;
				return( true );
			}
		  break;
		case GT_TIF:
			if( ::GetTIFInfo( m_pszFileName, &nWidth, &nHeight, &nPlanes, &nColorDepth, &nColorNumber ) )
			{
			  gi->nWidth = nWidth;
			  gi->nHeight = nHeight;
			  gi->nPlanes = nPlanes;
			  gi->nColorDepth = nColorDepth;
			  gi->nColorNumber = nColorNumber;
				return( true );
			}
		  break;
	}
	return( false );
}

ImageINFO *CImageObject::GetImageInfo( void )
{
	int nWidth, nHeight, nPlanes, nColorDepth, nColorNumber;

	if( m_nImageType == 0 )
	{
		m_nLastError = GL_UNSUPPORTED_FILETYPE;
		return( false );
	}
	switch( m_nImageType )
	{
		case GT_BMP:
			if( ::GetBMPInfo( m_pszFileName, &nWidth, &nHeight, &nPlanes, &nColorDepth, &nColorNumber ) )
			{
      	ImageINFO *gi = new ImageINFO;
			  gi->nWidth = nWidth;
			  gi->nHeight = nHeight;
			  gi->nPlanes = nPlanes;
			  gi->nColorDepth = nColorDepth;
			  gi->nColorNumber = nColorNumber;
				return( gi );
			}
		  break;
		case GT_GIF:
			if( ::GetGIFInfo( m_pszFileName, &nWidth, &nHeight, &nPlanes, &nColorDepth, &nColorNumber ) )
			{
      	ImageINFO *gi = new ImageINFO;
			  gi->nWidth = nWidth;
			  gi->nHeight = nHeight;
			  gi->nPlanes = nPlanes;
			  gi->nColorDepth = nColorDepth;
			  gi->nColorNumber = nColorNumber;
				return( gi );
			}
		  break;
		case GT_JPG:
			if( ::GetJPGInfo( m_pszFileName, &nWidth, &nHeight, &nPlanes, &nColorDepth, &nColorNumber ) )
			{
      	ImageINFO *gi = new ImageINFO;
			  gi->nWidth = nWidth;
			  gi->nHeight = nHeight;
			  gi->nPlanes = nPlanes;
			  gi->nColorDepth = nColorDepth;
			  gi->nColorNumber = nColorNumber;
				return( gi );
			}
		  break;
		case GT_PCX:
			if( ::GetPCXInfo( m_pszFileName, &nWidth, &nHeight, &nPlanes, &nColorDepth, &nColorNumber ) )
			{
      	ImageINFO *gi = new ImageINFO;
			  gi->nWidth = nWidth;
			  gi->nHeight = nHeight;
			  gi->nPlanes = nPlanes;
			  gi->nColorDepth = nColorDepth;
			  gi->nColorNumber = nColorNumber;
				return( gi );
			}
		  break;
		case GT_TGA:
			if( ::GetTGAInfo( m_pszFileName, &nWidth, &nHeight, &nPlanes, &nColorDepth, &nColorNumber ) )
			{
      	ImageINFO *gi = new ImageINFO;
			  gi->nWidth = nWidth;
			  gi->nHeight = nHeight;
			  gi->nPlanes = nPlanes;
			  gi->nColorDepth = nColorDepth;
			  gi->nColorNumber = nColorNumber;
				return( gi );
			}
		  break;
		case GT_TIF:
			if( ::GetTIFInfo( m_pszFileName, &nWidth, &nHeight, &nPlanes, &nColorDepth, &nColorNumber ) )
			{
      	ImageINFO *gi = new ImageINFO;
			  gi->nWidth = nWidth;
			  gi->nHeight = nHeight;
			  gi->nPlanes = nPlanes;
			  gi->nColorDepth = nColorDepth;
			  gi->nColorNumber = nColorNumber;
				return( gi );
			}
		  break;
	}
	return( NULL );
}

// Change color depth of the Image
bool CImageObject::SetColorDepth( int nColorDepth )
{
	m_nLastError = GL_SUCCESS;
	if( nColorDepth == m_nBits )
		return( true );
	int nOldWidthInBytes, nNewWidthInBytes;
	char *pBuffer = ( char * )GetDIBPointer( &nOldWidthInBytes, nColorDepth, &nNewWidthInBytes );
	if( pBuffer == NULL )
		return( false );

	BITMAPINFOHEADER *pOldBIH, *pNewBIH;
	BITMAPFILEHEADER *pOldBFH, *pNewBFH;
	RGBQUAD *pOldRGBPalette, *pNewRGBPalette;
	unsigned char *pOldBits, *pNewBits;
	int nOldColors, nNewColors;
	pOldBFH = ( BITMAPFILEHEADER * )pBuffer;
	pOldBIH = ( BITMAPINFOHEADER * )&pBuffer[ sizeof( BITMAPFILEHEADER ) ];
	pOldRGBPalette = ( RGBQUAD * )&pBuffer[ sizeof( BITMAPFILEHEADER ) + sizeof( BITMAPINFOHEADER ) ];
	nOldColors = m_nColors;
	nNewColors = 1 << nColorDepth;
	if( nColorDepth > 8 )
		nNewColors = 0;
	pOldBits = ( unsigned char * )&pBuffer[ sizeof( BITMAPFILEHEADER ) + sizeof( BITMAPINFOHEADER) + nOldColors * sizeof( RGBQUAD ) ];
	if( m_nBits >= 16 && nColorDepth < 16 )
	{
		if( m_pLogPalette != NULL )
			delete[] m_pLogPalette;
		m_pLogPalette = CreatePaletteFromBitmap( nNewColors, pOldBits, m_nBits, m_nWidth, m_nHeight );
	}

	HGLOBAL hGlobal;
	DWORD dwSize;
	dwSize = sizeof( BITMAPFILEHEADER ) + sizeof( BITMAPINFOHEADER ) + nNewColors * sizeof( RGBQUAD ) + m_nHeight * nNewWidthInBytes;
	hGlobal = ::GlobalAlloc( GMEM_MOVEABLE | GMEM_ZEROINIT, dwSize );
	if( hGlobal == NULL )
	{
		::GlobalUnlock( m_hDib );
		return( false );
	}
	pBuffer = (char *) ::GlobalLock( hGlobal );
	if( pBuffer == NULL )
	{
		::GlobalFree( hGlobal );
		::GlobalUnlock( m_hDib );
		return( false );
	}

	pNewBFH = ( BITMAPFILEHEADER * )pBuffer;
	pNewBIH = ( BITMAPINFOHEADER * )&pBuffer[ sizeof( BITMAPFILEHEADER ) ];
	pNewRGBPalette = ( RGBQUAD * )&pBuffer[ sizeof( BITMAPFILEHEADER ) + sizeof( BITMAPINFOHEADER ) ];
	*pNewBFH = *pOldBFH;
	*pNewBIH = *pOldBIH;
	int i, j = nNewColors;
	if( m_nBits < 16 && nColorDepth < 16 )
	{
		for( i=0; i<j; i++ )
			pNewRGBPalette[i] = pOldRGBPalette[i];
	}
	else if( m_nBits >= 16 )
	{
 		for( i=0; i<j; i++ )
		{
			pNewRGBPalette[ i ].rgbRed = m_pLogPalette->palPalEntry[ i ].peRed;
			pNewRGBPalette[ i ].rgbGreen = m_pLogPalette->palPalEntry[ i ].peGreen;
			pNewRGBPalette[ i ].rgbBlue = m_pLogPalette->palPalEntry[ i ].peBlue;
		}
	}

	pNewBIH->biBitCount = nColorDepth;
	pNewBIH->biSizeImage = nNewWidthInBytes * m_nHeight;
	pNewBIH->biClrUsed = nNewColors;
	pNewBFH->bfSize = sizeof( BITMAPFILEHEADER ) + sizeof( BITMAPINFOHEADER ) + nNewColors * sizeof( RGBQUAD ) + pNewBIH->biSizeImage;
	pNewBFH->bfOffBits = sizeof( BITMAPFILEHEADER ) + sizeof( BITMAPINFOHEADER ) + nNewColors * sizeof( RGBQUAD );
	pNewBits = ( unsigned char * )&pBuffer[ sizeof( BITMAPFILEHEADER ) + sizeof( BITMAPINFOHEADER ) + nNewColors * sizeof( RGBQUAD ) ];
	m_nPaletteInBytes = nNewColors * sizeof( RGBQUAD );
	for( int y=0; y<m_nHeight; y++ )
	{
		unsigned char ucRed, ucGreen, ucBlue;
		unsigned char *pSrc, *pDest;
		pSrc = pOldBits;