imageprocess.cpp

医学图象处理系统

	memcpy(InputImage, OrientationImage, Imagesize);
	if(    RowAddress!=NULL)    delete []RowAddress;
	if(MagntiudeImage!=NULL)    delete []MagntiudeImage;
	if(OrientationImage!=NULL)  delete []OrientationImage;
}
void Image_Convolution_33(BYTE* InputImage , int ImgW , int ImgH ,int *Template)
{
	int	 Imagesize = ImgW*ImgH;
	if (InputImage==NULL || Imagesize==0) return ;

	int i,j;
	BYTE *Image ;
	BYTE *tmpImage = new BYTE[Imagesize];
    BYTE **RowAddress = new BYTE*[ImgH];
  
	//initialize 
	memset(tmpImage, 0, Imagesize);
	RowAddress[0] = InputImage;
	for(i=1 ; i<ImgH ;i++)
	{
		RowAddress[i] = RowAddress[i-1] + ImgW;
	}

	int  nG ,a00 ,a01, a02, a10, a11, a12, a20 ,a21, a22;

	a00 = Template[0];   a01 = Template[1];  a02 = Template[2];  
	a10 = Template[3];   a11 = Template[4];  a12 = Template[5];  
	a20 = Template[6];   a21 = Template[7];  a22 = Template[8];  
	Image = tmpImage + ImgW;
	for(j=1; j<ImgH-1; j++)
	{		
		for(i=1; i<ImgW-1; i++)
		{
			nG  = a00*RowAddress[j-1][i-1] + a01*RowAddress[j-1][i] + a02*RowAddress[j-1][i+1];
			nG += a10*RowAddress[ j ][i-1] + a11*RowAddress[ j ][i] + a12*RowAddress[ j ][i+1];
			nG += a20*RowAddress[j+1][i-1] + a21*RowAddress[j+1][i] + a22*RowAddress[j+1][i+1];
			nG  = labs(nG); 
			Image[i] = (nG>255) ? 255: nG;				 
		}
		Image += ImgW;
	}

	memcpy(InputImage, tmpImage, Imagesize);
	if(  tmpImage!=NULL)  delete []tmpImage;
	if(RowAddress!=NULL)  delete RowAddress;
}
void Image_Convolution_33(BYTE* InputImage , int ImgW , int ImgH ,int *Template1,int *Template2)
{
	int	 Imagesize = ImgW*ImgH;
	if (InputImage==NULL || Imagesize==0) return ;

	int i,j;
	BYTE *Image ;
	BYTE *tmpImage = new BYTE[Imagesize];
    BYTE **RowAddress = new BYTE*[ImgH];
  
	//initialize 
	memset(tmpImage, 0, ImgW*ImgH);
	RowAddress[0] = InputImage;
	for(i=1 ; i<ImgH ;i++)
	{
		RowAddress[i] = RowAddress[i-1] + ImgW;
	}

	double dx,dy;
	int    nG , a00 ,a01, a02, a10, a11, a12, a20 ,a21, a22;
	int         b00 ,b01, b02, b10, b11, b12, b20 ,b21, b22;

	a00 = Template1[0];   a01 = Template1[1];  a02 = Template1[2];  
	a10 = Template1[3];   a11 = Template1[4];  a12 = Template1[5];  
	a20 = Template1[6];   a21 = Template1[7];  a22 = Template1[8];  

	b00 = Template2[0];   b01 = Template2[1];  b02 = Template2[2];  
	b10 = Template2[3];   b11 = Template2[4];  b12 = Template2[5];  
	b20 = Template2[6];   b21 = Template2[7];  b22 = Template2[8];  

	Image = tmpImage + ImgW;
	for(j=1; j<ImgH-1; j++)
	{		
		for(i=1; i<ImgW-1; i++)
		{
			dx  = a00*RowAddress[j-1][i-1] + a01*RowAddress[j-1][i] + a02*RowAddress[j-1][i+1];
			dx += a10*RowAddress[ j ][i-1] + a11*RowAddress[ j ][i] + a12*RowAddress[ j ][i+1];
			dx += a20*RowAddress[j+1][i-1] + a21*RowAddress[j+1][i] + a22*RowAddress[j+1][i+1];
			dy  = b00*RowAddress[j-1][i-1] + b01*RowAddress[j-1][i] + b02*RowAddress[j-1][i+1];
			dy += b10*RowAddress[ j ][i-1] + b11*RowAddress[ j ][i] + b12*RowAddress[ j ][i+1];
			dy += b20*RowAddress[j+1][i-1] + b21*RowAddress[j+1][i] + b22*RowAddress[j+1][i+1];
			nG  = int(sqrt(dx*dx+dy*dy)+0.5);
			Image[i] = (nG>255) ? 255: nG;				 
		}
		Image += ImgW;
	}
	memcpy(InputImage, tmpImage, Imagesize);
	if(  tmpImage!=NULL)  delete []tmpImage;
	if(RowAddress!=NULL)  delete RowAddress;
}

