allimage.cpp

医学图象处理系统

#include "stdafx.h"
#include "AllImage.h"
#include "ImageProcess.h"

CAllImage::CAllImage()
{
	IsColorGifImage = IsColorPCXImage = FALSE;
}
CAllImage::~CAllImage()
{
}
CAllImage::CAllImage(CAllImage & source)
{
	CImage::CImage(source);
}
CAllImage::CAllImage(P_LONG width, P_LONG height, int PixelDepth,DWORD colornum)
{
	CImage::CImage(width, height, PixelDepth, colornum);
}
CAllImage::CAllImage(CAllImage &source, CPoint &LTp, CPoint &RBp)
{
	CImage::CImage(source, LTp, RBp);
}

BOOL CAllImage::ReadImageFromFile(LPCTSTR lpszFileName)
{
    CString FileName(lpszFileName);
    if(FileName.Right(3) == "jpg" ||FileName.Right(3) == "JPG")
    {
        return ReadImageAsJPG(FileName);
    }
	else if(FileName.Right(3) == "gif" ||FileName.Right(3) == "GIF")
    {
        return ReadImageAsGIF(FileName);
    }
	else if(FileName.Right(3) == "pcx" ||FileName.Right(3) == "PCX")
    {
        return ReadImageAsPCX(FileName);
    }
    else 
    {
		return CImage::ReadImageFromFile(lpszFileName);
    }    
}
BOOL CAllImage::SaveImageToFile(LPCTSTR lpszFileName)
{
    CString FileName(lpszFileName);
    if(FileName.Right(3) == "jpg" ||FileName.Right(3) == "JPG")
    {
        return SaveImageAsJPG(FileName);
    }
	else if(FileName.Right(3) == "gif" ||FileName.Right(3) == "GIF")
    {
		return SaveImageAsGIF(FileName);
	}
	else if(FileName.Right(3) == "pcx" ||FileName.Right(3) == "PCX")
    {
		return SaveImageAsPCX(FileName);
	}
    else 
	{
		return CImage::SaveImageToFile(lpszFileName);
    }    
}
BOOL CAllImage::ReadImageAsJPG(CString fileName)
{
	//DWORD UsedTime, StartTime = GetTickCount();
	UINT  width, height, Depth; 
	JpegFile::GetJPGDimensions(fileName, width, height, Depth);
	//UsedTime = GetTickCount() - StartTime;
	//TRACE("Read JPG  UsedTime = %d\n", UsedTime);
	m_wImageDepth    = Depth;
    m_wColorMapNum   = GetColorMapNum(m_wImageDepth);
    m_ImageWidth     = width;	
    m_ImageHeight    = height;
	m_nDibWidth      = (m_ImageWidth* m_wImageDepth/8+ 3) & ~3;
	m_nDibHeight     = m_ImageHeight;
	m_ImageSize      = m_nDibWidth*m_nDibHeight;
    m_HSIImageWidth  = (m_ImageWidth+3) & ~3;
	m_HSIImageHeight = m_ImageHeight;

	AllocateMemory();
	if(m_wImageDepth == 8)
		InitGrayImageInfo();
	else
		InitTrueColorInfo();
	GenerateRowAddress();
	JpegFile::JpegFileToRGB(fileName, RowAddress);
	
	/*JpegFile1 m_JPG;
	if(!m_JPG.OpenJPGFile(fileName))
		return false;
	
	m_wImageDepth    = m_JPG.comp_num* 8;
    m_wColorMapNum   = GetColorMapNum(m_wImageDepth);
    m_ImageWidth     = m_JPG.ImgWidth;	
    m_ImageHeight    = m_JPG.ImgHeight;
	m_nDibWidth      = (m_ImageWidth*m_wImageDepth/8+3) & ~3;
	m_nDibHeight     = m_ImageHeight;
	m_ImageSize      = m_nDibWidth*m_nDibHeight;
    m_HSIImageWidth  = (m_ImageWidth+3) & ~3;
	m_HSIImageHeight = m_ImageHeight;

    AllocateMemory();
	if(m_wImageDepth == 8)
		InitGrayImageInfo();
	else
		InitTrueColorInfo();
	GenerateRowAddress();

	m_JPG.ReadJPGData(RowAddress); //*/

	//UsedTime = GetTickCount() - StartTime;
	//TRACE("Read JPG  UsedTime = %d\n", UsedTime);
	return TRUE;
}
BOOL CAllImage::SaveImageAsJPG(CString fileName)
{	
	BOOL ok;
	if( m_wImageDepth==8 || m_wImageDepth==24)
	{
		ok = JpegFile::RGBToJpegFile(fileName, 
				 				     RowAddress, 
									 m_ImageWidth, m_ImageHeight, 
									 m_wImageDepth==24,
									 75);
	}
	else
	{
		long i, j, dataWidth = m_ImageWidth * 3;
		BYTE *m_buf = new BYTE[dataWidth*m_ImageHeight];
		BYTE **lpRow = new BYTE*[m_ImageHeight];
		for(lpRow[0]= m_buf, j= 1; j < m_ImageHeight; j++)
			lpRow[j] = lpRow[j-1] + dataWidth;
		
		RGBTRIPLE  temprgb;
		for( j= 0; j < m_ImageHeight; j++) 
		{
			RGBTRIPLE *LineAdd = (RGBTRIPLE *)lpRow[j];
			for( i= 0; i < m_ImageWidth; i++) 
			{
				temprgb = GetRGBPixel(i, j);
				*LineAdd++ = temprgb;
			}
		}
		ok = JpegFile::RGBToJpegFile(fileName, 
				     				 lpRow, 
									 m_ImageWidth, m_ImageHeight, 
									 true,
									 75);
		if(m_buf!=NULL) delete []m_buf;
	}//*/
	//lum = (int)(.299 * (double)(*pRed) + .587 * (double)(*pGrn) + .114 * (double)(*pBlu));
	return ok;
}
BOOL CAllImage::ReadImageAsGIF(CString fileName)
{
	BYTE *dataBuf;
	UINT  width,height; 
	dataBuf = GifImage.GIFReadFileToRGB(fileName, &width, &height);
	if (dataBuf==NULL||width<4||height<4)
	{
		AfxMessageBox("Read JPG file is failed");
		AfxThrowMemoryException();
		return FALSE;
	}
    m_wImageDepth    = 24;
    m_wColorMapNum   = GetColorMapNum(m_wImageDepth);
    m_ImageWidth     = width;	
    m_ImageHeight    = height;
	m_nDibWidth      = (m_ImageWidth*m_wImageDepth/8+3) & ~3;
	m_nDibHeight     = m_ImageHeight;
	m_ImageSize      = m_nDibWidth*m_nDibHeight;
    m_HSIImageWidth  = (m_ImageWidth+3) & ~3;
	m_HSIImageHeight = m_ImageHeight;

    AllocateMemory();
	InitTrueColorInfo();
	GenerateRowAddress();

	JpegFile::BGRFromRGB(dataBuf, m_ImageWidth, m_ImageHeight);
	long dataWidth = m_ImageWidth * 3;
	BYTE *TmpBuf = dataBuf;
	for(long i = 0; i < m_ImageHeight; i++) 
	{
        memcpy( RowAddress[i], TmpBuf, dataWidth);
		TmpBuf += dataWidth;
    }
    if(dataBuf!=NULL) delete []dataBuf;
	return TRUE;
}
BOOL CAllImage::SaveImageAsGIF(CString fileName)
{
	long i, j, dataWidth = m_ImageWidth * 3;
	BYTE *m_buf = new BYTE[dataWidth*m_ImageHeight];
	BYTE *TmpBuf = m_buf;
	if(m_wImageDepth==24)
	{
		for( j= 0; j < m_ImageHeight; j++) 
		{
			memcpy(TmpBuf, RowAddress[j], dataWidth);
			TmpBuf += dataWidth;
		}
		JpegFile::BGRFromRGB(m_buf, m_ImageWidth, m_ImageHeight);
	}
	else
	{
		RGBTRIPLE  temprgb;
		for( j= 0; j < m_ImageHeight; j++) 
		{
			BYTE *LineAdd = TmpBuf;
			for( i= 0; i < m_ImageWidth; i++) 
			{
				temprgb = GetRGBPixel(i, j);
				*LineAdd++ = temprgb.rgbtRed;
				*LineAdd++ = temprgb.rgbtGreen;
				*LineAdd++ = temprgb.rgbtBlue;
			}
			TmpBuf += dataWidth;
		}
	}
    int m_width  = m_ImageWidth;
	int m_height = m_ImageHeight;
	eImageType dImageType = GetImageType();
	IsColorGifImage = !(dImageType==IndexGrayImage);
    // swap red and blue
	// color quantization section - make an 8-bit image that looks like
	// our 24-bit image...
	// the palette
	RGBQUAD RGBpal[256];	
	BYTE *colormappedBuffer;

	// color or gray?
	if (IsColorGifImage) 
	{	// color !
		// allocate a buffer to colormap to
		colormappedBuffer = (BYTE *)  new BYTE[m_width* m_height];
		if (colormappedBuffer==NULL) {
			AfxMessageBox("Alloc error in SaveGIF!");
			return FALSE;
		}

		// colormap it - uses RGBQuant DLL
		if (!QuantizeRGB(m_buf,						// input
							colormappedBuffer,		// output
							m_width,
							m_height,
							RGBpal,
							2,		// palette type
							0,		// dither type
							NULL)) 
		{
			AfxMessageBox("Quantization error");
			delete [] colormappedBuffer;
			return FALSE;
		}
	} 
	else 
	{	// convert to 8-bit grayscale
		colormappedBuffer = MakeColormappedGrayscale(m_buf,					// RGB
													(UINT)m_width,			// pixels
													(UINT)m_height, 
													(UINT)m_width * 3,		// bytes
													(UINT)256,				// colors
													RGBpal);				// palette

	}

	if (colormappedBuffer==NULL) {
		AfxMessageBox("Failed to make 256 color image");
		return FALSE;
	}

	// figure out the palette entries
	int red[256], blue[256], green[256];
	for (i=0;i<256;i++) 
	{
		red[i]	=	RGBpal[i].rgbRed;
		green[i]=	RGBpal[i].rgbGreen;
		blue[i]	=	RGBpal[i].rgbBlue;
	}

	// write it
	GIFFile theGifThing;
	if (!theGifThing.GIFWriteFileFrom256Color(colormappedBuffer,
												fileName,
												m_width, 
												m_height,
												0,					// background color
												red, green, blue)) 
	{

		AfxMessageBox("Save GIF file is failed!");
		return FALSE;
	} 


	if (colormappedBuffer!=NULL)
		delete [] colormappedBuffer;
	if(m_buf!=NULL) delete []m_buf;
	return TRUE;
}
//***********************************************************
//函数类别： CImage类成员
//函数名称：  
//           GetImageDimensions
//函数用途：
//           获得图像文件的长宽信息 
//原始作者： 陆  宏  伟 
//修改日期： 12/10/1999 
//***********************************************************
void CAllImage::GetImageDimensions(LPCTSTR fileName, unsigned int &width, 
							                       unsigned int &height,
												   unsigned int &Depth)
{
	CString FileName(fileName);
	if(FileName.Right(3) == "pcx" ||FileName.Right(3) == "PCX")
	{
		PCXHEADER          PCXH;
		CFile pReadFile( fileName, CFile::modeRead | CFile::shareCompat);
		
		pReadFile.SeekToBegin();    // Set the file pointer to the begin of the file
		pReadFile.Read( (LPSTR)&PCXH, sizeof(PCXH) );
		width  = PCXH.wRight  - PCXH.wLeft + 1;
		height = PCXH.wBottom - PCXH.wTop  + 1;
		Depth  = PCXH.byPlanes * PCXH.byBits;
		pReadFile.Close();
	}
	else
	{
		CImage::GetImageDimensions(fileName, width, height, Depth);
	}
}
BOOL CAllImage::ReadImageAsPCX(LPCTSTR fileName)
{
	CString            Errormsg;
    PCXHEADER          PCXH;
    PCXD_VAR           PCXDVar;
    WORD               wi;
    BYTE               byTemp;
	WORD               wTemp;
	CFile            * pReadFile;
	BYTE               byPCX_Pal[769];
	BYTE			   bySysPal16[48] = {0,  0,  0,  0,  0,128,
										 0,128,  0,  0,128,128,
									   128,  0,  0,128,  0,128,
									   128,128,  0,128,128,128,
									   192,192,192,  0,  0,255,
										 0,255,  0,  0,255,255,
									   255,  0,  0,255,  0,255,
									   255,255,  0,255,255,255  };

    TRY
    {
	    pReadFile = new CFile( fileName, CFile::modeRead | CFile::shareCompat);
    }
    CATCH( CFileException, e )
    {
        //AfxMessageBox(" 指定文件不存在或错误");
        THROW_LAST();
    }
    END_CATCH

    pReadFile->SeekToBegin();    // Set the file pointer to the begin of the file
    pReadFile->Read( (LPSTR)&PCXH, sizeof(PCXH) );
	if (!CHECK_PCX(PCXH.byManufacturer)||( (PCXH.byPlanes==3)&&(PCXH.byBits!=8)) )
    {
		pReadFile->Close();
        if(pReadFile) delete pReadFile;
        Errormsg.Format("非 [PCX]文件: %s 或不支持这种文件格式",fileName);
        AfxMessageBox(Errormsg);
        return FALSE;
    }
    PCXDVar.wWidth         = PCXH.wRight  - PCXH.wLeft + 1;
    PCXDVar.wDepth         = PCXH.wBottom - PCXH.wTop  + 1;
    PCXDVar.wPlanes        = (WORD)PCXH.byPlanes;
    PCXDVar.wSrcBits       = (WORD)PCXH.byBits;
    PCXDVar.wNewBits       = PCXDVar.wSrcBits * PCXDVar.wPlanes;
    PCXDVar.wLineBytes     = PCXH.wLineBytes;
    PCXDVar.bEOF           = FALSE;
    
	m_wImageDepth   = PCXDVar.wNewBits;
    m_wColorMapNum  = GetColorMapNum(m_wImageDepth);
	m_ImageHeight   = PCXDVar.wDepth;
    m_ImageWidth    = PCXDVar.wWidth;
	m_nDibWidth     = (m_ImageWidth*m_wImageDepth/8+3) & ~3;
	m_nDibHeight    = m_ImageHeight;
	m_ImageSize     = m_nDibWidth*m_nDibHeight;
    m_HSIImageWidth  = (m_ImageWidth+3) & ~3;
	m_HSIImageHeight = m_ImageHeight;

    AllocateMemory();
	GenerateRowAddress();

	m_lpDibInfo->bmiHeader.biSize          = (DWORD)sizeof(BITMAPINFOHEADER);
    m_lpDibInfo->bmiHeader.biWidth         = (DWORD)PCXDVar.wWidth;
    m_lpDibInfo->bmiHeader.biHeight        = (DWORD)PCXDVar.wDepth;
    m_lpDibInfo->bmiHeader.biPlanes        = 1;
    m_lpDibInfo->bmiHeader.biBitCount      = m_wImageDepth;
    m_lpDibInfo->bmiHeader.biCompression   = BI_RGB;
    m_lpDibInfo->bmiHeader.biXPelsPerMeter = 0;
    m_lpDibInfo->bmiHeader.biYPelsPerMeter = 0;
    m_lpDibInfo->bmiHeader.biClrUsed       = m_wColorMapNum;
    m_lpDibInfo->bmiHeader.biClrImportant  = 0;
    m_lpDibInfo->bmiHeader.biSizeImage     = m_ImageSize;

	if ( PCXDVar.wNewBits<=8 )
    {
		if ( PCXH.byVersion==3 )//Set Palette
		{
			switch(m_wColorMapNum)// Use Default Palette  
			{
				case   2:
				{
					m_lpDibInfo->bmiColors[0].rgbRed          = 0x00;
					m_lpDibInfo->bmiColors[0].rgbGreen        = 0x00;
					m_lpDibInfo->bmiColors[0].rgbBlue         = 0x00;
					m_lpDibInfo->bmiColors[0].rgbReserved     = 0x00;
					m_lpDibInfo->bmiColors[1].rgbRed          = 0xFF;
					m_lpDibInfo->bmiColors[1].rgbGreen        = 0xFF;
					m_lpDibInfo->bmiColors[1].rgbBlue         = 0xFF;
					m_lpDibInfo->bmiColors[1].rgbReserved     = 0x00;
					 break;
				} 
				case  16:
				{
					if ( PCXH.wPaletteType==2 )
					{
						for(wi=0;wi<m_wColorMapNum;wi++)// Gray Palette 
						{
							byTemp                          = (BYTE)wi;
							m_lpDibInfo->bmiColors[wi].rgbRed      = byTemp;
							m_lpDibInfo->bmiColors[wi].rgbGreen    = byTemp;
							m_lpDibInfo->bmiColors[wi].rgbBlue     = byTemp;
							m_lpDibInfo->bmiColors[wi].rgbReserved = 0x00;
						} 
					}
					else  // Color Palette 
					{                 
						wTemp = 0; 
						for(wi=0;wi<m_wColorMapNum;wi++)
						{
							m_lpDibInfo->bmiColors[wi].rgbRed      = bySysPal16[wTemp++];
							m_lpDibInfo->bmiColors[wi].rgbGreen    = bySysPal16[wTemp++];
							m_lpDibInfo->bmiColors[wi].rgbBlue     = bySysPal16[wTemp++];
							m_lpDibInfo->bmiColors[wi].rgbReserved = 0x00;
						} 
					}
					break;
				}  
				case 256:
				{
					for(wi=0;wi<m_wColorMapNum;wi++)
					{
						byTemp                          = (BYTE)wi;
						m_lpDibInfo->bmiColors[wi].rgbRed      = byTemp;
						m_lpDibInfo->bmiColors[wi].rgbGreen    = byTemp;
						m_lpDibInfo->bmiColors[wi].rgbBlue     = byTemp;
						m_lpDibInfo->bmiColors[wi].rgbReserved = 0x00;
					}
					break;
				}
			} 
			BakupColorIndex();
		}  
        else  // if ( PCXH.byVersion==3 )//Set Palette
		{
			switch(m_wColorMapNum)// Get PCX Palette 
			{
				case   2:
				{
				   m_lpDibInfo->bmiColors[0].rgbRed          = PCXH.byPalette[0];
				   m_lpDibInfo->bmiColors[0].rgbGreen        = PCXH.byPalette[1];
				   m_lpDibInfo->bmiColors[0].rgbBlue         = PCXH.byPalette[2];
				   m_lpDibInfo->bmiColors[0].rgbReserved     = 0x00;
				   m_lpDibInfo->bmiColors[1].rgbRed          = PCXH.byPalette[3];
				   m_lpDibInfo->bmiColors[1].rgbGreen        = PCXH.byPalette[4];
				   m_lpDibInfo->bmiColors[1].rgbBlue         = PCXH.byPalette[5];
				   m_lpDibInfo->bmiColors[1].rgbReserved     = 0x00;
				   break;
				}
				case  16:
				{
				   wTemp = 0;
				   for(wi=0;wi<m_wColorMapNum;wi++)
				   {
					  m_lpDibInfo->bmiColors[wi].rgbRed      = PCXH.byPalette[wTemp++];
					  m_lpDibInfo->bmiColors[wi].rgbGreen    = PCXH.byPalette[wTemp++];
					  m_lpDibInfo->bmiColors[wi].rgbBlue     = PCXH.byPalette[wTemp++];
					  m_lpDibInfo->bmiColors[wi].rgbReserved = 0x00;
				   }
				   break;
				}
				case 256:
				{
					LONG lActual = pReadFile->Seek(-769L, CFile::end );
					pReadFile->Read((LPSTR)byPCX_Pal, 769);  
					for(wTemp = 1,wi=0; wi<m_wColorMapNum;wi++)
					{
					  //byPCX_Pal[1] Is The Start of PCX Palette  
					  m_lpDibInfo->bmiColors[wi].rgbRed      = byPCX_Pal[wTemp++];
					  m_lpDibInfo->bmiColors[wi].rgbGreen    = byPCX_Pal[wTemp++];
					  m_lpDibInfo->bmiColors[wi].rgbBlue     = byPCX_Pal[wTemp++];
					  m_lpDibInfo->bmiColors[wi].rgbReserved = 0x00;
					}
					break;
				}
			}
			BakupColorIndex();
		}
    }
	ReadPcxImage(pReadFile,m_lpDibArray, &PCXDVar,m_nDibWidth);
	pReadFile->Close();
    if(pReadFile)delete pReadFile;
    return TRUE;
}
BOOL CAllImage::SaveImageAsPCX(LPCTSTR fileName)
{
	CString            Errormsg;
	PCXHEADER          PCXH;
	PCXC_VAR           PCXCVar;
	WORD               wi;
	BYTE               byPCX_Pal[769];
    CFile             *pWriteFile;

	PCXCVar.wWidth     = (WORD)m_ImageWidth;
    PCXCVar.wDepth     = (WORD)m_ImageHeight;
    PCXCVar.wBits      = (WORD)m_wImageDepth;
    PCXCVar.wLineBytes = (WORD)m_ImageWidth;

	if(m_wImageDepth==4)
        PCXCVar.wPlanes = 4; 
	else if(m_wImageDepth==24)
		PCXCVar.wPlanes = 3; 
	else 
        PCXCVar.wPlanes = 1;