imageobject.cpp

一些自己做的关于图象处理的程序（如傅立叶变换

	BITMAPFILEHEADER *pOldBFH, *pNewBFH;
	BITMAPINFOHEADER *pOldBIH, *pNewBIH;
	RGBQUAD *pOldPalette, *pNewPalette;
	unsigned char *pOldBits, *pNewBits;
	int nOldWidthBytes, nNewWidthBytes;
	int nNumColors;
	
	pOldBuffer = (unsigned char *) GetDIBPointer( &nOldWidthBytes, m_nBits, &nNewWidthBytes, nNewWidth );
	if( pOldBuffer == NULL ) return( FALSE );
	
	pOldBFH = (BITMAPFILEHEADER *) pOldBuffer;
	pOldBIH = (BITMAPINFOHEADER *) &pOldBuffer[sizeof(BITMAPFILEHEADER)];
	nNumColors = m_nColors;
	pOldPalette = (RGBQUAD *) &pOldBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)];
	pOldBits = (unsigned char *) &pOldBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+nNumColors*sizeof(RGBQUAD)];
	
	dwNewMemorySize = (DWORD) nNumColors * sizeof( RGBQUAD ) + sizeof( BITMAPFILEHEADER ) + sizeof( BITMAPINFOHEADER ) + nNewWidthBytes * nNewHeight;
	m_nLastError = IMAGELIB_MEMORY_ALLOCATION_ERROR;
	hNewMemory = ::GlobalAlloc( GMEM_MOVEABLE | GMEM_ZEROINIT, dwNewMemorySize );
	if( hNewMemory == NULL ){
		::GlobalUnlock( m_hDib );
		return( FALSE );
	}
	
	m_nLastError = IMAGELIB_MEMORY_LOCK_ERROR;
	pNewBuffer = (unsigned char *) ::GlobalLock( hNewMemory );
	if( pNewBuffer == NULL ){
		::GlobalFree( hNewMemory );
		::GlobalUnlock( m_hDib );
		return( FALSE );
	}
	
	pNewBFH = (BITMAPFILEHEADER *) pNewBuffer;
	pNewBIH = (BITMAPINFOHEADER *) &pNewBuffer[sizeof(BITMAPFILEHEADER)];
	pNewPalette = (RGBQUAD *) &pNewBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)];
	pNewBits = (unsigned char *) &pNewBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+nNumColors*sizeof(RGBQUAD)];
	
	*pNewBFH = *pOldBFH;
	*pNewBIH = *pOldBIH;
	pNewBIH->biSizeImage = nNewWidthBytes * nNewHeight;
	pNewBIH->biWidth = nNewWidth;
	pNewBIH->biHeight = nNewHeight;
	if( nNumColors != 0 ) memcpy( pNewPalette, pOldPalette, nNumColors * sizeof( RGBQUAD ) );
	
	m_nWidth = nNewWidth;
	m_nHeight = nNewHeight;
	
	if( nDegrees == 90 ) Rotate90( pNewBits, pOldBits );
	else Rotate270( pNewBits, pOldBits );
	
	::GlobalUnlock( m_hDib );
	::GlobalUnlock( hNewMemory );
	::GlobalFree( m_hDib );
	m_hDib = hNewMemory;
	
	m_nLastError = IMAGELIB_SUCCESS;
	
	return( TRUE );
	
}

