imgfunction.cpp

基于小波的SAR斑点处理

#include "stdafx.h"
#include "Progress.h"
#include "Comput.h"
#include "ImgFunction.h"

#include <math.h>

static int HIGHER[7][7]=
{
	{-1,0,-1,-1,-1,-1,-10000},/*  (  */
	{-10000,1,1,1,1,1,1},/*  )  */
	{-1,1,1,1,-1,-1,1},/*  +  */
	{-1,1,1,1,-1,-1,1},/*  -  */
	{-1,1,1,1,1,1,1}, /*  *  */
	{-1,1,1,1,1,1,1}, /*  /  */
	{-1,-10000,-1,-1,-1,-1,0}  /*  #  */
};

void ChangeExt(LPCTSTR s1,char *s2,char *NewExt)
{
	unsigned int i;
	for(i=0;i<strlen(s1);i++)
	{
		if(*(s1+i)=='.')
			break;
	}
	strncpy(s2,s1,i+1);
	*(s2+i+1)='\0';
	strcat(s2,NewExt);
}

int IsWhite(char c)
{
	if(c==' '||c==9)
		return 1;
	else return 0;
}

int Higher(struct OPTR Optr1,struct OPTR Optr2)
{
	if(Optr1.Type==FUNCTION&&Optr2.Type==FUNCTION)
		return 1;/*Higher*/
	else if(Optr1.Type==FUNCTION&&(Optr2.Type==DELIMITER&&Optr2.Flag==0))
		return -1;
	else if(Optr1.Type==FUNCTION&&(Optr2.Type==DELIMITER&&Optr2.Flag!=0))
		return 1;
	else if(Optr1.Type==DELIMITER&&Optr2.Type==DELIMITER)
		return(HIGHER[Optr1.Flag][Optr2.Flag]);
	else /*if(Optr1.Type==DELIMITER&&Optr2.Type==FUCTION)*/
	{
		if(Optr1.Flag==1)
			return  -10000;
		else
			return -1;
	}
}

float Operate(float Var1,float Var2,int Flag)
{
	switch(Flag)
	{
	case 2://+
		return Var1+Var2;
	case 3:
		return Var1-Var2;
	case 4:
		return Var1*Var2;
	case 5:
		return (float)(Var1/(Var2+0.00001));
	}
	return 0.0;
}

void Operate(float *Res,BYTE *Var1,BYTE *Var2,int Height,int Width,int Flag)
{
	DWORD Order;
	int RPro;
	int Process = 0;
	for(int i=0;i<Height;i++)
	{
		RPro=(int)(100.0 * (i+1) / Height);
		if(RPro>Process)
		{
			for(int j=0;j<RPro-Process;j++)
				UpdateStatusBar();
			Process=RPro;
		}
		for(int j=0;j<Width;j++)
		{
			Order = (DWORD)i*Width+j;
			switch(Flag)
			{
			case 2://+
				Res[Order] = (float)Var1[Order]+(float)Var2[Order];
				break;
			case 3:
				Res[Order] = (float)Var1[Order]-(float)Var2[Order];
				break;
			case 4:
				Res[Order] = (float)Var1[Order]*(float)Var2[Order];
				break;
			case 5:
				Res[Order] = float(Var1[Order]/((float)Var2[Order]+0.00001));
				break;
			}
		}
	}
}

void Operate(float *Res,BYTE *Var1,float Var2,int Height,int Width,int Flag)
{
	DWORD Order;
	int RPro;
	int Process = 0;
	for(int i=0;i<Height;i++)
	{
		RPro=(int)(100.0 * (i+1) / Height);
		if(RPro>Process)
		{
			for(int j=0;j<RPro-Process;j++)
				UpdateStatusBar();
			Process=RPro;
		}
		for(int j=0;j<Width;j++)
		{
			Order = (DWORD)i*Width+j;
			switch(Flag)
			{
			case 2://+
				Res[Order] = (float)Var1[Order]+Var2;
				break;
			case 3:
				Res[Order] = (float)Var1[Order]-Var2;
				break;
			case 4:
				Res[Order] = (float)Var1[Order]*Var2;
				break;
			case 5:
				Res[Order] = float(Var1[Order]/(Var2+0.00001));
				break;
			}
		}
	}
}

