allimage.cpp

医学图象处理系统

	if ( m_wImageDepth==8 )
	{
         byPCX_Pal[0] = 0x0C;
         DWORD wTemp = 1;
         for(wi=0;wi<COLORCOUNT;wi++)
         {
            byPCX_Pal[wTemp++] = m_lpDibInfo->bmiColors[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<ImgH; j++)
	{
		memcpy(TargetAddress, RowAddress[j+LTPt.y] + LTPt.x, ImgW);
		TargetAddress += ImgW;
	}
	
	Image_ManualBinary(lptmpImage , ImgSize,  threshold, Type);

	TargetAddress = lptmpImage;
	for(j=0; j<ImgH; j++)
	{
		memcpy(RowAddress[j+LTPt.y] + LTPt.x, TargetAddress, ImgW);
		TargetAddress += ImgW;
	}

	if(lptmpImage!=NULL) delete []lptmpImage;
	return TRUE;
}
BOOL CAllImage::Binary2(int threshold, int Type)
{
	BYTE Threshold=(BYTE) threshold;
	eImageType dImageType = GetImageType();
	if(dImageType != IndexGrayImage||m_lpDibArray==NULL) return FALSE;

	Image_ManualBinary(m_lpDibArray , m_ImageSize,  threshold, Type);
    
	return TRUE;
}

BOOL CAllImage::ImageProcess(CPoint LTPt,CPoint RBPt, eProcessType ProcType)
{
	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<ImgH; j++)
	{
		memcpy(TargetAddress, RowAddress[j+LTPt.y] + LTPt.x, ImgW);
		TargetAddress += ImgW;
	}	

	switch(ProcType)
    {
        case  PT_Sharpen_Sobel: 
			{
				Image_Sobel(lptmpImage , ImgW , ImgH);
				break;
			}
		case  PT_EdgeOrention_Sobel: 
			{
				Image_EdgeOrention_Sobel(lptmpImage , ImgW , ImgH);
				break;
			}
		case  PT_Sharpen_Roberts: 
			{
				Image_Roberts(lptmpImage , ImgW , ImgH);
				break;
			}
		
		case  PT_Sharpen_Prewitt: 
			{
				Image_Prewitt(lptmpImage , ImgW , ImgH);
				break;
			}
		case  PT_Sharpen_Laplacian: 
			{
				Image_Laplacian(lptmpImage , ImgW , ImgH);
				break;
			}	
		case  PT_Enhance_Histogram: 
			{
				Image_Histogramenhance(lptmpImage , ImgSize);
				break;
			}
		case  PT_ShowPyramidImage: 
			{
				Image_Pyramid_Show(lptmpImage , ImgW, ImgH);
				break;
			}
		case  PT_Segment_AutoBinary: 
			{
				Image_AutoBinary(lptmpImage , ImgSize);
				break;
			}
		case  PT_Segment_AutoBinary_ME: 
			{
				Image_AutoBinary_MaxExpection(lptmpImage , ImgSize);
				break;
			}
		case  PT_Segment_AutoBinary_Qtsu: 
			{
				Image_AutoBinary_Qtsu(lptmpImage , ImgSize);
				break;
			}
		case  PT_Segment_AutoBinary_EC: 
			{
				Image_AutoBinary_EntropicCorrelation(lptmpImage , ImgSize);
				break;
			}
	}

	TargetAddress = lptmpImage;
	for(j=0; j<ImgH; j++)
	{
		memcpy(RowAddress[j+LTPt.y] + LTPt.x, TargetAddress, ImgW);
		TargetAddress += ImgW;
	}

	if(lptmpImage!=NULL) delete []lptmpImage;
	return TRUE;
}
BOOL CAllImage::ImageProcess(eProcessType ProcType)
{
	eImageType dImageType = GetImageType();
	if(dImageType != IndexGrayImage||m_lpDibArray==NULL) return FALSE;

	switch(ProcType)
    {
        case  PT_Sharpen_Sobel: 
			{
				Image_Sobel(m_lpDibArray , m_nDibWidth , m_ImageHeight);
				break;
			}
		case  PT_EdgeOrention_Sobel: 
			{
				Image_EdgeOrention_Sobel(m_lpDibArray , m_nDibWidth , m_ImageHeight);
				break;
			}
		case  PT_Sharpen_Roberts: 
			{
				Image_Roberts(m_lpDibArray , m_nDibWidth , m_ImageHeight);
				break;
			}
		
		case  PT_Sharpen_Prewitt: 
			{
				Image_Prewitt(m_lpDibArray , m_nDibWidth , m_ImageHeight);
				break;
			}
		case  PT_Sharpen_Laplacian: 
			{
				Image_Laplacian(m_lpDibArray , m_nDibWidth , m_ImageHeight);
				break;
			}		
		case  PT_Enhance_Histogram: 
			{
				Image_Histogramenhance(m_lpDibArray , m_ImageSize);
				break;
			}	
		case  PT_ShowPyramidImage: 
			{
				VerticalFlip();
				Image_Pyramid_Show(m_lpDibArray , m_nDibWidth, m_ImageHeight);
				VerticalFlip();
				break;
			}	
		case  PT_Segment_AutoBinary: 
			{
				Image_AutoBinary(m_lpDibArray , m_ImageSize);
				break;
			}	
		case  PT_Segment_AutoBinary_ME: 
			{
				Image_AutoBinary_MaxExpection(m_lpDibArray , m_ImageSize);
				break;
			}
		case  PT_Segment_AutoBinary_Qtsu: 
			{
				Image_AutoBinary_Qtsu(m_lpDibArray , m_ImageSize);
				break;
			}
		case  PT_Segment_AutoBinary_EC: 
			{
				Image_AutoBinary_EntropicCorrelation(m_lpDibArray , m_ImageSize);
				break;
			}
	}
	return TRUE;
}