void CImageObject::Rotate90( unsigned char *pNewBits, unsigned char *pOldBits )
{
	
	int nOldWidth, nOldHeight, nOldWidthBytes, nNewWidthBytes;
	nOldWidth = m_nHeight;
	nOldHeight = m_nWidth;
	
	unsigned char *pTemp;
	unsigned char Data, Data1, Data2, Data3, Data4, Mask, Shift;
	int x, y;
	
	switch( m_nBits )
	{
	case 1:
		nOldWidthBytes = ( nOldWidth + 7 ) / 8;
		while( ( nOldWidthBytes & 3 ) != 0 ) nOldWidthBytes++;
		nNewWidthBytes = ( m_nWidth + 7 ) / 8;
		while( ( nNewWidthBytes & 3 ) != 0 ) nNewWidthBytes++;
		for( y=0; y<m_nHeight; y++ )
		{
			pTemp = pNewBits;
			pTemp += ( ( m_nHeight - 1 - y ) * nNewWidthBytes );
			for( x=0; x<m_nWidth; x++ )
			{
				Data = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+(y/8)];
				Data >>= ( 7 - ( y & 7 ) );
				Data &= 0x01;
				Shift = ( 7 - ( ( m_nWidth - 1 - x ) & 7 ) );
				Mask = 1 << Shift;
				Data <<= Shift;
				pTemp[(m_nWidth-1-x)/8] &= ( Mask ^ 0xff );
				pTemp[(m_nWidth-1-x)/8] |= Data;
			}
		}
		break;
	case 4:
		nOldWidthBytes = ( nOldWidth + 1 ) / 2;
		while( ( nOldWidthBytes & 3 ) != 0 ) 
		{
			nOldWidthBytes++;
		}

		nNewWidthBytes = ( m_nWidth + 1 ) / 2;
		while( ( nNewWidthBytes & 3 ) != 0 ) 
		{
			nNewWidthBytes++;
		}

		for( y=0; y<m_nHeight; y++ )
		{
			pTemp = pNewBits;
			pTemp += ( ( m_nHeight - 1 - y ) * nNewWidthBytes );
			for( x=0; x<m_nWidth; x++ )
			{
				Data = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+(y/2)];
				if( !( y & 1 ) ) Data >>= 4;
				else Data &= 0x0f;
				if( ( x & 1 ) )
				{
					Data <<= 4;
					pTemp[(m_nWidth-1-x)/2] &= 0x0f;
					pTemp[(m_nWidth-1-x)/2] |= Data;
				}
				else
				{
					pTemp[(m_nWidth-1-x)/2] &= 0xf0;
					pTemp[(m_nWidth-1-x)/2] |= Data;
				}
			}
		}
		break;
	case 8:
		nOldWidthBytes = nOldWidth;
		while( ( nOldWidthBytes & 3 ) != 0 ) 
		{
			nOldWidthBytes++;
		}

		nNewWidthBytes = m_nWidth;
		while( ( nNewWidthBytes & 3 ) != 0 ) 
		{
			nNewWidthBytes++;
		}

		for( y=0; y<m_nHeight; y++ )
		{
			pTemp = pNewBits;
			pTemp += ( ( m_nHeight - 1 - y ) * nNewWidthBytes );
			for( x=0; x<m_nWidth; x++ )
			{
				Data = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+y];
				pTemp[m_nWidth-1-x] = Data;
			}
		}
		break;
	case 16:
		nOldWidthBytes = nOldWidth * 2;
		while( ( nOldWidthBytes & 3 ) != 0 ) 
		{
			nOldWidthBytes++;
		}

		nNewWidthBytes = m_nWidth * 2;
		while( ( nNewWidthBytes & 3 ) != 0 ) 
		{
			nNewWidthBytes++;
		}

		for( y=0; y<m_nHeight; y++ )
		{
			pTemp = pNewBits;
			pTemp += ( ( m_nHeight - 1 - y ) * nNewWidthBytes );
			for( x=0; x<m_nWidth; x++ )
			{
				Data1 = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+y*2];
				Data2 = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+y*2+1];
				pTemp[(m_nWidth-1-x)*2] = Data1;
				pTemp[(m_nWidth-1-x)*2+1] = Data2;
			}
		}
		break;
	case 24:
		nOldWidthBytes = nOldWidth * 3;
		while( ( nOldWidthBytes & 3 ) != 0 ) 
		{
			nOldWidthBytes++;
		}

		nNewWidthBytes = m_nWidth * 3;
		while( ( nNewWidthBytes & 3 ) != 0 ) 
		{
			nNewWidthBytes++;
		}

		for( y=0; y<m_nHeight; y++ )
		{
			pTemp = pNewBits;
			pTemp += ( ( m_nHeight - 1 - y ) * nNewWidthBytes );
			for( x=0; x<m_nWidth; x++ )
			{
				Data1 = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+y*3];
				Data2 = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+y*3+1];
				Data3 = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+y*3+2];
				pTemp[(m_nWidth-1-x)*3] = Data1;
				pTemp[(m_nWidth-1-x)*3+1] = Data2;
				pTemp[(m_nWidth-1-x)*3+2] = Data3;
			}
		}
		break;
	case 32:
		nOldWidthBytes = nOldWidth * 4;
		while( ( nOldWidthBytes & 3 ) != 0 ) 
		{
			nOldWidthBytes++;
		}

		nNewWidthBytes = m_nWidth * 4;
		while( ( nNewWidthBytes & 3 ) != 0 ) 
		{
			nNewWidthBytes++;
		}

		for( y=0; y<m_nHeight; y++ )
		{
			pTemp = pNewBits;
			pTemp += ( ( m_nHeight - 1 - y ) * nNewWidthBytes );
			for( x=0; x<m_nWidth; x++ )
			{
				Data1 = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+y*4];
				Data2 = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+y*4+1];
				Data3 = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+y*4+2];
				Data4 = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+y*4+3];
				pTemp[(m_nWidth-1-x)*4] = Data1;
				pTemp[(m_nWidth-1-x)*4+1] = Data2;
				pTemp[(m_nWidth-1-x)*4+2] = Data3;
				pTemp[(m_nWidth-1-x)*4+3] = Data4;
			}
		}
		break;
	}
		
}