void Operate(float *Res,BYTE *Var1,float *Var2,int Height,int Width,int Flag)
{
	DWORD Order;
	int RPro;
	int Process = 0;
	for(int i=0;i<Height;i++)
	{
		RPro=(int)(100.0 * (i+1) / Height);
		if(RPro>Process)
		{
			for(int j=0;j<RPro-Process;j++)
				UpdateStatusBar();
			Process=RPro;
		}
		for(int j=0;j<Width;j++)
		{
			Order = (DWORD)i*Width+j;
			switch(Flag)
			{
			case 2://+
				Res[Order] = (float)Var1[Order]+Var2[Order];
				break;
			case 3:
				Res[Order] = (float)Var1[Order]-Var2[Order];
				break;
			case 4:
				Res[Order] = (float)Var1[Order]*Var2[Order];
				break;
			case 5:
				Res[Order] = float(Var1[Order]/(Var2[Order]+0.00001));
				break;
			}
		}
	}
}

void Operate(float *Res,float Var1,BYTE *Var2,int Height,int Width,int Flag)
{
	DWORD Order;
	int RPro;
	int Process = 0;
	for(int i=0;i<Height;i++)
	{
		RPro=(int)(100.0 * (i+1) / Height);
		if(RPro>Process)
		{
			for(int j=0;j<RPro-Process;j++)
				UpdateStatusBar();
			Process=RPro;
		}
		for(int j=0;j<Width;j++)
		{
			Order = (DWORD)i*Width+j;
			switch(Flag)
			{
			case 2://+
				Res[Order] = Var1+(float)Var2[Order];
				break;
			case 3:
				Res[Order] = Var1-(float)Var2[Order];
				break;
			case 4:
				Res[Order] = Var1*(float)Var2[Order];
				break;
			case 5:
				Res[Order] = float(Var1/((float)Var2[Order]+0.00001));
				break;
			}
		}
	}
}

void Operate(float *Res,float Var1,float *Var2,int Height,int Width,int Flag)
{
	DWORD Order;
	int RPro;
	int Process = 0;
	for(int i=0;i<Height;i++)
	{
		RPro=(int)(100.0 * (i+1) / Height);
		if(RPro>Process)
		{
			for(int j=0;j<RPro-Process;j++)
				UpdateStatusBar();
			Process=RPro;
		}
		for(int j=0;j<Width;j++)
		{
			Order = (DWORD)i*Width+j;
			switch(Flag)
			{
			case 2://+
				Res[Order] = Var1+Var2[Order];
				break;
			case 3:
				Res[Order] = Var1-Var2[Order];
				break;
			case 4:
				Res[Order] = Var1*Var2[Order];
				break;
			case 5:
				Res[Order] = float(Var1/(Var2[Order]+0.00001));
				break;
			}
		}
	}
}

void Operate(float *Res,float *Var1,float *Var2,int Height,int Width,int Flag)
{
	DWORD Order;
	int RPro;
	int Process = 0;
	for(int i=0;i<Height;i++)
	{
		RPro=(int)(100.0 * (i+1) / Height);
		if(RPro>Process)
		{
			for(int j=0;j<RPro-Process;j++)
				UpdateStatusBar();
			Process=RPro;
		}
		for(int j=0;j<Width;j++)
		{
			Order = (DWORD)i*Width+j;
			switch(Flag)
			{
			case 2://+
				Res[Order] = Var1[Order]+Var2[Order];
				break;
			case 3:
				Res[Order] = Var1[Order]-Var2[Order];
				break;
			case 4:
				Res[Order] = Var1[Order]*Var2[Order];
				break;
			case 5:
				Res[Order] = float(Var1[Order]/(Var2[Order]+0.00001));
				break;
			}
		}
	}
}

void Operate(float *Res,float *Var1,float Var2,int Height,int Width,int Flag)
{
	DWORD Order;
	int RPro;
	int Process = 0;
	for(int i=0;i<Height;i++)
	{
		RPro=(int)(100.0 * (i+1) / Height);
		if(RPro>Process)
		{
			for(int j=0;j<RPro-Process;j++)
				UpdateStatusBar();
			Process=RPro;
		}
		for(int j=0;j<Width;j++)
		{
			Order = (DWORD)i*Width+j;
			switch(Flag)
			{
			case 2://+
				Res[Order] = Var1[Order]+Var2;
				break;
			case 3:
				Res[Order] = Var1[Order]-Var2;
				break;
			case 4:
				Res[Order] = Var1[Order]*Var2;
				break;
			case 5:
				Res[Order] = float(Var1[Order]/(Var2+0.00001));
				break;
			}
		}
	}
}

