image.cpp

医学图象处理系统

		{
			for(int i= 0; i< m_wColorMapNum; i++)
			{
				m_lpDibInfo->bmiColors[i].rgbBlue     = (P_BYTE)i;
				m_lpDibInfo->bmiColors[i].rgbGreen    = (P_BYTE)i;
				m_lpDibInfo->bmiColors[i].rgbRed      = (P_BYTE)i;
				m_lpDibInfo->bmiColors[i].rgbReserved = 0;
			} 
			BakupColorIndex();
			memset(m_lpDibArray, (P_BYTE)colornum, m_ImageSize);
		}      
		else if( m_wImageDepth == 16 )
		{
			m_dwBBitMask    = 0x1F;
			m_dwGBitMask    = 0x3E0;
			m_dwRBitMask    = 0x7C00; 
			m_wlowRedBit    = 10;	
			m_wlowGreenBit  = 5;	
			m_wlowBlueBit   = 0;
			m_wNumRedBits   = 5; 	
			m_wNumGreenBits = 5;
			m_wNumBlueBits  = 5;	
			DWORD *Mask  =  (DWORD *)m_lpDibInfo->bmiColors;
			Mask[0] = m_dwRBitMask;
			Mask[1] = m_dwGBitMask;
			Mask[2] = m_dwBBitMask;

			RGBTRIPLE  Pixel3;
			BYTE      *RGB  = (BYTE * )&colornum;
			Pixel3.rgbtRed   = RGB[0] / 8;
			Pixel3.rgbtGreen = RGB[1] / 8;
			Pixel3.rgbtBlue  = RGB[2] / 8;
			WORD Pixel2 = Pixel3.rgbtRed<<m_wlowRedBit | 
				          Pixel3.rgbtGreen<<m_wlowGreenBit | 
						  Pixel3.rgbtBlue<<m_wlowBlueBit;
			for(int j= 0; j< m_nDibHeight; j++)
			{
				WORD *lpPixel= (WORD*)(RowAddress[j]);
				for(int i= 0; i< width; i++, lpPixel++)
				{
					*lpPixel = Pixel2;
				}
			}
		}
		else if( m_wImageDepth == 24 )
		{
			RGBTRIPLE  Pixel, *lpTriple;
			BYTE      *RGB  = (BYTE * )&colornum;
			Pixel.rgbtRed   = RGB[0];
			Pixel.rgbtGreen = RGB[1];
			Pixel.rgbtBlue  = RGB[2];
			for(int j= 0; j< m_nDibHeight; j++)
			{
				lpTriple = (RGBTRIPLE*)(RowAddress[j]);
				for(int i= 0; i< width; i++, lpTriple++)
				{
					*lpTriple = Pixel;
				}
			}
		}   
	}
	GenerateRowAddress();
	return TRUE;
}    
//***********************************************************

