public static ZComplexDescriptor ATAN_OLD4(ZArrayDescriptor[] zArrayPicture, double[] fzz)
{
// 8, 9, 10, 11 -> Complex[1]
int w1 = zArrayPicture[8].width;
int h1 = zArrayPicture[8].height;
ZComplexDescriptor faza = new ZComplexDescriptor(w1, h1);
for (int i = 0; i < w1; i++)
{
for (int j = 0; j < h1; j++)
{
double i1 = zArrayPicture[8].array[i, j]; // 0
double i2 = zArrayPicture[9].array[i, j]; // 90
double i3 = zArrayPicture[10].array[i, j]; // 180
double i4 = zArrayPicture[11].array[i, j]; // 270
// ------ Формула расшифровки
faza.array[i, j] = new Complex(i1 - i2, i2 - i4);
}
}
return(faza);
}
//----------------------------------------------------------------------------------------------
// Циклический сдвиг Смещение изображения в центр
//----------------------------------------------------------------------------------------------
public static ZComplexDescriptor Invers(ZComplexDescriptor zarray)
{
int nx = zarray.width;
int ny = zarray.height;
if (nx != ny)
{
MessageBox.Show("Invers nx != ny");
}
Complex[] Array = new Complex[nx];
Complex[] Array1 = new Complex[nx];
ZComplexDescriptor resultArray = new ZComplexDescriptor(nx, ny);
int n2 = nx / 2;
for (int j = 0; j < ny; j++)
{
for (int i = 0; i < nx; i++)
{
Array[i] = zarray.array[i, j];
}
for (int i = 0; i < n2; i++)
{
Array1[i] = Array[i + n2]; Array1[i + n2] = Array[i];
}
for (int i = 0; i < nx; i++)
{
resultArray.array[i, j] = Array1[i];
}
}
for (int i = 0; i < nx; i++)
{
for (int j = 0; j < ny; j++)
{
Array[j] = resultArray.array[i, j];
}
for (int j = 0; j < n2; j++)
{
Array1[j] = Array[j + n2]; Array1[j + n2] = Array[j];
}
for (int j = 0; j < ny; j++)
{
resultArray.array[i, j] = Array1[j];
}
}
return(resultArray);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Конструктор для заполения реальной части и мнимой части
// k=0 Re
// k=1 Im
// k=2 re im=0
// value.Real, value.Imaginary
public ZComplexDescriptor(ZArrayDescriptor descriptorToCopy, ZComplexDescriptor a, int k)
{
if (descriptorToCopy == null)
{
MessageBox.Show("ZArrayDescriptor == NULL"); return;
}
if (a == null)
{
MessageBox.Show("ZComplexDescriptor == NULL"); return;
}
width = a.width;
height = a.height;
int w1 = descriptorToCopy.width;
int h1 = descriptorToCopy.height;
MessageBox.Show("k= " + k + "width= " + width + "height = " + height + "w1 = " + w1 + "h1 = " + h1);
if (w1 > width || h1 > height)
{
MessageBox.Show("ZComplexDescriptor.cs ZArrayDescriptor > ZComplexDescriptor"); return;
}
int x1 = (width - w1) / 2;
int y1 = (height - h1) / 2;
array = new Complex[width, height];
//MessageBox.Show("width =" + Convert.ToString(width) + "height =" + Convert.ToString(height));
for (int i1 = 0; i1 < w1; i1++)
{
for (int j1 = 0; j1 < h1; j1++)
{
int i = i1 + x1;
int j = j1 + y1;
//Double c = descriptorToCopy.array[i, j];
if (k == 0)
{
array[i, j] = new Complex(descriptorToCopy.array[i1, j1], a.array[i1, j1].Imaginary);
}
if (k != 0)
{
array[i, j] = new Complex(a.array[i1, j1].Real, descriptorToCopy.array[i1, j1]);
}
}
}
}
public static ZArrayDescriptor Re(ZComplexDescriptor zComplex)
{
int nx = zComplex.width;
int ny = zComplex.height;
ZArrayDescriptor amp1 = new ZArrayDescriptor(nx, ny);
for (int i = 0; i < nx; i++)
{
for (int j = 0; j < ny; j++)
{
amp1.array[i, j] = zComplex.array[i, j].Real;
}
}
return(amp1);
}
//----------------------------------------------------------------------------------------------
// Двухмерное быстрое преобразование Фурье
//----------------------------------------------------------------------------------------------
public static ZComplexDescriptor FourierTransform(ZComplexDescriptor zarray, int powerOfTwo)
{
int nx = zarray.width;
int ny = zarray.height;
Complex[] Array = new Complex[nx];
Complex[] Array1 = new Complex[nx];
ZComplexDescriptor resultArray = new ZComplexDescriptor(nx, ny);
//for (int i = 0; i < nx; i++) Array[i] = new Complex(0.0, 0.0);
//Complex[] Array_exp = new Complex[nx];
//for (int i = 0; i < nx; i++) Array_exp[i] = new Complex(Math.Cos(i * Math.PI ), -Math.Sin(i * Math.PI ));
for (int j = 0; j < ny; j++)
{
//for (int i = 0; i < nx; i++) Array[i] = zarray.array[i, j] * Array_exp[i];
for (int i = 0; i < nx; i++)
{
Array[i] = zarray.array[i, j];
}
Array1 = GetFourierTransform(Array, powerOfTwo);
for (int i = 0; i < nx; i++)
{
resultArray.array[i, j] = Array1[i];
}
}
for (int i = 0; i < nx; i++)
{
//for (int j = 0; j < ny; j++) Array[j] = resultArray.array[i, j]*Array_exp[j];
for (int j = 0; j < ny; j++)
{
Array[j] = resultArray.array[i, j];
}
Array1 = GetFourierTransform(Array, powerOfTwo);
for (int j = 0; j < ny; j++)
{
resultArray.array[i, j] = Array1[j];
}
}
return(resultArray);
}
public ZComplexDescriptor(ZComplexDescriptor descriptorToCopy)
{
if (descriptorToCopy == null)
{
return;
}
array = new Complex[descriptorToCopy.width, descriptorToCopy.height];
width = descriptorToCopy.width;
height = descriptorToCopy.height;
for (int i = 0; i < width; i++)
{
for (int j = 0; j < height; j++)
{
array[i, j] = descriptorToCopy.array[i, j];
}
}
}
public static ZComplexDescriptor Exponenta(double g, int N)
{
ZComplexDescriptor cmpl = new ZComplexDescriptor(N, 256);
double kx = 2 * Math.PI * g / N;
double am = 1;
for (int i = 0; i < N; i++)
{
for (int j = 0; j < 256; j++)
{
double fz = -kx * i;
cmpl.array[i, j] = Complex.FromPolarCoordinates(am, fz);
}
}
return(cmpl);
}
public static double getAverage(ZComplexDescriptor newDescriptor)
{
if (newDescriptor == null)
{
return(0);
}
double a = 0;
for (int i = 0; i < newDescriptor.width; i++)
{
for (int j = 0; j < newDescriptor.height; j++)
{
a = a + newDescriptor.array[i, j].Magnitude;
}
}
a = a / (newDescriptor.width * newDescriptor.height);
return(a);
}
public static ZComplexDescriptor InverseFourierTransform(ZComplexDescriptor zarray, int powerOfTwo)
{
int nx = zarray.width;
int ny = zarray.height;
Complex[] Array = new Complex[nx];
Complex[] Array1 = new Complex[nx];
ZComplexDescriptor resultArray = new ZComplexDescriptor(nx, ny);
for (int j = 0; j < ny; j++)
{
for (int i = 0; i < nx; i++)
{
Array[i] = zarray.array[i, j];
}
Array1 = GetInverseFourierTransform(Array, powerOfTwo);
for (int i = 0; i < nx; i++)
{
resultArray.array[i, j] = Array1[i];
}
}
for (int i = 0; i < nx; i++)
{
for (int j = 0; j < ny; j++)
{
Array[j] = resultArray.array[i, j];
}
Array1 = GetInverseFourierTransform(Array, powerOfTwo);
for (int j = 0; j < ny; j++)
{
resultArray.array[i, j] = Array1[j];
}
}
return(resultArray);
}
// Конструктор для заполнения амплитуды , фаза остается
public ZComplexDescriptor(ZComplexDescriptor zc, ZArrayDescriptor ampl)
{
if (ampl == null)
{
MessageBox.Show("ZComplexDescriptor == NULL"); return;
}
width = zc.width;
height = zc.height;
array = new Complex[width, height];
//double max = SumClass.getMax(descriptorToCopy);
//double min = SumClass.getMin(descriptorToCopy);
//MessageBox.Show("width =" + Convert.ToString(width) + "height =" + Convert.ToString(height));
for (int i = 0; i < width; i++)
{
for (int j = 0; j < height; j++)
{
array[i, j] = Complex.FromPolarCoordinates(ampl.array[i, j], zc.array[i, j].Phase);
}
}
}
public static double getMax(ZComplexDescriptor newDescriptor)
{
if (newDescriptor == null)
{
return(0);
}
double max = double.MinValue;
for (int i = 0; i < newDescriptor.width; i++)
{
for (int j = 0; j < newDescriptor.height; j++)
{
// max = Math.Max(max, newDescriptor.array[i, j]);
double a = newDescriptor.array[i, j].Magnitude;
if (max < a)
{
max = a;
}
}
}
return(max);
}
//----------------------------------------------------------------------------------------------
// Двухмерное быстрое преобразование Френеля
//----------------------------------------------------------------------------------------------
public static ZComplexDescriptor FrenelTransform(ZComplexDescriptor zarray, int powerOfTwo, double lambda, double d, double dx)
{
int nx = zarray.width;
int ny = zarray.height;
if (nx != ny)
{
MessageBox.Show("Frenel nx != ny");
}
Complex[] Array = new Complex[nx];
double[] phase = exp1(lambda, d, nx, dx);
Complex[] Array_с2 = exp2(lambda, d, nx, dx);
ZComplexDescriptor resultArray = new ZComplexDescriptor(nx, ny);
//Array_с1 = exp1(lambda, d, nx, dx);
//Array_с2 = exp2(lambda, d, nx, dx);
for (int j = 0; j < ny; j++)
{
for (int i = 0; i < nx; i++)
{
Array[i] = zarray.array[i, j] * Array_с2[i];
}
Array = GetFourierTransform(Array, powerOfTwo);
for (int i = 0; i < nx; i++)
{
resultArray.array[i, j] = Array[i];
}
}
for (int i = 0; i < nx; i++)
{
for (int j = 0; j < ny; j++)
{
Array[j] = resultArray.array[i, j] * Array_с2[j];
}
Array = GetFourierTransform(Array, powerOfTwo);
for (int j = 0; j < ny; j++)
{
resultArray.array[i, j] = Array[j];
}
}
for (int i = 0; i < nx; i++)
{
for (int j = 0; j < ny; j++)
{
resultArray.array[i, j] = Complex.FromPolarCoordinates(resultArray.array[i, j].Magnitude, resultArray.array[i, j].Phase + phase[j]);
}
}
for (int j = 0; j < ny; j++)
{
for (int i = 0; i < nx; i++)
{
resultArray.array[i, j] = Complex.FromPolarCoordinates(resultArray.array[i, j].Magnitude, resultArray.array[i, j].Phase + phase[i]);
}
}
/*
*
* for (int i = 0; i < nx; i++)
* for (int j = 0; j < ny; j++)
* { resultArray.array[i, j] = new Complex( phase[j], 0); }
*
* for (int j = 0; j < ny; j++)
* for (int i = 0; i < nx; i++)
* { resultArray.array[i, j] = resultArray.array[i, j].Real + phase[i]; }
*/
// for (int i = 0; i < nx; i++) for (int j = 0; j < ny; j++) resultArray.array[i, j] = Array_с1[j];
// for (int j = 0; j < ny; j++) for (int i = 0; i < nx; i++) resultArray.array[i, j] = resultArray.array[i, j] * Array_с1[i];
return(resultArray);
}