void Operate(float *Res,float *Var1,BYTE *Var2,int Height,int Width,int Flag)
{
	DWORD Order;
	int RPro;
	int Process = 0;
	for(int i=0;i<Height;i++)
	{
		RPro=(int)(100.0 * (i+1) / Height);
		if(RPro>Process)
		{
			for(int j=0;j<RPro-Process;j++)
				UpdateStatusBar();
			Process=RPro;
		}
		for(int j=0;j<Width;j++)
		{
			Order = (DWORD)i*Width+j;
			switch(Flag)
			{
			case 2://+
				Res[Order] = Var1[Order]+(float)Var2[Order];
				break;
			case 3:
				Res[Order] = Var1[Order]-(float)Var2[Order];
				break;
			case 4:
				Res[Order] = Var1[Order]*(float)Var2[Order];
				break;
			case 5:
				Res[Order] = float(Var1[Order]/((float)Var2[Order]+0.00001));
				break;
			}
		}
	}
}

float Fuction(float Var,int Flag)
{
	switch(Flag)
	{
	case 0:
		return (float)sin(Var);
	case 1:
		return (float)cos(Var);
	case 2:
		return (float)log(Var>0?Var:0.00001);
	case 3:
		return (float)sqrt(Var>0?Var:0.0);
	case 4:
		{
		double Value = exp((double)Var);
		if(Value>MAXFLOAT)
			return (float)MAXFLOAT;
		else
			return (float)Value;
		}
	case 5:
		return (float)sign(Var);
	case 6:
		return (float)fabs(Var);
	case 7:
		return (float)((int)(Var));
	}
	return 0.0;
}

void Fuction(float *Res,BYTE *Var,int Height,int Width,int Flag)
{
	DWORD Order;
	int RPro;
	int Process = 0;
	double Value;
	for(int i=0;i<Height;i++)
	{
		RPro=(int)(100.0 * (i+1) / Height);
		if(RPro>Process)
		{
			for(int j=0;j<RPro-Process;j++)
				UpdateStatusBar();
			Process=RPro;
		}
		for(int j=0;j<Width;j++)
		{
			Order = (DWORD)i*Width+j;
			switch(Flag)
			{
			case 0:
				Res[Order] = (float)sin((float)Var[Order]);
				break;
			case 1:
				Res[Order] = (float)cos((float)Var[Order]);
				break;
			case 2:
				Res[Order] = (float)log((float)Var[Order]>0?Var[Order]:0.00001);
				break;
			case 3:
				Res[Order] = (float)sqrt((float)Var[Order]);
				break;
			case 4:
			{
				Value = exp((double)Var[Order]);
				if(Value>MAXFLOAT)
					Res[Order] = (float)MAXFLOAT;
				else
				Res[Order] = (float)Value;
				break;
			}	
			case 5:
				Res[Order] = (float)sign((float)Var[Order]);
				break;
			case 6:
				Res[Order] = (float)fabs((float)Var[Order]);
				break;
			case 7:
				Res[Order] = (int)((float)Var[Order]);
				break;
			}
		}
	}
}

void Fuction(float *Res,float *Var,int Height,int Width,int Flag)
{
	DWORD Order;
	int RPro;
	int Process = 0;
	double Value;
	for(int i=0;i<Height;i++)
	{
		RPro=(int)(100.0 * (i+1) / Height);
		if(RPro>Process)
		{
			for(int j=0;j<RPro-Process;j++)
				UpdateStatusBar();
			Process=RPro;
		}
		for(int j=0;j<Width;j++)
		{
			Order = (DWORD)i*Width+j;
			switch(Flag)
			{
			case 0:
				Res[Order] = (float)sin(Var[Order]);
				break;
			case 1:
				Res[Order] = (float)cos(Var[Order]);
				break;
			case 2:
				Res[Order] = (float)log(Var[Order]>0?Var[Order]:0.00001);
				break;
			case 3:
				Res[Order] = (float)sqrt(Var[Order]>0?Var[Order]:0.0);
				break;
			case 4:
			{
				Value = exp((double)Var[Order]);
				if(Value>MAXFLOAT)
					Res[Order] = (float)MAXFLOAT;
				else
					Res[Order] = (float)Value;
				break;
			}
			case 5:
				Res[Order] = (float)sign(Var[Order]);
				break;
			case 6:
				Res[Order] = (float)fabs(Var[Order]);
				break;
			case 7:
				Res[Order] = (int)(Var[Order]);
				break;
			}
		}
	}
}