//***********************************************************
BOOL CImage::CreatePartImg(CImage &source, CPoint &LTp, CPoint &RBp, int nScale)
{
#ifdef _DEBUG
	if(!source.CheckRect(LTp,RBp))
	{
		AfxMessageBox("下标越界!!!");
		AfxAbort();
	}
#endif  
	//还需要加入高彩的放大处理
	DeleteMe();

	m_wImageDepth    = source.m_wImageDepth;
	m_wColorMapNum   = source.m_wColorMapNum; 

	P_LONG SourceW   = (RBp.x - LTp.x);
	P_LONG SourceH   = (RBp.y - LTp.y);
	P_LONG width     = SourceW * nScale;
    P_LONG height    = SourceH * nScale;
 
    m_ImageWidth     = width;	
    m_ImageHeight    = height;	
    m_nDibWidth      = (width* m_wImageDepth/ 8 + 3) & ~3;;
    m_nDibHeight     = height;
    m_ImageSize      = m_nDibWidth * m_nDibHeight;
	
    m_HSIImageWidth  = (width + 3) & ~3;
	m_HSIImageHeight = height;
    
	AllocateMemory();
    if( m_lpDibInfo!=NULL && m_lpDibArray!=NULL ) //create the bitmap info     
	{  
		m_lpDibInfo->bmiHeader.biSize          = sizeof(BITMAPINFOHEADER);
		m_lpDibInfo->bmiHeader.biWidth         = width;
		m_lpDibInfo->bmiHeader.biHeight        = source.m_IsImageDownUp ? height : -height;
		m_lpDibInfo->bmiHeader.biPlanes        = 1;
		m_lpDibInfo->bmiHeader.biBitCount      = m_wImageDepth;
		m_lpDibInfo->bmiHeader.biCompression   = BI_RGB;
		m_lpDibInfo->bmiHeader.biSizeImage     = m_ImageSize;
		m_lpDibInfo->bmiHeader.biXPelsPerMeter = 0;
		m_lpDibInfo->bmiHeader.biYPelsPerMeter = 0;
		m_lpDibInfo->bmiHeader.biClrUsed       = m_wColorMapNum;
		m_lpDibInfo->bmiHeader.biClrImportant  = 0;
	
		if( m_wImageDepth <= 8 )// create the color table
		{
			for(int i= 0; i< m_wColorMapNum; i++)
			{
				m_lpDibInfo->bmiColors[i] = source.m_lpDibInfo->bmiColors[i];
			} 
			BakupColorIndex();
		}        
	}
	GenerateRowAddress();
	//下面开始用插值方法来产生放大的图像
	P_LONG   xx, yy, tx, ty;
	float    alpha, belta;    
	float   *coef = new float[nScale];

	for(int i= 0; i< nScale; i++)
        coef[i] = (float)i / (float)nScale;

    if( m_wImageDepth == 8 )
	{
		P_BYTE I11, I12, I21, I22, I;
		for( P_LONG y0 = 0; y0 < SourceH  ; y0++)    
		{
			yy = y0 * nScale;
			ty = y0 + LTp.y;
			for( P_LONG x0 = 0; x0 < SourceW; x0++)  
			{
				xx = x0 * nScale;            
				tx = x0 + LTp.x;
				
				I11 = source.RowAddress[ ty ][ tx ];
				I12 = source.RowAddress[ ty ][tx+1];
				I21 = source.RowAddress[ty+1][ tx ];
				I22 = source.RowAddress[ty+1][tx+1];
				for(P_LONG j = 0; j < nScale; j ++)
				{
					belta = coef[j];
					for( P_LONG i = 0; i <  nScale; i ++)
					{					
						alpha = coef[i];
						I = (P_BYTE)(  (float)(I11  + (I12-I11) * alpha) * (1.0 - belta) + 
									   (float)(I21  + (I22-I21) * alpha) * belta+0.5);
						RowAddress[yy+ j][xx+ i] = I;
					}
				}				
			}		
		}
		int LineRemain = m_nDibWidth - m_ImageWidth;
		if(LineRemain)
		{
			for(P_LONG j = 0; j < m_ImageHeight  ; j ++)
			{
				P_BYTE *lp = RowAddress[j] + width-1;
				P_BYTE gray = *lp++;
				memset(lp, gray, LineRemain);
			}
		}
	}//end of if(m_wImageDepth==8)
	else if( m_wImageDepth == 24 )
	{
		int        g11, g12, g21, g22;
		RGBTRIPLE  I11, I12, I21, I22, I, *RGBRowAddress;
 		for( P_LONG y0 = 0; y0 < SourceH; y0 ++)    
		{
			yy = y0 * nScale;
			ty = y0 + LTp.y;
			
			for( P_LONG x0 = 0; x0 < SourceW; x0 ++)  
			{
				xx = x0 * nScale;            
				tx = x0 + LTp.x;

				I11 = source.GetRGBPixel(tx,   ty );
				I12 = source.GetRGBPixel(tx+1, ty);
				I21 = source.GetRGBPixel(tx,   ty+1);
				I22 = source.GetRGBPixel(tx+1, ty+1);
				for(P_LONG j = 0; j < nScale; j ++)
				{
					RGBRowAddress =	(RGBTRIPLE*)(RowAddress[yy+ j]);
					belta = coef[j];
					for( P_LONG i = 0; i <  nScale; i ++)
					{					
						alpha = coef[i];
						
						g11 = I11.rgbtRed;
						g12 = I12.rgbtRed;
						g21 = I21.rgbtRed;
						g22 = I22.rgbtRed;
						I.rgbtRed= (P_BYTE)((float)(g11  + (g12-g11) * alpha) * (1.0 - belta) + 
									        (float)(g21  + (g22-g21) * alpha) * belta+0.5);
						g11 = I11.rgbtGreen;
						g12 = I12.rgbtGreen;
						g21 = I21.rgbtGreen;
						g22 = I22.rgbtGreen;
						I.rgbtGreen= (P_BYTE)((float)(g11  + (g12-g11) * alpha) * (1.0 - belta) + 
									          (float)(g21  + (g22-g21) * alpha) * belta+0.5);
						g11 = I11.rgbtBlue;
						g12 = I12.rgbtBlue;
						g21 = I21.rgbtBlue;
						g22 = I22.rgbtBlue;
						I.rgbtBlue= (P_BYTE)((float)(g11  + (g12-g11) * alpha) * (1.0 - belta) + 
									         (float)(g21  + (g22-g21) * alpha) * belta+0.5);
					    RGBRowAddress[xx+ i] = I;
					}
				}				
			}
		}
		int LineRemain = m_nDibWidth - m_ImageWidth * 3;
		if( LineRemain )
		{
			for(P_LONG j =1; j <= m_ImageHeight  ; j++)
			{
				P_BYTE *lp = RowAddress[j] - 1 - LineRemain;
				memset(lp, 255, LineRemain);
			}
		}
	}
	if( coef != NULL ) delete []coef;
	return TRUE;
}
//***********************************************************

