allimage.cpp

医学图象处理系统

			{
				Image_Binary_Erosion(m_lpDibArray , m_nDibWidth , m_ImageHeight,
									 Mask, MaskR, TargetGray);
				break;
			}
		
		case  PT_Morphology_Opening: 
			{
				Image_Binary_Erosion(m_lpDibArray , m_nDibWidth , m_ImageHeight, 
									 Mask, MaskR, TargetGray);
				Image_Binary_Dilation(m_lpDibArray , m_nDibWidth , m_ImageHeight,
					                 Mask, MaskR, TargetGray);
				break;
			}
		case  PT_Morphology_Closing: 
			{
				Image_Binary_Dilation(m_lpDibArray , m_nDibWidth , m_ImageHeight,
					                 Mask, MaskR, TargetGray);
				Image_Binary_Erosion(m_lpDibArray , m_nDibWidth , m_ImageHeight, 
									 Mask, MaskR, TargetGray);
				break;
			}		
	}
	return TRUE;
}
BOOL CAllImage::GrayMorph2(CPoint LTPt,CPoint RBPt, eProcessType ProcType, BYTE *Mask,int MaskR)
{
	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_Gray_Dilation(lptmpImage , ImgW , ImgH , Mask, MaskR);
				break;
			}
		case  PT_Morphology_Erosion: 
			{
				Image_Gray_Erosion(lptmpImage , ImgW , ImgH , Mask, MaskR);
				break;
			}
		
		case  PT_Morphology_Opening: 
			{
				Image_Gray_Erosion(lptmpImage , ImgW , ImgH , Mask, MaskR);
				Image_Gray_Dilation(lptmpImage , ImgW , ImgH , Mask, MaskR);
				break;
			}
		case  PT_Morphology_Closing: 
			{
				Image_Gray_Dilation(lptmpImage , ImgW , ImgH , Mask, MaskR);
				Image_Gray_Erosion(lptmpImage , ImgW , ImgH , Mask, MaskR);
				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::GrayMorph2(eProcessType ProcType, BYTE *Mask, int MaskR)
{
	eImageType dImageType = GetImageType();
	if(dImageType != IndexGrayImage||m_lpDibArray==NULL) return FALSE;

	switch(ProcType)
    {
        case  PT_Morphology_Dilation: 
			{
				Image_Gray_Dilation(m_lpDibArray , m_nDibWidth , m_ImageHeight,
					                 Mask, MaskR);
				break;
			}
		case  PT_Morphology_Erosion: 
			{
				Image_Gray_Erosion(m_lpDibArray , m_nDibWidth , m_ImageHeight,
									 Mask, MaskR);
				break;
			}
		
		case  PT_Morphology_Opening: 
			{
				Image_Gray_Erosion(m_lpDibArray , m_nDibWidth , m_ImageHeight, 
									 Mask, MaskR);
				Image_Gray_Dilation(m_lpDibArray , m_nDibWidth , m_ImageHeight,
					                 Mask, MaskR);
				break;
			}
		case  PT_Morphology_Closing: 
			{
				Image_Gray_Dilation(m_lpDibArray , m_nDibWidth , m_ImageHeight,
					                 Mask, MaskR);
				Image_Gray_Erosion(m_lpDibArray , m_nDibWidth , m_ImageHeight, 
									 Mask, MaskR);
				break;
			}		
	}
	return TRUE;
}

BOOL CAllImage::Binary_AreaLabel(CPoint LTPt,CPoint RBPt, 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;
	}	

	int AreaNum = Image_Binary_grass_label(lptmpImage , ImgW , ImgH, TargetGray);
	struct AreaAttrib  *L_aattrib = new  AreaAttrib[AreaNum];
	Image_Binary_Get_Area_Attrib(lptmpImage , ImgW , ImgH, L_aattrib, AreaNum);
	memset(lptmpImage, ~TargetGray,  ImgSize);
	for(int i= 0; i< AreaNum; i++)
	{
		int AreaW = L_aattrib[i].Outline.right - L_aattrib[i].Outline.left;
		int AreaH = L_aattrib[i].Outline.bottom - L_aattrib[i].Outline.top;
		int x0 =  L_aattrib[i].Outline.left;
		int x1 =  L_aattrib[i].Outline.right;
		int	y0 =  L_aattrib[i].Outline.top; 
		int y1 =  L_aattrib[i].Outline.bottom;
		memset(lptmpImage + y0*ImgW+x0, TargetGray, AreaW);
		int ypos = y0 * ImgW;
		for(int j= y0; j<= y1; j+= ImgW)
		{
			*(lptmpImage + ypos + x0) = TargetGray;
			*(lptmpImage + ypos + x1) = TargetGray;
			ypos += ImgW;
		}		
		memset(lptmpImage + y1*ImgW+x0, TargetGray, AreaW);
	}
	if (L_aattrib !=NULL)  delete[]L_aattrib;

	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::Binary_AreaLabel(BYTE TargetGray, CPoint *OutPutPt, int &PtMum)
{
	eImageType dImageType = GetImageType();
	if(dImageType != IndexGrayImage||m_lpDibArray==NULL) return FALSE;
	VerticalFlip();
    int AreaNum = Image_Binary_grass_label(m_lpDibArray , m_nDibWidth , m_ImageHeight, TargetGray);
	/*struct AreaAttrib  *L_aattrib = new  AreaAttrib[AreaNum];
	Image_Binary_Get_Area_Attrib(m_lpDibArray, m_nDibWidth, m_ImageHeight, L_aattrib, AreaNum);
	memset(m_lpDibArray, ~TargetGray,  m_nDibWidth*m_ImageHeight);
	for(int i= 0; i< AreaNum; i++)
	{
		int AreaW = L_aattrib[i].Outline.right - L_aattrib[i].Outline.left;
		int AreaH = L_aattrib[i].Outline.bottom - L_aattrib[i].Outline.top;
		int x0 =  L_aattrib[i].Outline.left ;
		int x1 =  L_aattrib[i].Outline.right ;
		int	y0 =  L_aattrib[i].Outline.top ; 
		int y1 =  L_aattrib[i].Outline.bottom ;
		OutPutPt[i].x = int(L_aattrib[i].Centerx + 0.5);
		OutPutPt[i].y = int(L_aattrib[i].Centery + 0.5);
		
		memset(m_lpDibArray + y0*m_nDibWidth+x0, TargetGray, AreaW);
		int ypos = y0 * m_nDibWidth;
		for(int j= y0; j<=y1; j++)
		{
			*(m_lpDibArray + ypos + x0) = TargetGray;
			*(m_lpDibArray + ypos + x1) = TargetGray;
			ypos += m_nDibWidth;
		}		
		memset(m_lpDibArray + y1*m_nDibWidth+x0, TargetGray, AreaW);
	}
	if (L_aattrib !=NULL)  delete[]L_aattrib;//*/
	VerticalFlip();
	PtMum = AreaNum;
	return TRUE;
}
BOOL CAllImage::Gauss_Blur2(double Sigma, 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_Gauss_Blur(lptmpImage , ImgW , ImgH, Sigma);
	
	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::Gauss_Blur2(double Sigma)
{
	eImageType dImageType = GetImageType();
	if(dImageType != IndexGrayImage||m_lpDibArray==NULL) return FALSE;

	Image_Gauss_Blur(m_lpDibArray , m_nDibWidth , m_ImageHeight, Sigma); 
	return TRUE;
}
BOOL CAllImage::Gauss_Sharpen2(double Sigma, 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_Gauss_Sharpen(lptmpImage , ImgW , ImgH, Sigma);
	
	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::Gauss_Sharpen2(double Sigma)
{
	eImageType dImageType = GetImageType();
	if(dImageType != IndexGrayImage||m_lpDibArray==NULL) return FALSE;

	Image_Gauss_Sharpen(m_lpDibArray , m_nDibWidth , m_ImageHeight, Sigma); 
	return TRUE;
}
BOOL CAllImage::Marr_Hildreth2(double Sigma, 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_Edge_MarrHildreth(lptmpImage , ImgW , ImgH, Sigma);
	
	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::Marr_Hildreth2(double Sigma)
{
	eImageType dImageType = GetImageType();
	if(dImageType != IndexGrayImage||m_lpDibArray==NULL) return FALSE;

	Image_Edge_MarrHildreth(m_lpDibArray , m_nDibWidth , m_ImageHeight, Sigma); 
	return TRUE;
}
BOOL CAllImage::Binary_Process(eProcessType ProcType, BYTE TargetGray, 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;
	}	
	
	switch(ProcType)
    {
        case  PT_Binary_Thin_Hilditch: 
			{
				Image_Binary_Thin_Hilditch(lptmpImage , ImgW , ImgH, TargetGray);
				break;
			}
		case  PT_Binary_Thin_ZhangSuen: 
			{
				Image_Binary_Thin_ZhangSuen(lptmpImage , ImgW , ImgH, TargetGray);
				break;
			}
		case  PT_Binary_Thin_Somebody: 
			{
				Image_Binary_Thin_Somebody(lptmpImage , ImgW , ImgH, TargetGray);
				break;
			}
		case  PT_Binary_Transform_Hough: 
			{
				Image_Binary_HoughTransform(lptmpImage , ImgW , ImgH, TargetGray);
				break;
			}
		case  PT_Binary_Transform_Radon: 
			{
				Image_Binary_RadonTransform(lptmpImage , ImgW , ImgH, TargetGray);
				break;
			}
		case  PT_Binary_Edge_Simple: 
			{
				Image_Binary_SimpleEdge(lptmpImage , ImgW , ImgH, 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::Binary_Process(eProcessType ProcType,BYTE TargetGray)
{
	eImageType dImageType = GetImageType();
	if(dImageType != IndexGrayImage||m_lpDibArray==NULL) return FALSE;

	switch(ProcType)
    {
        case  PT_Binary_Thin_Hilditch: 
			{
				Image_Binary_Thin_Hilditch(m_lpDibArray , m_nDibWidth , m_ImageHeight, TargetGray); 
				break;
			}
		case  PT_Binary_Thin_ZhangSuen: 
			{
				Image_Binary_Thin_ZhangSuen(m_lpDibArray , m_nDibWidth , m_ImageHeight, TargetGray); 
				break;
			}
		case  PT_Binary_Thin_Somebody: 
			{
				Image_Binary_Thin_Somebody(m_lpDibArray , m_nDibWidth , m_ImageHeight, TargetGray); 
				break;
			}
		case  PT_Binary_Transform_Hough: 
			{
				Image_Binary_HoughTransform(m_lpDibArray , m_nDibWidth , m_ImageHeight, TargetGray); 
				break;
			}
		case  PT_Binary_Transform_Radon: 
			{
				Image_Binary_RadonTransform(m_lpDibArray , m_nDibWidth , m_ImageHeight, TargetGray); 
				break;
			}
		case  PT_Binary_Edge_Simple: 
			{
				Image_Binary_SimpleEdge(m_lpDibArray , m_nDibWidth , m_ImageHeight, TargetGray); 
				break;
			}
	}	
	return TRUE;
}
BOOL CAllImage::ImageNeedMaskProcess(eProcessType ProcType, int masksize , 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;
	}	

	switch(ProcType)
    {
        case  PT_Smoothing_Mean: 
			{
				Image_MeanFilter(lptmpImage , ImgW , ImgH, masksize);
				break;
			}
		case  PT_Smoothing_RecursiveMiddle: 
			{
				Image_RMiddleFilter(lptmpImage , ImgW , ImgH, masksize);
				break;
			}
		case  PT_Smoothing_NonRecursiveMiddle: 
			{
				Image_NonRMiddleFilter(lptmpImage , ImgW , ImgH, masksize);
				break;
			}		
		case  PT_Smoothing_FastMiddle: 
			{
				Image_FastMedian(lptmpImage , ImgW , ImgH, masksize);
				break;
			}
		case  PT_Segment_RoInvarOperator: 
			{
				Image_Edge_RotateInvariantOperator(lptmpImage , ImgW , ImgH, masksize);
				break;
			}
		case  PT_EdgeOrention_RoInvarOperator: 
			{
				Image_EdgeOrention_RotateInvariantOperator(lptmpImage , ImgW , ImgH, masksize);
				break;
			}
		case  PT_ShowMosaicImage: 
			{
				Image_Mosaic_Show(lptmpImage , ImgW , ImgH, masksize);
				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::ImageNeedMaskProcess(eProcessType ProcType, int masksize )
{
	eImageType dImageType = GetImageType();
	if(dImageType != IndexGrayImage||m_lpDibArray==NULL) return FALSE;

	switch(ProcType)
    {
        case  PT_Smoothing_Mean: 
			{
				Image_MeanFilter(m_lpDibArray , m_nDibWidth , m_ImageHeight, masksize);
				break;
			}
		case  PT_Smoothing_RecursiveMiddle: 
			{
				Image_RMiddleFilter(m_lpDibArray , m_nDibWidth , m_ImageHeight, masksize);
				break;
			}
		case  PT_Smoothing_NonRecursiveMiddle: 
			{
				Image_NonRMiddleFilter(m_lpDibArray , m_nDibWidth , m_ImageHeight, masksize); 
				break;
			}
		
		case  PT_Smoothing_FastMiddle: 
			{
				Image_FastMedian(m_lpDibArray , m_nDibWidth , m_ImageHeight, masksize); 
				break;
			}
		case  PT_Segment_RoInvarOperator: 
			{
				Image_Edge_RotateInvariantOperator(m_lpDibArray , m_nDibWidth , m_ImageHeight, masksize);
				break;
			}	
		case  PT_EdgeOrention_RoInvarOperator: 
			{
				Image_EdgeOrention_RotateInvariantOperator(m_lpDibArray , m_nDibWidth , m_ImageHeight, masksize);
				break;
			}
		case  PT_ShowMosaicImage: 
			{
				Image_Mosaic_Show(m_lpDibArray , m_nDibWidth , m_ImageHeight, masksize);
				break;
			}
	}

	return TRUE;
}