image.cpp

医学图象处理系统

				}
			}	
			break;
		}
		case  BLUECOMPONENT | REDCOMPONENT: 
		{
			if( m_wImageDepth == 24)
			{
				for(int j= 0; j< m_ImageHeight; j++)
				{
					RGBTRIPLE* pixptr = (RGBTRIPLE*)(RowAddress[j]);
					for(int i= 0; i< m_ImageWidth; i++)
					{
						pixptr[i].rgbtGreen = 0;
					} 
				}
			}	
			break;
		}
		case  HUEIMAGE: 
		{
			CreateHSIImage( HUEIMAGE );
			if( m_wImageDepth == 24)
			{
				for(int j= 0, k= 0; j< m_ImageHeight; j++, k += m_HSIImageWidth)
				{
					RGBTRIPLE* pixptr = (RGBTRIPLE*)( RowAddress[j] );

					for(int i= 0; i< m_ImageWidth; i++)
					{
						pixptr[i].rgbtRed   =
						pixptr[i].rgbtBlue  =
						pixptr[i].rgbtGreen = m_lpHSIArray[k + i];
					} 
				}
			}	
			break;
		}
		case  SATURATIONIMAGE: 
		{
			CreateHSIImage( SATURATIONIMAGE );
			if( m_wImageDepth == 24 )
			{
				for(int j= 0, k= 0; j< m_ImageHeight; j++, k += m_HSIImageWidth)
				{
					RGBTRIPLE* pixptr=(RGBTRIPLE*)( RowAddress[j] );
					for(int i= 0; i< m_ImageWidth; i++)
					{
						pixptr[i].rgbtRed   =
						pixptr[i].rgbtBlue  =
						pixptr[i].rgbtGreen = m_lpHSIArray[k + i];
					} 
				}
			}	
			break;
		}
		case  INTENSITYIMAGE: 
		{
			CreateHSIImage( INTENSITYIMAGE );
			if( m_wImageDepth == 24 )
			{
				for(int j= 0, k= 0; j< m_ImageHeight; j++, k += m_HSIImageWidth)
				{
					RGBTRIPLE* pixptr = (RGBTRIPLE*)( RowAddress[j] );
					for(int i= 0; i< m_ImageWidth; i++)
					{
						pixptr[i].rgbtRed   =
						pixptr[i].rgbtBlue  =
						pixptr[i].rgbtGreen = m_lpHSIArray[k + i];
					} 
				}
			}	
			break;
		}
	}
}
//***********************************************************

//***********************************************************
void CImage::BackUp()
{
	if( m_lpDibArrayBuff == NULL)
	{
	    NewBuffer();          
    }   	
    memcpy(m_lpDibArrayBuff, m_lpDibArray, m_ImageSize);
}
//***********************************************************

//***********************************************************
void CImage::ImgSwap()
{
	if(m_lpDibArray     == NULL)  return;
	if(m_lpDibArrayBuff == NULL)  BackUp();

	P_BYTE *tmpImgPt = m_lpDibArray;
	m_lpDibArray     = m_lpDibArrayBuff;
	m_lpDibArrayBuff = tmpImgPt;
	tmpImgPt         = NULL;

	GenerateRowAddress();
}
//***********************************************************