void Image_Roberts(BYTE* InputImage , int ImgW , int ImgH)
{
	int	 Imagesize = ImgW*ImgH;
	if (InputImage==NULL || Imagesize==0) return ;

	int i,j;
	BYTE *Image ;
	BYTE *tmpImage = new BYTE[Imagesize];
    BYTE **RowAddress = new BYTE*[ImgH];
  
	//initialize 
	memset(tmpImage, 0, Imagesize);
	RowAddress[0] = InputImage;
	for(i=1 ; i<ImgH ;i++)
	{
		RowAddress[i] = RowAddress[i-1] + ImgW;
	}

	int dx,dy;
	Image = tmpImage + ImgW;
	for(j=0; j<ImgH-1; j++)
	{		
		for(i=0; i<ImgW-1; i++)
		{
			dx = abs(RowAddress[ j ][ i ] - RowAddress[j+1][i+1]);
			dy = abs(RowAddress[j+1][ i ] - RowAddress[ j ][i+1]);
			Image[i] = (dx>dy) ? dx: dy;				 
		}
		Image += ImgW;
	}

	memcpy(InputImage, tmpImage, Imagesize);
	if(  tmpImage!=NULL)  delete []tmpImage;
	if(RowAddress!=NULL)  delete RowAddress;
}
void Image_Prewitt(BYTE* InputImage , int ImgW , int ImgH)
{
	int	 Imagesize = ImgW*ImgH;
	if (InputImage==NULL || Imagesize==0) return ;

	int i,j;
	BYTE *Image ;
	BYTE *tmpImage = new BYTE[Imagesize];
    BYTE **RowAddress = new BYTE*[ImgH];
  
	//initialize 
	memset(tmpImage, 0, Imagesize);
	RowAddress[0] = InputImage;
	for(i=1 ; i<ImgH ;i++)
	{
		RowAddress[i] = RowAddress[i-1] + ImgW;
	}

	double dx,dy;
	int    nG;
	Image = tmpImage + ImgW;
	for(j=1; j<ImgH-1; j++)
	{		
		for(i=1; i<ImgW-1; i++)
		{
			dx  = RowAddress[j-1][i+1] - RowAddress[j-1][i-1];
			dx += RowAddress[ j ][i+1] - RowAddress[ j ][i-1];
			dx += RowAddress[j+1][i+1] - RowAddress[j+1][i-1];
			dy  = RowAddress[j+1][i-1] - RowAddress[j-1][i-1];
			dy += RowAddress[j+1][ i ] - RowAddress[j-1][ i ];
			dy += RowAddress[j+1][i+1] - RowAddress[j-1][i+1];
			nG  = int(sqrt(dx*dx+dy*dy)+0.5);
			Image[i] = (nG>255) ? 255: nG;				 
		}
		Image += ImgW;
	}

	memcpy(InputImage, tmpImage, Imagesize);
	if(  tmpImage!=NULL)  delete []tmpImage;
	if(RowAddress!=NULL)  delete RowAddress;
}
void Image_Laplacian(BYTE* InputImage , int ImgW , int ImgH)
{
	int	 Imagesize = ImgW*ImgH;
	if (InputImage==NULL || Imagesize==0) return ;

	int i,j;
	BYTE *Image ;
	BYTE *tmpImage = new BYTE[Imagesize];
    BYTE **RowAddress = new BYTE*[ImgH];
  
	//initialize 
	memset(tmpImage, 0, Imagesize);
	RowAddress[0] = InputImage;
	for(i=1 ; i<ImgH ;i++)
	{
		RowAddress[i] = RowAddress[i-1] + ImgW;
	}

	Image = tmpImage + ImgW;
	int nG;
	for(j=1; j<ImgH-1; j++)
	{		
		for(i=1; i<ImgW-1; i++)
		{
			nG  = RowAddress[j-1][ i ] + RowAddress[j+1][ i ];
			nG += RowAddress[ j ][i-1] + RowAddress[ j ][i+1];
			nG  = abs(5*RowAddress[j][i] - nG);
			Image[i] = (nG>255) ? 255 : nG;				 
		}
		Image += ImgW;
	}

	memcpy(InputImage,tmpImage,ImgW*ImgH);
	if(  tmpImage!=NULL)  delete []tmpImage;
	if(RowAddress!=NULL)  delete []RowAddress;
}
void Image_Wallis(BYTE* InputImage , int ImgW , int ImgH, double Ia, int Imean, int Isigma, int Iam)
{
	int	 Imagesize = ImgW*ImgH;
	if (InputImage==NULL || Imagesize==0) return ;

	int i,j;
	BYTE *Image ;
	BYTE *tmpImage = new BYTE[Imagesize];
	int  *Sigma    = new int[Imagesize];
    BYTE **RowAddress = new BYTE*[ImgH];
	memset(Sigma, 0, ImgW*ImgH*sizeof(int));
	//initialize 
	memset(tmpImage, 0, Imagesize);
	RowAddress[0] = InputImage;
	for(i=1 ; i<ImgH ;i++)
	{
		RowAddress[i] = RowAddress[i-1] + ImgW;
	}

	Image = tmpImage + ImgW;
	int nG;
	for(j=1; j<ImgH-1; j++)
	{		
		for(i=1; i<ImgW-1; i++)
		{
			nG  = RowAddress[j-1][i-1] + RowAddress[j-1][i] + RowAddress[j-1][i+1];
			nG += RowAddress[ j ][i-1] + RowAddress[ j ][i] + RowAddress[ j ][i+1];
			nG += RowAddress[j+1][i-1] + RowAddress[j+1][i] + RowAddress[j+1][i+1];
			Image[i] = (nG + 5)/9;						 
		}
		Image += ImgW;
	}

	Image = tmpImage + ImgW;
	for(j=1; j<ImgH-1; j++)
	{		
		for(i=1; i<ImgW-1; i++)
		{
			nG  = (RowAddress[j-1][i-1] - Image[i])*(RowAddress[j-1][i-1] - Image[i]);
			nG += (RowAddress[j-1][ i ] - Image[i])*(RowAddress[j-1][ i ] - Image[i]);
			nG += (RowAddress[j-1][i+1] - Image[i])*(RowAddress[j-1][i+1] - Image[i]);
			nG += (RowAddress[ j ][i-1] - Image[i])*(RowAddress[ j ][i-1] - Image[i]);
			nG += (RowAddress[ j ][ i ] - Image[i])*(RowAddress[ j ][ i ] - Image[i]);
			nG += (RowAddress[ j ][i+1] - Image[i])*(RowAddress[ j ][i+1] - Image[i]);
			nG += (RowAddress[j+1][i-1] - Image[i])*(RowAddress[j+1][i-1] - Image[i]);
			nG += (RowAddress[j+1][ i ] - Image[i])*(RowAddress[j+1][ i ] - Image[i]);
			nG += (RowAddress[j+1][i+1] - Image[i])*(RowAddress[j+1][i+1] - Image[i]);
			Sigma[j*ImgW + i] = int((sqrt(nG) + 5)/9);						 
		}
		Image += ImgW;
	}
	Image = tmpImage + ImgW;
	double ftemp;
	for(j=1; j<ImgH-1; j++)
	{		
		for(i=1; i<ImgW-1; i++)
		{    
			 ftemp= (Ia*Imean+(1-Ia)*Image[i])	+
				    (RowAddress[j][i] - Image[i])*(Iam/(Iam*Sigma[j*ImgW+i]+Isigma));
			 
			 RowAddress[j][i] = BYTE(ftemp+0.5);
		}
		Image += ImgW;
	}
	if(     Sigma!=NULL)  delete []Sigma;
	if(  tmpImage!=NULL)  delete []tmpImage;
	if(RowAddress!=NULL)  delete []RowAddress;
}