BOOL CAllImage::Wallis2(CPoint LTPt,CPoint RBPt,double Ia, int Imean, int Isigma, int Iam)
{
	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<ImgH; j++)
	{
		memcpy(TargetAddress, RowAddress[j+LTPt.y] + LTPt.x, ImgW);
		TargetAddress += ImgW;
	}	

	Image_Wallis(lptmpImage , ImgW , ImgH, Ia, Imean,Isigma, Iam);
	
	TargetAddress = lptmpImage;
	for(j=0; j<ImgH; j++)
	{
		memcpy(RowAddress[j+LTPt.y] + LTPt.x, TargetAddress, ImgW);
		TargetAddress += ImgW;
	}

	if(lptmpImage!=NULL) delete []lptmpImage;
	return TRUE;
}
BOOL CAllImage::Wallis2(double Ia, int Imean, int Isigma, int Iam)
{
	eImageType dImageType = GetImageType();
	if(dImageType != IndexGrayImage||m_lpDibArray==NULL) return FALSE;

    Image_Wallis(m_lpDibArray , m_nDibWidth , m_ImageHeight, Ia, Imean,Isigma,Iam);
	return TRUE;
}

BOOL CAllImage::SusanNormalFilter2(int bt, double dt, CPoint LTPt, CPoint RBPt)
{
	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<ImgH; j++)
	{
		memcpy(TargetAddress, RowAddress[j+LTPt.y] + LTPt.x, ImgW);
		TargetAddress += ImgW;
	}	

	Image_SUSAN_Filter(lptmpImage , ImgW , ImgH, bt, dt);
	
	TargetAddress = lptmpImage;
	for(j=0; j<ImgH; j++)
	{
		memcpy(RowAddress[j+LTPt.y] + LTPt.x, TargetAddress, ImgW);
		TargetAddress += ImgW;
	}

	if(lptmpImage!=NULL) delete []lptmpImage;
	return TRUE;
}
BOOL CAllImage::SusanNormalFilter2(int bt, double dt)
{
	eImageType dImageType = GetImageType();
	if(dImageType != IndexGrayImage||m_lpDibArray==NULL) return FALSE;

    Image_SUSAN_Filter(m_lpDibArray , m_nDibWidth , m_ImageHeight, bt, dt);
	return TRUE;
}