//***********************************************************
BOOL CImage::CreateMicroImg(CImage &source, P_LONG MicroW, P_LONG MicroH)
{
	//还需要加入高彩的放大处理
	DeleteMe();

	m_wImageDepth    = source.m_wImageDepth;
	m_wColorMapNum   = source.m_wColorMapNum; 

    m_ImageWidth     = MicroW;	
    m_ImageHeight    = MicroH;	
    m_nDibWidth      = (m_ImageWidth* m_wImageDepth/ 8 + 3) & ~3;;
    m_nDibHeight     = MicroH;
    m_ImageSize      = m_nDibWidth * m_nDibHeight;
	
    m_HSIImageWidth  = (MicroW + 3) & ~3;
	m_HSIImageHeight = MicroH;
    
	AllocateMemory();
    if( m_lpDibInfo!=NULL && m_lpDibArray != NULL ) //create the bitmap info     
	{  
		m_lpDibInfo->bmiHeader.biSize          = sizeof(BITMAPINFOHEADER);
		m_lpDibInfo->bmiHeader.biWidth         = MicroW;
		m_lpDibInfo->bmiHeader.biHeight        = source.m_IsImageDownUp ? MicroH : -MicroH;
		m_lpDibInfo->bmiHeader.biPlanes        = 1;
		m_lpDibInfo->bmiHeader.biBitCount      = m_wImageDepth;
		m_lpDibInfo->bmiHeader.biCompression   = BI_RGB;
		m_lpDibInfo->bmiHeader.biSizeImage     = m_ImageSize;
		m_lpDibInfo->bmiHeader.biXPelsPerMeter = 0;
		m_lpDibInfo->bmiHeader.biYPelsPerMeter = 0;
		m_lpDibInfo->bmiHeader.biClrUsed       = m_wColorMapNum;
		m_lpDibInfo->bmiHeader.biClrImportant  = 0;
	
		if( m_wImageDepth <= 8 )// create the color table
		{
			for(int i= 0; i< m_wColorMapNum; i++)
			{
				m_lpDibInfo->bmiColors[i] = source.m_lpDibInfo->bmiColors[i];
			} 
			BakupColorIndex();
		}        
	}
	GenerateRowAddress();
	//下面开始用插值方法来产生缩小的图像
	P_LONG   x0, y0, xx, yy;
	float    dx = (float)source.m_ImageWidth/  (float)MicroW;
	float    dy = (float)source.m_ImageHeight/ (float)MicroH;
	float    OrgPtx, OrgPty;
    if( m_wImageDepth == 8 )
	{
		for(OrgPty = 0, y0 = 0; y0 < MicroH  ; y0++)    
		{			 
			yy = int(OrgPty + 0.5);
			for(OrgPtx = 0, x0 = 0; x0 < MicroW  ; x0++)  
			{
				xx                 = int(OrgPtx + 0.5);            
				RowAddress[y0][x0] = source.RowAddress[ yy ][ xx ];
				OrgPtx            += dx;
			}
			OrgPty += dy;
		}		
	} //end of if(m_wImageDepth==8)
	else if( m_wImageDepth == 24 )
	{
		RGBTRIPLE *RGBRowAddress;
		for(OrgPty = 0, y0 = 0; y0 < MicroH  ; y0++)    
		{
			yy = int(OrgPty + 0.5);
			RGBRowAddress = (RGBTRIPLE *)RowAddress[y0];
			for(OrgPtx = 0, x0 = 0; x0 < MicroW  ; x0++)  
			{
				xx                = int(OrgPtx + 0.5);            
				RGBRowAddress[x0] = source.GetRGBPixel(xx, yy);
				OrgPtx           += dx;
			}
			OrgPty += dy;
		}		
	} //end of if(m_wImageDepth==24)
	
	return TRUE;
}
//***********************************************************

//***********************************************************
BOOL CImage::ConvertToGrayImage()
{
	eImageType dImageType = GetImageType();
	if( m_wImageDepth ==  IndexGrayImage) return false;
	
	P_LONG i, j, GrayImagewidth = (m_ImageWidth + 3) & ~3;
	BYTE *tempBMP = new BYTE[GrayImagewidth * m_ImageHeight];  
	memset(tempBMP, 0, GrayImagewidth * m_ImageHeight);

	BYTE *lAdd = tempBMP + GrayImagewidth * (m_ImageHeight - 1);
	RGBTRIPLE   rgbV;
	for(j= 0; j< m_ImageHeight; j++)
	{
		for(i= 0; i< m_ImageWidth; i++)
		{
			rgbV    = GetRGBPixel(i, j);
			lAdd[i] =  (rgbV.rgbtBlue+ rgbV.rgbtGreen + rgbV.rgbtRed + 2)/3;
		}
		lAdd -= GrayImagewidth;
	}
	m_wImageDepth    = 8;
	m_nDibWidth      = GrayImagewidth;
	m_nDibHeight     = m_ImageHeight;
	m_ImageSize      = m_nDibWidth * m_nDibHeight;

	m_wColorMapNum   = GetColorMapNum(m_wImageDepth);
	m_HSIImageWidth  = (m_ImageWidth + 3) & ~3;
	m_HSIImageHeight = m_ImageHeight;

	m_bmfHeader.bfType      = DIB_HEADER_MARKER;        // "BM"
	m_bmfHeader.bfOffBits   = sizeof(BITMAPFILEHEADER) +
		                      sizeof(BITMAPINFOHEADER) + 
						      m_wColorMapNum * sizeof(RGBQUAD);
	m_bmfHeader.bfSize      = m_bmfHeader.bfOffBits + m_ImageSize;
	m_bmfHeader.bfReserved1 = 0;
	m_bmfHeader.bfReserved2 = 0;

	AllocateMemory();
	InitGrayImageInfo();
	GenerateRowAddress();
	memcpy(m_lpDibArray, tempBMP, m_ImageSize);
	if( tempBMP!= NULL ) delete[]tempBMP;
	return true;	
}
//***********************************************************

//***********************************************************
void  CImage::GetImageDimensions(LPCTSTR fileName, unsigned int &width, 
							                       unsigned int &height,
												   unsigned int &Depth)
{
	CString FileName(fileName);
	if(FileName.Right(3) == "img" ||FileName.Right(3) == "IMG")
	{
		CFile  pReadFile(fileName, CFile::modeRead | CFile::shareCompat);
		DWORD  dwBitsSize = pReadFile.GetLength();
		double multi = sqrt(dwBitsSize) / IMG_FORMAT_BASE_LENGTH;

		width    = IMG_FORMAT_BASE_LENGTH * int(multi);
		height   = dwBitsSize / width;
	}
	else
	{
		FILE    *rf = fopen(fileName, "r");
		if ( rf == NULL) return;
		
		if(FileName.Right(3) == "bmp" ||FileName.Right(3) == "BMP")
		{    
			BITMAPFILEHEADER    BMP_Header; 
			BITMAPINFOHEADER    BMP_InfoHeader;
			fread( (LPSTR)&BMP_Header,     sizeof(BITMAPFILEHEADER), 1, rf );
			fread( (LPSTR)&BMP_InfoHeader, sizeof(BITMAPINFOHEADER), 1, rf );
			if ( BMP_Header.bfType != DIB_HEADER_MARKER )    
			{
				AfxMessageBox("您所指定的不是一个BMP文件！");
				return ;
			}
			width  = BMP_InfoHeader.biWidth;	
			height = abs(BMP_InfoHeader.biHeight);
			Depth  = BMP_InfoHeader.biBitCount;
		}
		else if(FileName.Right(3) == "pbm" ||FileName.Right(3) == "PBM")
		{    
			char    P14[4];
			//读出图像的宽度和高度
			int     w = 0, h = 0;
			fscanf(rf, "%s\n", P14);
			if ( (P14[0] != 'P') && (P14[1] != '1'&&P14[1] != '4') )
			{
				AfxMessageBox("您所指定的不是一个PBM文件！");
				return;
			}
			fscanf(rf, "%d %d\n", &w, &h);	
			width  = w;	
			height = h;
			Depth  = 8;
		} 
		else if(FileName.Right(3) == "pgm" ||FileName.Right(3) == "PGM")
		{
			char    P5[4];
			fscanf(rf, "%s\n", P5);
			if ( (P5[0] != 'P') && (P5[1] != '5') ) 
			{
				AfxMessageBox("您所指定的不是一个PGM文件！");
				return;
			}
			//读出图像的宽度和高度
			int     w = 0, h = 0, MaxGray = 255;
			fscanf(rf, "%d %d\n", &w, &h);
			fscanf(rf, "%d\n", &MaxGray);
			width  = w;	
			height = h;
			Depth  = 8;
		}
		fclose(rf);
	}
}
//***********************************************************

//***********************************************************
BOOL CImage::ReadImageFromFile(LPCTSTR lpszFileName)
{
    CFile * pReadFile;
    TRY {  pReadFile = new CFile( lpszFileName, CFile::modeRead | CFile::shareCompat); }
    CATCH( CFileException, e )
    {
		return false;
    }
    END_CATCH

	if( pReadFile == NULL || pReadFile->GetLength( )<54)
	{
		AfxMessageBox("文件类指针或文件格式错误!!!");        
		if( pReadFile != NULL )
		{
			pReadFile->Close(); delete pReadFile;  pReadFile = NULL;
		}
		return false;
	}
	else
	{
		BOOL    result = false;
 		CString FileName(lpszFileName);
		if(FileName.Right(3) == "img" ||FileName.Right(3) == "IMG")
		{
			result = ReadImageAsIMG( pReadFile);
		}
		else if(FileName.Right(3) == "bmp" ||FileName.Right(3) == "BMP")
		{    
			result = ReadImageAsBMP( pReadFile);
		}
		
		if(pReadFile != NULL)
		{
			pReadFile->Close(); delete pReadFile;  pReadFile = NULL;
		}
		return result;
	}
}
//***********************************************************