void CImageObject::Rotate270( unsigned char *pNewBits, unsigned char *pOldBits )
{
	
	int nOldWidth, nOldHeight, nOldWidthBytes, nNewWidthBytes;
	nOldWidth = m_nHeight;
	nOldHeight = m_nWidth;
	
	unsigned char *pTemp;
	unsigned char Data, Data1, Data2, Data3, Data4, Mask, Shift;
	int x, y, yy;
	
	switch( m_nBits ){
	case 1:
		nOldWidthBytes = ( nOldWidth + 7 ) / 8;
		while( ( nOldWidthBytes & 3 ) != 0 ) nOldWidthBytes++;
		nNewWidthBytes = ( m_nWidth + 7 ) / 8;
		while( ( nNewWidthBytes & 3 ) != 0 ) nNewWidthBytes++;
		for( y=0; y<m_nHeight; y++ ){
			yy = m_nHeight - 1 - y;
			pTemp = pNewBits;
			pTemp += ( ( m_nHeight - 1 - y ) * nNewWidthBytes );
			for( x=0; x<m_nWidth; x++ ){
				Data = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+(yy/8)];
				Data >>= ( 7 - ( yy & 7 ) );
				Data &= 0x01;
				Shift = ( 7 - ( x & 7 ) );
				Mask = 1 << Shift;
				Data <<= Shift;
				pTemp[x/8] &= ( Mask ^ 0xff );
				pTemp[x/8] |= Data;
			}
		}
		break;
	case 4:
		nOldWidthBytes = ( nOldWidth + 1 ) / 2;
		while( ( nOldWidthBytes & 3 ) != 0 ) nOldWidthBytes++;
		nNewWidthBytes = ( m_nWidth + 1 ) / 2;
		while( ( nNewWidthBytes & 3 ) != 0 ) nNewWidthBytes++;
		for( y=0; y<m_nHeight; y++ ){
			yy = m_nHeight - 1 - y;
			pTemp = pNewBits;
			pTemp += ( ( m_nHeight - 1 - y ) * nNewWidthBytes );
			for( x=0; x<m_nWidth; x++ ){
				Data = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+(yy/2)];
				if( !( yy & 1 ) ) Data >>= 4;
				else Data &= 0x0f;
				if( !( x & 1 ) ){
					Data <<= 4;
					pTemp[x/2] &= 0x0f;
					pTemp[x/2] |= Data;
				}
				else{
					pTemp[x/2] &= 0xf0;
					pTemp[x/2] |= Data;
				}
			}
		}
		break;
	case 8:
		nOldWidthBytes = nOldWidth;
		while( ( nOldWidthBytes & 3 ) != 0 ) nOldWidthBytes++;
		nNewWidthBytes = m_nWidth;
		while( ( nNewWidthBytes & 3 ) != 0 ) nNewWidthBytes++;
		for( y=0; y<m_nHeight; y++ ){
			yy = m_nHeight - 1 - y;
			pTemp = pNewBits;
			pTemp += ( ( m_nHeight - 1 - y ) * nNewWidthBytes );
			for( x=0; x<m_nWidth; x++ ){
				Data = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+yy];
				pTemp[x] = Data;
			}
		}
		break;
	case 16:
		nOldWidthBytes = nOldWidth * 2;
		while( ( nOldWidthBytes & 3 ) != 0 ) nOldWidthBytes++;
		nNewWidthBytes = m_nWidth * 2;
		while( ( nNewWidthBytes & 3 ) != 0 ) nNewWidthBytes++;
		for( y=0; y<m_nHeight; y++ ){
			yy = m_nHeight - 1 - y;
			pTemp = pNewBits;
			pTemp += ( ( m_nHeight - 1 - y ) * nNewWidthBytes );
			for( x=0; x<m_nWidth; x++ ){
				Data1 = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+yy*2];
				Data2 = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+yy*2+1];
				pTemp[x*2] = Data1;
				pTemp[x*2+1] = Data2;
			}
		}
		break;
	case 24:
		nOldWidthBytes = nOldWidth * 3;
		while( ( nOldWidthBytes & 3 ) != 0 ) nOldWidthBytes++;
		nNewWidthBytes = m_nWidth * 3;
		while( ( nNewWidthBytes & 3 ) != 0 ) nNewWidthBytes++;
		for( y=0; y<m_nHeight; y++ ){
			yy = m_nHeight - 1 - y;
			pTemp = pNewBits;
			pTemp += ( ( m_nHeight - 1 - y ) * nNewWidthBytes );
			for( x=0; x<m_nWidth; x++ ){
				Data1 = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+yy*3];
				Data2 = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+yy*3+1];
				Data3 = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+yy*3+2];
				pTemp[x*3] = Data1;
				pTemp[x*3+1] = Data2;
				pTemp[x*3+2] = Data3;
			}
		}
		break;
	case 32:
		nOldWidthBytes = nOldWidth * 4;
		while( ( nOldWidthBytes & 3 ) != 0 ) nOldWidthBytes++;
		nNewWidthBytes = m_nWidth * 4;
		while( ( nNewWidthBytes & 3 ) != 0 ) nNewWidthBytes++;
		for( y=0; y<m_nHeight; y++ ){
			yy = m_nHeight - 1 - y;
			pTemp = pNewBits;
			pTemp += ( ( m_nHeight - 1 - y ) * nNewWidthBytes );
			for( x=0; x<m_nWidth; x++ ){
				Data1 = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+yy*4];
				Data2 = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+yy*4+1];
				Data3 = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+yy*4+2];
				Data4 = pOldBits[(m_nWidth-1-x)*nOldWidthBytes+yy*4+3];
				pTemp[x*4] = Data1;
				pTemp[x*4+1] = Data2;
				pTemp[x*4+2] = Data3;
				pTemp[x*4+3] = Data4;
			}
		}
		break;
		}
		
}