//***********************************************************
void CImage::CreateHSIImage(DWORD dwType)
{
	if( m_lpHSIArray == NULL ) NewHSIImg();
#ifdef _DEBUG
	if( m_wImageDepth != 24 || m_lpHSIArray == NULL )
	{ 
		AfxMessageBox("下标越界或图像色彩不对!!!");
		AfxAbort();
	} 
#endif
	//static  DWORD OldType = 0;
	//double   dRED, dGREEN, dBLUE;
	P_LONG   i, j;
    P_BYTE  *rgb;   
    P_BYTE  *Line = m_lpHSIArray;

    switch( dwType )
	{
	    case  HUEIMAGE: 
		{
			//	Hue = (P_BYTE)( atan2( 0.7071 * (dGREEN - dBLUE), 0.816496 * dRED - 0.40824 * (dGREEN + dBLUE) ) 
			//                 * 90.0 * 2.0 / 3.1415926 * 255.0 / 360.0);
			double temp = 90.0 * 2.0 / 3.1415926 * 255.0 / 360.0;
			double table1[512], table2[512], table3[512];
			P_BYTE tmpr, tmpg, tmpb;  
			for( j= 0; j< 512; j++ )
			{
				table1[j] =  0.7071 * (j-255);
				table2[j] =  0.816496 * j;
				table3[j] =  0.40824 * j;
			}
			for( j= 0; j< m_HSIImageHeight; j++, Line += m_HSIImageWidth)
			{				
				rgb  = RowAddress[j];
				for(i=0; i<m_ImageWidth; i++ )
				{			
					tmpb = *rgb++;
					tmpg = *rgb++;
					tmpr = *rgb++;
					Line[i] = (P_BYTE)(atan2(table1[tmpg - tmpb + 255], 
						                     table2[tmpr] - table3[tmpg + tmpb] ) * temp);
				}
			}
        	break;
		}
		case  SATURATIONIMAGE: 
		{
			BYTE  minRGB;
			double meanRGB;
			for( j= 0; j< m_HSIImageHeight; j++, Line += m_HSIImageWidth)
			{
				rgb  = RowAddress[j];
				for(i=0; i<m_ImageWidth; i++, rgb += 3 )
				{			
					minRGB  = min(rgb[0], rgb[1]);
					minRGB  = min(rgb[2], minRGB);
					meanRGB = (rgb[0] + rgb[1] + rgb[2])/ 3.0;
					Line[i] = meanRGB ? ~(P_BYTE)(minRGB/ meanRGB* 255) : 0;
				}
			}
			break;
		}
		case  INTENSITYIMAGE: 
		{
			for( j= 0; j< m_HSIImageHeight; j++, Line += m_HSIImageWidth)
			{
				rgb  = RowAddress[j];
				for(i=0; i<m_ImageWidth; i++, rgb += 3 )
				{			
					Line[i] = (P_BYTE)((rgb[0]+ rgb[1]+ rgb[2])/ 3);
				}
			}			
			break;
		}
	}
}
//***********************************************************

//***********************************************************
RGBTRIPLE  CImage::GetRGBPixel(P_LONG x, P_LONG y)
{
	RGBTRIPLE rv;
#ifdef _DEBUG
	if(!CheckPoint(x,y)||m_lpDibArray==NULL)
	{
		AfxMessageBox("下标越界或图像色彩不对!!!");
		AfxAbort();
	}
#endif  
    switch( m_wImageDepth )
    {
		case  1:
		{
			BYTE    Temp  = RowAddress[y][x/8];
			int     pos   = 7 - x%8;
			if(Temp&(1<<pos)) 
				rv            = ColorIndex[1]; 
			else 
				rv            = ColorIndex[0]; 
			break;
		}
		case  4:
		{
			BYTE    Temp  = RowAddress[y][x/2];
			int     index;
			if(x%2) index = Temp & 0x0F;
			else    index = Temp & 0xF0>>4;
			rv            = ColorIndex[index]; 
			break;
		}
		case  8:
		{
			int    index = RowAddress[y][x];
			rv           = ColorIndex[index]; 
			break;
		}
		case 16:
		{
			WORD *pixptr = (WORD*)RowAddress[y];
			WORD  temp   = pixptr[x];
			rv.rgbtRed   = (P_BYTE)( (temp&m_dwRBitMask) >> m_wlowRedBit ); 
			rv.rgbtGreen = (P_BYTE)( (temp&m_dwGBitMask) >> m_wlowGreenBit );
			rv.rgbtBlue  = (P_BYTE)( (temp&m_dwBBitMask) );
			break;
		}
		case 24: 
		{
			RGBTRIPLE* pixptr = (RGBTRIPLE*)RowAddress[y];
			rv                = pixptr[x];
			break;
		}
		case 32: 
		{
			DWORD *pixptr = (DWORD*)RowAddress[y];
			DWORD temp    = pixptr[x];
			rv.rgbtRed    = (P_BYTE)( (temp&m_dwRBitMask) >> m_wlowRedBit ); 
			rv.rgbtGreen  = (P_BYTE)( (temp&m_dwGBitMask) >> m_wlowGreenBit );
			rv.rgbtBlue   = (P_BYTE)( temp&m_dwBBitMask );
			break;
		}
	}
	return rv;
}
//***********************************************************