void Image_SUSAN_Filter(BYTE* InputImage , int ImgW , int ImgH, int bt, double dt) 
{
	int	 Imagesize = ImgW*ImgH;
	if (InputImage==NULL || Imagesize==0) return ;

    int      i,j,x,y,area,brightness,tmp,centre;
	int      mask_size = ((int)(1.5 * dt)) + 1;
	BYTE    *dpt,  *cp,  *bp,  *ip,  bbp[516];
    
	double   temp,total;

	BYTE *tmpImage = new BYTE[Imagesize];
    BYTE **RAtmpImage = new BYTE*[ImgH];
	BYTE **RAimg = new BYTE*[ImgH];
	BYTE *dp = new BYTE[(2*mask_size+1)*(2*mask_size+1)];
	//initialize 
	memcpy(tmpImage, InputImage, Imagesize);
	
	RAtmpImage[0] = InputImage;
	RAimg[0]      = tmpImage;
	for(i=1 ; i<ImgH ;i++)
	{
		RAtmpImage[i] = RAtmpImage[i-1] + ImgW;
		RAimg[i]      =      RAimg[i-1] + ImgW;
	}

	CProgressDlg * MsgHandler = new CProgressDlg();
    MsgHandler->Create(NULL);
    MsgHandler->SetStatus("SUSAN Filter Process");

	//建立查找表
    bbp[0]=bbp[1]=bbp[515]=bbp[514]=0;
    bp=bbp+258;    
   
    for(int k=-256;k<257;k++)
	{
        temp=((float)k)/((float)bt);
        temp=temp*temp;
        temp=100.0*exp(-temp)+0.5;
        bbp[k+258]= (BYTE)(temp);
	}

	dpt = dp;
	temp   = -(dt*dt);
    for(i=-mask_size; i<=mask_size; i++)
	{
        for(j=-mask_size; j<=mask_size; j++)
		{
            x = (int) (100.0 * exp( ((float)((i*i)+(j*j))) / temp )+0.5);
            *dpt++ = (BYTE)x;
		}
	}  //建立查找表结束
	//开始滤波
    for(j=mask_size;  j<ImgH-mask_size;  j++)
	{
		for(i=mask_size;  i<ImgW-mask_size;  i++) 
		{
			area   = 0;
			total  = 0;
			dpt    = dp;
            centre = RAimg[j][i];
		    cp     = bp + centre;
            for(y=-mask_size; y<=mask_size; y++)
			{
			    ip = RAimg[j+y] + i - mask_size;
                for(x=-mask_size; x<=mask_size; x++)
				{
				    brightness = *ip++;
                    tmp = (*dpt++) * (*(cp-brightness));
                    area += tmp;
                    total += tmp * brightness;
				}    			  
			}
            tmp = area-10000;
            if(tmp>30000)
			{
			   RAtmpImage[j][i] = (BYTE)( (total-(centre*10000))/tmp+0.5 );
			}
		    else
			{
			    int p[8],k,l,tmp;
                p[0]=RAimg[j-1][i-1];  p[1]=RAimg[j-1][ i ];  p[2]=RAimg[j-1][i+1];
				p[3]=RAimg[ j ][i-1];                         p[4]=RAimg[ j ][i+1]; 
				p[5]=RAimg[j+1][i-1];  p[6]=RAimg[j+1][i-1];  p[7]=RAimg[j+1][i+1];

                for(k=0; k<7; k++)
                    for(l=0; l<(7-k); l++)
						if (p[l]>p[l+1])
						{
                             tmp=p[l]; p[l]=p[l+1]; p[l+1]=tmp;
						}
                RAtmpImage[j][i] = (p[3]+p[4])/2;
			}
		}
		MsgHandler->SetPos(100 * j /ImgH );
	}

	//滤波结束
	if(dp!=NULL)  delete []dp;
	if(RAimg!=NULL)  delete []RAimg;
	if(tmpImage!=NULL)  delete []tmpImage;
	if(RAtmpImage!=NULL)  delete []RAtmpImage;
	MsgHandler->DestroyWindow();
    delete  MsgHandler;
}
void Image_MeanFilter(BYTE* InputImage , int ImgW , int ImgH ,int Masksize)
{
	int	 Imagesize = ImgW* ImgH;
	if (InputImage==NULL || Imagesize==0) return ;

	int  i, j;
	int  Area = Masksize* Masksize; 
	int  HalfArea = Area/ 2;
	int	 r = Masksize/ 2;  
	BYTE *tmpImage    = new BYTE[Imagesize];
    BYTE **RowAddress = new BYTE*[ImgH];
	BYTE **Image	  = new BYTE*[ImgH];
  
	//initialize 
	memcpy(tmpImage, InputImage, Imagesize);

	Image[0] = InputImage;
	RowAddress[0] = tmpImage; 
	for(i=1 ; i<ImgH ;i++)
	{
		Image[i]	  = Image[i-1] + ImgW;
		RowAddress[i] = RowAddress[i-1] + ImgW;
	}

	int dx, dy, nG;
	for(j=r; j<ImgH-r; j++)
	{		
		for(i=r; i<ImgW-r; i++)
		{
			nG = 0;
			for(dy= -r; dy<= r; dy++)
				for(dx= -r; dx<= r; dx++)
					nG +=  RowAddress[j+dy][i+dx];
			Image[j][i] = (nG + HalfArea)/ Area;				 
		}
	}

	if(Image	  != NULL)  delete []Image;
	if(tmpImage   != NULL)  delete []tmpImage;
	if(RowAddress != NULL)  delete []RowAddress;
}