BOOL CImageObject::Invert( void )
{
	
	unsigned char *pBuffer, *pTemp1, *pTemp2;
	BITMAPINFOHEADER *pBIH;
	RGBQUAD *pPalette;
	unsigned char *pBits;
	int nWidthBytes;
	int nNumColors;
	int y, yy;
	unsigned char *pTemp;
	
	pBuffer = (unsigned char *) GetDIBPointer( &nWidthBytes );
	if( pBuffer == NULL ) return( FALSE );
	
	pBIH = (BITMAPINFOHEADER *) &pBuffer[sizeof(BITMAPFILEHEADER)];
	nNumColors = m_nColors;
	pPalette = (RGBQUAD *) &pBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)];
	pBits = (unsigned char *) &pBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+nNumColors*sizeof(RGBQUAD)];
	
	pTemp = new unsigned char [nWidthBytes];
	if( pTemp != NULL ){
		yy = pBIH->biHeight;
		if( !( yy & 1 ) ) yy /= 2;
		else yy = ( yy / 2 ) + 1;
		for( y=0; y<yy; y++ ){
			pTemp1 = pBits;
			pTemp1 += ( ( pBIH->biHeight - 1 - y ) * nWidthBytes );
			pTemp2 = pBits;
			pTemp2 += y * nWidthBytes;
			memcpy( pTemp, pTemp1, nWidthBytes );
			memcpy( pTemp1, pTemp2, nWidthBytes );
			memcpy( pTemp2, pTemp, nWidthBytes );
		}
		delete [] pTemp;
	}
	
	::GlobalUnlock( m_hDib );
	
	m_nLastError = IMAGELIB_SUCCESS;
	
	return( TRUE );
	
}