BOOL CAllImage::EnhaceLinear(CPoint LTPt, CPoint RBPt, int a2, int b2, int type)
{
	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<ImgH; j++)
	{
		memcpy(TargetAddress, RowAddress[j+LTPt.y] + LTPt.x, ImgW);
		TargetAddress += ImgW;
	}	

	switch(type)
	{
	case 0:
		Image_LinearScalar(lptmpImage, ImgSize, a2, b2); 
		break;
	case 1:
		Image_AutoLevels(lptmpImage, ImgSize);
		break;
	}

	TargetAddress = lptmpImage;
	for(j=0; j<ImgH; j++)
	{
		memcpy(RowAddress[j+LTPt.y] + LTPt.x, TargetAddress, ImgW);
		TargetAddress += ImgW;
	}

	if(lptmpImage!=NULL) delete []lptmpImage;
	return TRUE;
}
BOOL CAllImage::EnhaceLinear(int a2, int b2, int type)
{
	eImageType dImageType = GetImageType();
	if(dImageType != IndexGrayImage||m_lpDibArray==NULL) return FALSE;

	switch(type)
	{
	case 0:
		Image_LinearScalar(m_lpDibArray , m_ImageSize, a2, b2); 
		break;
	case 1:
		Image_AutoLevels(m_lpDibArray , m_ImageSize);
		break;
	}
	
	return TRUE;
}
BOOL CAllImage::SusanNormalEdge2(int bt, CPoint LTPt, CPoint RBPt)
{
	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<ImgH; j++)
	{
		memcpy(TargetAddress, RowAddress[j+LTPt.y] + LTPt.x, ImgW);
		TargetAddress += ImgW;
	}

	Image_SUSAN_Edge_Normal(lptmpImage , ImgW , ImgH, bt);
	
	TargetAddress = lptmpImage;
	for(j=0; j<ImgH; j++)
	{
		memcpy(RowAddress[j+LTPt.y] + LTPt.x, TargetAddress, ImgW);
		TargetAddress += ImgW;
	}

	if(lptmpImage!=NULL) delete []lptmpImage;
	return TRUE;
}
BOOL CAllImage::SusanNormalEdge2(int bt)
{
	eImageType dImageType = GetImageType();
	if(dImageType != IndexGrayImage||m_lpDibArray==NULL) return FALSE;

    Image_SUSAN_Edge_Normal(m_lpDibArray , m_nDibWidth , m_ImageHeight, bt);
	return TRUE;
}

BOOL CAllImage::SusanPrinciple2(int bt, CPoint LTPt, CPoint RBPt)
{
	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<ImgH; j++)
	{
		memcpy(TargetAddress, RowAddress[j+LTPt.y] + LTPt.x, ImgW);
		TargetAddress += ImgW;
	}	

	Image_SUSAN_Principle(lptmpImage , ImgW , ImgH, bt);
	
	TargetAddress = lptmpImage;
	for(j=0; j<ImgH; j++)
	{
		memcpy(RowAddress[j+LTPt.y] + LTPt.x, TargetAddress, ImgW);
		TargetAddress += ImgW;
	}

	if(lptmpImage!=NULL) delete []lptmpImage;
	return TRUE;
}
BOOL CAllImage::SusanPrinciple2(int bt)
{
	eImageType dImageType = GetImageType();
	if(dImageType != IndexGrayImage||m_lpDibArray==NULL) return FALSE;

    Image_SUSAN_Principle(m_lpDibArray , m_nDibWidth , m_ImageHeight, bt);
	return TRUE;
}

BOOL CAllImage::BinaryMorph2(CPoint LTPt,CPoint RBPt, eProcessType ProcType, 
		              BYTE *Mask,int MaskR,BYTE TargetGray)
{
	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<ImgH; j++)
	{
		memcpy(TargetAddress, RowAddress[j+LTPt.y] + LTPt.x, ImgW);
		TargetAddress += ImgW;
	}	

	switch(ProcType)
    {
        case  PT_Morphology_Dilation: 
			{
				Image_Binary_Dilation(lptmpImage , ImgW , ImgH , Mask, MaskR, TargetGray);
				break;
			}
		case  PT_Morphology_Erosion: 
			{
				Image_Binary_Erosion(lptmpImage , ImgW , ImgH , Mask, MaskR, TargetGray);
				break;
			}
		
		case  PT_Morphology_Opening: 
			{
				Image_Binary_Erosion(lptmpImage , ImgW , ImgH , Mask, MaskR, TargetGray);
				Image_Binary_Dilation(lptmpImage , ImgW , ImgH , Mask, MaskR, TargetGray);
				break;
			}
		case  PT_Morphology_Closing: 
			{
				Image_Binary_Dilation(lptmpImage , ImgW , ImgH , Mask, MaskR, TargetGray);
				Image_Binary_Erosion(lptmpImage , ImgW , ImgH , Mask, MaskR, TargetGray);
				break;
			}	
	}

	TargetAddress = lptmpImage;
	for(j=0; j<ImgH; j++)
	{
		memcpy(RowAddress[j+LTPt.y] + LTPt.x, TargetAddress, ImgW);
		TargetAddress += ImgW;
	}

	if(lptmpImage!=NULL) delete []lptmpImage;
	return TRUE;
}
BOOL CAllImage::BinaryMorph2(eProcessType ProcType, BYTE *Mask, int MaskR, BYTE TargetGray)
{
	eImageType dImageType = GetImageType();
	if(dImageType != IndexGrayImage||m_lpDibArray==NULL) return FALSE;

	switch(ProcType)
    {
        case  PT_Morphology_Dilation: 
			{
				Image_Binary_Dilation(m_lpDibArray , m_nDibWidth , m_ImageHeight,
					                 Mask, MaskR, TargetGray);
				break;
			}
		case  PT_Morphology_Erosion: