www.pudn.com > 医学图像处理示例源代码.rar > 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 <p, 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;wibmiColors[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;wibmiColors[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;wibmiColors[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;wibmiColors[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; wibmiColors[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;
if ( m_wImageDepth==8 )
{
byPCX_Pal[0] = 0x0C;
DWORD wTemp = 1;
for(wi=0;wibmiColors[wi].rgbRed;
byPCX_Pal[wTemp++] = m_lpDibInfo->bmiColors[wi].rgbGreen ;
byPCX_Pal[wTemp++] = m_lpDibInfo->bmiColors[wi].rgbBlue;
}
}
TRY
{
pWriteFile = new CFile( fileName, CFile::modeCreate | CFile::modeWrite);
}
CATCH( CFileException, e )
{
//AfxMessageBox(" 指定文件不存在或错误");
THROW_LAST();
}
END_CATCH
eImageType dImageType = GetImageType();
if( dImageType == FourBitsImage || dImageType == IndexColorImage
||dImageType ==TrueColorImage || dImageType == HighColorImage )
IsColorPCXImage = TRUE;
else
IsColorPCXImage = FALSE;
PCXH.byManufacturer = PCX_MARK;
PCXH.byVersion = 5;
PCXH.byEncoding = 1;
PCXH.byBits = (BYTE)( (PCXCVar.wBits>= 8) ? 8 : 1 );
PCXH.wLeft = 0;
PCXH.wTop = 0;
PCXH.wRight = PCXCVar.wWidth - 1;
PCXH.wBottom = PCXCVar.wDepth - 1;
PCXH.wXResolution = 0;
PCXH.wYResolution = 0;
PCXH.byReserved = 0;
PCXH.byPlanes = (BYTE)PCXCVar.wPlanes;
PCXH.wLineBytes = PCXCVar.wLineBytes;
PCXH.wPaletteType = IsColorPCXImage;
PCXH.wScrWidth = 0;
PCXH.wScrDepth = 0;
pWriteFile->Write( (LPSTR)&PCXH, sizeof(PCXH) );
WritePcxImage(pWriteFile,m_lpDibArray,&PCXCVar,m_nDibWidth);
if ( m_wImageDepth==8 )
{
pWriteFile->Write((LPSTR)byPCX_Pal,769 );
}
pWriteFile->Close();
if(pWriteFile!=NULL) delete pWriteFile;
return TRUE;
}
BOOL CAllImage::Binary2(int threshold, int Type, CPoint LTPt,CPoint RBPt)
{
BYTE Threshold=(BYTE) threshold;
eImageType dImageType = GetImageType();
if(dImageType != IndexGrayImage||m_lpDibArray==NULL||!CheckRect(LTPt,RBPt))
return FALSE;
int ImgW = RBPt.x - LTPt.x + 1;
int ImgH = RBPt.y - LTPt.y + 1;
int ImgSize = ImgW*ImgH;
BYTE *lptmpImage = new BYTE[ImgSize];
BYTE *TargetAddress = lptmpImage;
for(int j=0; j