BOOL CImageObject::Reverse( void )
{
	
	unsigned char *pBuffer, *pTemp;
	BITMAPINFOHEADER *pBIH;
	RGBQUAD *pPalette;
	unsigned char *pBits;
	int nWidthBytes;
	int nNumColors;
	int y, x, xx, xt, nWidth;
	unsigned char Data, Tmp, Data1, Tmp1;
	
	pBuffer = (unsigned char *) GetDIBPointer( &nWidthBytes );
	if( pBuffer == NULL ) return( FALSE );
	
	pBIH = (BITMAPINFOHEADER *) &pBuffer[sizeof(BITMAPFILEHEADER)];
	nNumColors = m_nColors;
	pPalette = (RGBQUAD *) &pBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)];
	pBits = (unsigned char *) &pBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+nNumColors*sizeof(RGBQUAD)];
	
	xx = pBIH->biWidth;
	if( !( xx & 1 ) ) xx /= 2;
	else xx = ( xx / 2 ) + 1;
	nWidth = pBIH->biWidth;
	if( m_nBits == 4 ){
		xx = pBIH->biWidth;
		xx = ( xx + 3 ) / 4;
		nWidth = ( pBIH->biWidth + 1 ) / 2;
	}
	else if( m_nBits == 1 ){
		xx = pBIH->biWidth;
		xx = ( xx + 15 ) / 16;
		nWidth = ( pBIH->biWidth + 7 ) / 8;
	}
	
	for( y=0; y<pBIH->biHeight; y++ ){
		pTemp = pBits;
		pTemp += y * nWidthBytes;
		switch( m_nBits ){
		case 1:
			for( x=0; x<xx; x++ ){
				xt = nWidth - 1 - x;
				Data = pTemp[x];
				Data1 = Data << 7;
				Data1 |= ( ( Data & 0x02 ) << 5 );
				Data1 |= ( ( Data & 0x04 ) << 3 );
				Data1 |= ( ( Data & 0x08 ) << 1 );
				Data1 |= ( ( Data & 0x10 ) >> 1 );
				Data1 |= ( ( Data & 0x20 ) >> 3 );
				Data1 |= ( ( Data & 0x40 ) >> 5 );
				Data1 |= ( ( Data & 0x80 ) >> 7 );
				
				Tmp = pTemp[xt];
				Tmp1 = Tmp << 7;
				Tmp1 |= ( ( Tmp & 0x02 ) << 5 );
				Tmp1 |= ( ( Tmp & 0x04 ) << 3 );
				Tmp1 |= ( ( Tmp & 0x08 ) << 1 );
				Tmp1 |= ( ( Tmp & 0x10 ) >> 1 );