void Image_Mosaic_Show(BYTE* InputImage , int ImgW , int ImgH ,int Masksize)
{
	int	 Imagesize = ImgW*ImgH;
	if (InputImage==NULL || Imagesize==0) return ;

	int  i, j;
	int  Area = Masksize*Masksize; 
	int  HalfArea = Area/2;
	BYTE *tmpImage = new BYTE[Imagesize] ;
	BYTE **S_RowAddress = new BYTE*[ImgH];
	BYTE **D_RowAddress = new BYTE*[ImgH];
  
	//initialize 
	memcpy(tmpImage, InputImage, Imagesize);

	S_RowAddress[0] = InputImage;
	D_RowAddress[0] = tmpImage;
	for(i=1 ; i<ImgH ;i++)
	{
		D_RowAddress[i] = D_RowAddress[i-1] + ImgW;
		S_RowAddress[i] = S_RowAddress[i-1] + ImgW;
	}
	int dx,dy;
	int    nG;
	for(j=0; j<ImgH- Masksize; j+=Masksize)
	{		
		for(i=0; i<ImgW- Masksize; i+=Masksize)
		{
			nG = 0;
			for(dy=0; dy<Masksize; dy++)
				for(dx=0; dx<Masksize; dx++)
					nG +=  D_RowAddress[j+dy][i+dx]; 
			BYTE temp = (nG+HalfArea)/Area;
			for(dy=0; dy<Masksize; dy++)
			{
				memset(S_RowAddress[j+dy] + i, temp, Masksize);
			}
		}	
		int remained = ImgW%Masksize;
		if(remained)
		{
			for(dy=0; dy<Masksize; dy++)
				for(dx=0; dx<remained; dx++)
					nG +=  D_RowAddress[j+dy][ImgW- 1- dx]; 
			BYTE temp = (nG+HalfArea)/Masksize/remained;
			for(dy=0; dy<Masksize; dy++)
			{
				memset(S_RowAddress[j+dy] + ImgW/Masksize*Masksize, temp, remained);
			}