//***********************************************************
void CImage::SetRGBPixel(P_LONG x, P_LONG y,RGBTRIPLE color)
{
#ifdef _DEBUG
	if(!CheckPoint(x,y)||m_lpDibArray==NULL)
	{
		AfxMessageBox("下标越界或图像色彩不对!!!");
		AfxAbort();
	}
#endif  
    switch(m_wImageDepth)
    {
		case  8:
		{
			int       index  = RowAddress[y][x];
			RowAddress[y][x] = (color.rgbtRed + color.rgbtGreen + color.rgbtBlue)/ 3; 
			break;
		}
		case 16:
		{
			WORD *pixptr = (WORD*)RowAddress[y];
			WORD  temp   = color.rgbtRed<<m_wlowRedBit | 
				           color.rgbtGreen<<m_wlowGreenBit |
						   color.rgbtBlue<<m_wlowBlueBit;
			pixptr[x]    = temp;
			break;
		}
		case 24: 
		{
			RGBTRIPLE* pixptr = (RGBTRIPLE*)RowAddress[y];
			pixptr[x]         = color;
			break;
		}
		case 32: 
		{
			DWORD *pixptr = (DWORD*)RowAddress[y];
			DWORD  temp   = color.rgbtRed | color.rgbtGreen<<m_wlowGreenBit | color.rgbtBlue<<m_wlowBlueBit;
			pixptr[x]     = temp;		
			break;
		}
	}
}
//***********************************************************

//***********************************************************
void CImage::SetRGBPixel(P_LONG x, P_LONG y, DWORD color)
{
	RGBTRIPLE rv;
    rv.rgbtRed   = (P_BYTE)  color&0x000000FF ;
	rv.rgbtGreen = (P_BYTE) (color&0x0000FF00) >> 8;
	rv.rgbtBlue  = (P_BYTE) (color&0x00FF0000) >> 16;
    SetRGBPixel(x, y, rv);
}

//***********************************************************

//***********************************************************
P_BYTE CImage::GetGrayV(P_LONG x, P_LONG y)
{
#ifdef _DEBUG
	if(!CheckPoint(x,y)||m_wImageDepth!=8||m_lpDibArray==NULL)
	{
		AfxMessageBox("下标越界或非灰度图像!!!");
		AfxAbort();
	}
#endif  
    return RowAddress[y][x];
}

P_BYTE CImage::GetGrayV(double x, double y)
{
	int		ix = int(x);
	int		iy = int(y);
	double  dx = x - ix;
	double  dy = y - iy;

	if( ix < 0)	
	{
		ix = 0;
	}
	else if( ix >= (m_ImageWidth-1) ) 	
	{
		ix = m_ImageWidth - 2;
	}

	if( iy < 0)
	{
		iy = 0;
	}
	else if( iy >= (m_ImageHeight- 1) )
	{
		iy = m_ImageHeight - 2;
	}
	
	BYTE I11, I12, I21, I22;
	int  I;
	I11 = RowAddress[ iy ][ ix ];
	I12 = RowAddress[ iy ][ix+1];
	I21 = RowAddress[iy+1][ ix ];
	I22 = RowAddress[iy+1][ix+1];
	I = (int)(  (float)(I11  + (I12-I11) * dx) * (1.0 - dy) + 
			    (float)(I21  + (I22-I21) * dx) * dy + 0.5);
	return I>255 ? 255 : BYTE(I);
}
//***********************************************************
 
//***********************************************************
void CImage::SetGrayV(P_LONG x, P_LONG y,P_BYTE gray)
{
#ifdef _DEBUG
	if(!CheckPoint(x,y)||m_wImageDepth!=8||m_lpDibArray==NULL)
	{
		AfxMessageBox("下标越界或非灰度图像!!!");
		AfxAbort();
	}
#endif  
	RowAddress[y][x] = gray;
}
//***********************************************************

//***********************************************************
P_BYTE CImage::GetXYHueValue(P_LONG x, P_LONG y)
{ 
#ifdef _DEBUG
	if(!CheckPoint(x,y)||m_wImageDepth!=24||m_lpHSIArray==NULL)
	{
		AfxMessageBox("下标越界或非灰度图像!!!");
		AfxAbort();
	}
#endif  
	P_LONG y1 = m_HSIImageHeight - 1 - y;
	return m_lpHSIArray[y1 * m_HSIImageWidth + x];    
}
//***********************************************************

//***********************************************************
void  CImage::ImageInfo()
{
	CString msg;
	msg.Format("图像宽度: %5d\n图像高度: %5d\n数据宽度: %5d\n数据高度: %5d\n像素深度: %5d\n",m_ImageWidth,m_ImageHeight,m_nDibWidth,m_nDibHeight,m_wImageDepth);
	eImageType dImageType = GetImageType();
	switch(dImageType)
    {
        case  BinaryImage: 
			{
				msg+="颜色数目:    2\n图像类型: 二值图像";
				break;
			}
        case  FourBitsImage:
			{
				msg+="颜色数目:     16\n图像类型: 4位彩色值图像";
				break;
			}
        case  IndexColorImage:
			{
				msg+="颜色数目:   256\n图像类型: 8位彩色图像";
				break;
			}
		case  IndexGrayImage:
			{
				msg+="颜色数目:   256\n图像类型: 8位灰度图像";
				break;
			}
        case  HighColorImage: 
			{
				if(m_Is565RGBImage)
					msg+="颜色数目:    64K\n图像类型: 16位图像(565)";
				else
					msg+="颜色数目:    64K\n图像类型: 16位图像(555)";
				break;
			}
        case  TrueColorImage: 
			{
				msg+="颜色数目:   16M\n图像类型: 24位彩色图像";
				break;
			}
		case  UltraColorImage:
			{
				msg+="颜色数目:    4G\n图像类型: 32位彩色图像";
				break;
			}
    } 
	AfxMessageBox(msg);
}
//***********************************************************

//***********************************************************
WORD CImage::GetColorMapNum(int Depth)
{
	switch(Depth)
    {
        case  1: return 2;
        case  4: return 16;
        case  8: return 256;
        default: return 0;
    }   
}
//***********************************************************

//***********************************************************
eImageType CImage::GetImageType()
{
	switch(m_wImageDepth)
    {
        case  1: return BinaryImage;
        case  4: return FourBitsImage;
        case  8: 
			{
				int IsColorImage = 0;
				for(int gray= 0; gray < COLORCOUNT; gray++)
				{
					P_BYTE tr, tg, tb;
					tr = m_lpDibInfo->bmiColors[gray].rgbBlue;
					tg = m_lpDibInfo->bmiColors[gray].rgbGreen;
					tb = m_lpDibInfo->bmiColors[gray].rgbRed;
					BOOL bt =!( (tr==tg)&&(tg==tb)&&(tb==tr) );
					if( bt ) 
					{ 
						IsColorImage=1;
						break;
					}
				}    
				if(IsColorImage)
					return IndexColorImage;
				else
					return IndexGrayImage;
			}