void GetIHS(BYTE *IHS,BYTE Red,BYTE Green,BYTE Blue)
{
	int Intens = (int)Red+(int)Green+(int)Blue;
	IHS[0] = Intens/3;
	if(Blue<=Green&&Blue<=Red)
	{
		if(Blue==Red&&Blue==Green)
		{
			IHS[1] = 0;
			IHS[2] = 0;
		}
		else
		{
			IHS[1] = (float)(Green-Blue)/((float)Intens-(float)Blue*3)/3*255;
			IHS[2] = ((float)Intens-(float)Blue*3)/Intens*255;
		}
	}
	else if(Red<=Blue&&Red<=Green)
	{
		if(Red==Blue&&Red==Green)
		{
			IHS[1] = 0;
			IHS[2] = 0;
		}
		else
		{
			IHS[1] = ((float)Green+(float)2*Blue-3*(float)Red)/
				((float)Intens-(float)Red*3)/3*255;
			IHS[2] = ((float)Intens-(float)Red*3)/Intens*255;
		}
	}
	else if(Green<=Blue&&Green<=Red)
	{
		if(Green==Red&&Green==Blue)
		{
			IHS[1] = 0;
			IHS[2] = 0;
		}
		else
		{
			IHS[1] = ((float)3*Red+(float)2*Blue-5*(float)Green)/
				((float)Intens-(float)Green*3)/3*255;
			IHS[2] = ((float)Intens-(float)Green*3)/Intens*255;
		}
	}
}

void GetRGB(BYTE *RGB,BYTE Intensity,BYTE Hue,BYTE Saturation)
{
	float I;
	float H;
	float S;
	I = Intensity*3;
	H = (float)Hue/255*3;
	S = (float)Saturation/255;
	if(H<1&&H>=0)
	{
		RGB[0] = I/3*(1+2*S-3*S*H);
		RGB[1] = I/3*(1-S+3*S*H);
		RGB[2] = I/3*(1-S);
	}
	else if(H<2&&H>=1)
	{
		RGB[0] = I/3*(1-S);
		RGB[1] = I/3*(1+5*S-3*S*H);
		RGB[2] = I/3*(1-4*S+3*S*H);
	}
	else
	{
		RGB[0] = I/3*(1-7*S+3*S*H);
		RGB[1] = I/3*(1-S);
		RGB[2] = I/3*(1+8*S-3*S*H);
	}
}

BOOL IsAllFileExist(CPtrArray &aFileNameArray)
{
	CString *pszTemp;
	CFileStatus rStatus;
	for(int i=0;i<aFileNameArray.GetSize();i++)
	{
		pszTemp = (CString *)(aFileNameArray[i]);
		if(!CFile::GetStatus(*pszTemp,rStatus))
		{
			return FALSE;
		}
	}
	return TRUE;
}

void myline(int x1,int y1,int x2,int y2,POINT *lpPoint)
{
	ASSERT(lpPoint!=NULL);
	int delta_x,delta_y;
	int inc_x,inc_y;
	int dist;
	int t;
	int xerr=0,yerr=0;
	delta_x=x2-x1;
	delta_y=y2-y1;
	if(delta_x>0)
		inc_x=1;
	else if(delta_x==0)
		inc_x=0;
	else 
		inc_x=-1;
	if(delta_y>0)
		inc_y=1;
	else if(delta_y==0)
		inc_y=0;
	else inc_y=-1;
		delta_x=abs(delta_x);
	delta_y=abs(delta_y);
	if(delta_x>delta_y)
		dist=delta_x;
	else
		dist=delta_y;
	for(t=0;t<=dist;t++)
	{
		lpPoint[t].x = x1;
		lpPoint[t].y = y1;
		xerr+=delta_x;
		yerr+=delta_y;
		if(xerr>=dist)
		{
			xerr-=dist;
			x1+=inc_x;
		}
		if(yerr>=dist)
		{
			yerr-=dist;
			y1+=inc_y;
		}
	}
}