/// <summary>
/// Суммирование строк в массиве от 0 до h1
/// </summary>
/// <param name="zArray"></param>
/// <returns></returns>
public static ZArrayDescriptor Sum_zArrayY_ALL(ZArrayDescriptor zArray)
{
if (zArray == null)
{
MessageBox.Show(" Sum_zArrayY: zArrayDescriptor == null"); return(null);
}
int w1 = zArray.width;
int h1 = zArray.height;
ZArrayDescriptor res_array = new ZArrayDescriptor(w1, h1);
double[] array_line = new double[w1];
for (int i = 0; i < w1; i++)
{
for (int j = 0; j < h1; j++)
{
array_line[i] += zArray.array[i, j];
}
}
for (int i = 0; i < w1; i++)
{
for (int j = 0; j < h1; j++)
{
res_array.array[i, j] = array_line[i] / h1;
}
}
return(res_array);
}
// Конструктор для заполнения фазы (Амплитуда постоянная)
public ZComplexDescriptor(ZArrayDescriptor descriptorToCopy, double am)
{
if (descriptorToCopy == null)
{
MessageBox.Show("ZComplexDescriptor == NULL"); return;
}
width = descriptorToCopy.width;
height = descriptorToCopy.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++)
{
double a = descriptorToCopy.array[i, j];
a = (a - min) * 2.0 * Math.PI / (max - min);
a = a - Math.PI;
array[i, j] = Complex.FromPolarCoordinates(am, a);
//array[i, j] = new Complex(1.0, descriptorToCopy.array[i, j]);
}
}
}
//------------------------------------------------------------------------------------------------------------------------
//Random rnd = new Random((int)DateTime.Now.Ticks & 0x0000FFFF);
// double fa = (0.5- rnd.NextDouble() )* Math.PI * noise; //rnd.NextDouble() 0-1
public static ZArrayDescriptor Model_FAZA(double n, double noise)
{
int NX = 1024;
int NY = 1024;
ZArrayDescriptor cmpl = new ZArrayDescriptor(NX, NY); // Результирующий фронт
Random rnd = new Random((int)DateTime.Now.Ticks & 0x0000FFFF);
// Random rnd = new Random();
for (int i = 0; i < NX; i++)
{
for (int j = 0; j < NY; j++)
{
double fz1 = (i % n);
fz1 = fz1 * 2 * Math.PI / (n);
double fa = (0.5 - rnd.NextDouble()) * fz1 * noise; //rnd.NextDouble() 0-1
fz1 = fz1 + fa;
//if (fz1 > 2 * Math.PI) fz1 = 2 * Math.PI; //fz1 - 2 * Math.PI;
//if (fz1 < 0) fz1 = 0; // + 2 * Math.PI;
cmpl.array[i, j] = fz1;
}
}
return(cmpl);
}
// Конструктор array из zArray
// если изображение меньше чем Nx, Ny, то оно помещается в левый угол, если изображение больше, то оно обрезается
//
public ZArrayDescriptor(ZArrayDescriptor zArrayPicture, int Nx, int Ny, int k)
{
if (zArrayPicture == null)
{
MessageBox.Show("zArrayPicture = NULL"); return;
}
if (k != 1)
{
MessageBox.Show(" ZArrayDescriptor k != 1"); return;
}
width = Nx;
height = Ny;
array = new double[Nx, Ny];
int Nx_z = zArrayPicture.width;
int Ny_z = zArrayPicture.height;
Nx_z = Math.Min(Nx, Nx_z);
Ny_z = Math.Min(Ny, Ny_z);
for (int i = 0; i < Nx_z; i++)
{
for (int j = 0; j < Ny_z; j++)
{
array[i, j] = zArrayPicture.array[i, j];
}
}
}
public static ZArrayDescriptor Model_FAZA_SUBN(ZArrayDescriptor z2, ZArrayDescriptor z3, double noise)
{
int NX = z2.width;
int NY = z2.height;
double n0 = -Math.PI * noise / 3;
double n1 = 2 * Math.PI + Math.PI * noise / 3;
ZArrayDescriptor cmpl = new ZArrayDescriptor(NX, NY); // Результирующий фронт
for (int i = 0; i < NX; i++)
{
for (int j = 0; j < NY; j++)
{
double fz1 = (z2.array[i, j] - z3.array[i, j]);
if (fz1 < n0)
{
fz1 = fz1 + 2 * Math.PI;
}
if (fz1 > n1)
{
fz1 = fz1 - n1;
}
cmpl.array[i, j] = fz1;
}
}
return(cmpl);
}
public static ZArrayDescriptor Model_FAZA_SUBA(ZArrayDescriptor z2, ZArrayDescriptor z3)
{
int NX = z2.width;
int NY = z2.height;
ZArrayDescriptor cmpl = new ZArrayDescriptor(NX, NY); // Результирующий фронт
for (int i = 0; i < NX; i++)
{
for (int j = 0; j < NY; j++)
{
double fz1 = Math.Abs((z2.array[i, j] - z3.array[i, j]));
//if (fz1 < 0) fz1 = fz1 + 180;
cmpl.array[i, j] = fz1;
}
}
double[,] a = new double[8, 8];
a = Model_VZ(8);
for (int i = 0; i < 8; i++)
{
MessageBox.Show(" " + a[i, 0] + " " + a[i, 1] + " " + a[i, 2] + " " + a[i, 3] + " " + a[i, 4] + " " + a[i, 5] + " " + a[i, 6] + " " + a[i, 7]);
}
return(cmpl);
}
//---------------------------------------------------------------------------------------------------------------WB
public static ZArrayDescriptor WB(double fz, double n_polos)
{
int NX = 1024;
int NY = 1024;
ZArrayDescriptor cmpl = new ZArrayDescriptor(NX, NY); // Результирующий фронт
double a = 255;
double kx = 2.0 * Math.PI / NX;
// a = (a - min) * 2.0 * Math.PI / (max - min); -pi +pi
for (int i = 0; i < NX; i++)
{
for (int j = 0; j < NY; j++)
{
double fz1 = Math.Sin(kx * i * n_polos + fz);
if (fz1 < 0)
{
a = 0;
}
else
{
a = 255;
}
cmpl.array[i, j] = a;
}
}
return(cmpl);
}
public static void Vizual_PictureAsRaw(ZArrayDescriptor zArrayDescriptor, PictureBox pictureBox)
{
int width = zArrayDescriptor.width;
int height = zArrayDescriptor.height;
if (width == 0 || height == 0)
{
MessageBox.Show("Vizual_Picture: width == 0 || height == 0"); return;
}
Bitmap bmp2 = new Bitmap(width, height);
BitmapData data2 = ImageProcessor.getBitmapData(bmp2);
for (int j = 0; j < width; j++)
{
for (int i = 0; i < height; i++)
{
int c;
c = Convert.ToInt32(zArrayDescriptor.array[j, i]);
Color c1 = Color.FromArgb(c, c, c);
ImageProcessor.setPixel(data2, j, i, c1);
}
}
pictureBox.Image = bmp2;
bmp2.UnlockBits(data2);
}
// 4 синусоиды с фазовым сдвигом
public static ZArrayDescriptor Sinus(double fz, double a, double n_polos, double gamma, int kr, int Nx, int Ny, double noise)
{
int kr1 = kr + 1;
int NX = Nx * kr1;
int NY = Ny * kr1;
//MessageBox.Show(" nx " + NX + " a " + a + " noise " + noise);
ZArrayDescriptor cmpl = new ZArrayDescriptor(NX, NY); // Результирующий фронт
Random rnd = new Random((int)DateTime.Now.Ticks & 0x0000FFFF);
// Random rnd = new Random();
double kx = 2.0 * Math.PI / NX;
// a = (a - min) * 2.0 * Math.PI / (max - min); -pi +pi
for (int i = 0; i < NX; i += kr1)
{
for (int j = 0; j < NY; j++)
{
double fz1 = a * (Math.Sin(kx * i * n_polos - fz) + 1) / 2;
//double fz1 = a * (Math.Sin(2.0 * Math.PI * i / n_polos + fz) + 1) / 2;
double fa = (0.5 - rnd.NextDouble()) * a * noise; //rnd.NextDouble() 0-1
fz1 = fz1 + fa;
cmpl.array[i, j] = Math.Pow(fz1, gamma);
}
}
return(cmpl);
}
public void Stolb_a0(int i, int N2x, ZArrayDescriptor data2, int Ny, int NyP)
{
int N2 = 0;
if (Ny > NyP)
{
N2 = (Ny - NyP) / 2;
for (int j = 0; j < N2; j++)
{
array[i, j] = 0; // 127;
}
for (int j = N2; j < Ny - N2; j++)
{
array[i, j] = data2.array[i - N2x, j - N2];
}
for (int j = Ny - N2; j < Ny; j++)
{
array[i, j] = 0; // 127;
}
}
else
{
for (int j = 0; j < Ny; j++)
{
array[i, j] = data2.array[i - N2x, j];
}
}
}
//
// Устранение фазовой неоднозначности
//
public static ZArrayDescriptor Shift_Picture(ZArrayDescriptor zArrayPicture, double o_gr, double o_mn)
{
if (zArrayPicture == null)
{
MessageBox.Show("SumClass ZArrayDescriptor array == null"); return(null);
}
int width = zArrayPicture.width;
int height = zArrayPicture.height;
ZArrayDescriptor z_array = new ZArrayDescriptor(width, height);
double max = getMax(zArrayPicture);
//double min = getMin(zArrayPicture);
double min = o_mn;
for (int j = 0; j < width; j++)
{
for (int i = 0; i < height; i++)
{
double c = zArrayPicture.array[i, j];
if (c > o_gr)
{
c = min - (max - c);
}
z_array.array[i, j] = c;
}
}
return(z_array);
}
public static ZArrayDescriptor Range_Array1(ZArrayDescriptor zArrayPicture, double fmax)
{
if (zArrayPicture == null)
{
MessageBox.Show("SumClass ZArrayPicture == null"); return(null);
}
int width = zArrayPicture.width;
int height = zArrayPicture.height;
ZArrayDescriptor rezult = new ZArrayDescriptor(width, height);
double min = getMin(zArrayPicture);
double max = getMax(zArrayPicture);
if (max == min)
{
return(rezult);
}
double max1 = max - min;
//MessageBox.Show("fmax1 = " + fmax);
for (int i = 0; i < width; i++)
{
for (int j = 0; j < height; j++)
{
double fc = zArrayPicture.array[i, j];
rezult.array[i, j] = fmax * (fc - min) / max1;
}
}
return(rezult);
}
//-------------------------------------------------------------------------------------------------------------------------
public static ZArrayDescriptor ATAN_am(ZArrayDescriptor[] zArrayPicture, double[] fzz)
{
// 8, 9, 10, 11 -> Complex[1]
int w1 = zArrayPicture[0].width;
int h1 = zArrayPicture[0].height;
ZArrayDescriptor faza = new ZArrayDescriptor(w1, h1);
int n_sdv = 4; // Число фазовых сдвигов
double[] i_sdv = new double[4];
double[] v_sdv = new double[4]; // Вектор коэффициентов
double[] k_sin = new double[4];
double[] k_cos = new double[4];
for (int i = 0; i < n_sdv; i++)
{
k_sin[i] = Math.Sin(fzz[i]);
k_cos[i] = Math.Cos(fzz[i]);
}
for (int i = 0; i < w1; i++)
{
for (int j = 0; j < h1; j++)
{
i_sdv[0] = zArrayPicture[0].array[i, j];
i_sdv[1] = zArrayPicture[1].array[i, j];
i_sdv[2] = zArrayPicture[2].array[i, j];
i_sdv[3] = zArrayPicture[3].array[i, j];
// ------ Формула расшифровки
v_sdv[0] = i_sdv[1] - i_sdv[n_sdv - 1];
v_sdv[n_sdv - 1] = i_sdv[0] - i_sdv[n_sdv - 2];
for (int ii = 1; ii < n_sdv - 1; ii++)
{
v_sdv[ii] = i_sdv[ii + 1] - i_sdv[ii - 1];
}
double fz1 = 0;
double fz2 = 0;
for (int ii = 0; ii < n_sdv; ii++)
{
fz1 += v_sdv[ii] * k_sin[ii];
fz2 += v_sdv[ii] * k_cos[ii];
}
faza.array[i, j] = Math.Atan2(fz1, fz2);
}
}
return(faza);
}
// Конструктор для случайного заполнения фазы (RANDOM) (Амплитуда из файла, k=1)
public ZComplexDescriptor(ZArrayDescriptor descriptorToCopy, ZArrayDescriptor amp, int k)
{
if (amp == null)
{
MessageBox.Show("Ampl == NULL"); return;
}
if (descriptorToCopy == null)
{
MessageBox.Show("ZArrayDescriptor == NULL"); return;
}
if (k != 1)
{
MessageBox.Show(" k!=1 "); return;
}
width = amp.width;
height = amp.height;
array = new Complex[width, height];
double max = SumClass.getMax(descriptorToCopy);
double min = SumClass.getMin(descriptorToCopy);
int NX = descriptorToCopy.width;
int NY = descriptorToCopy.height;
if (NX > width)
{
NX = width;
}
if (NY > height)
{
NY = height;
}
//MessageBox.Show("width =" + Convert.ToString(width) + "height =" + Convert.ToString(height));
Random rnd = new Random();
for (int i = 0; i < NX; i++)
{
for (int j = 0; j < NY; j++)
{
double am = amp.array[i, j];
double fz = descriptorToCopy.array[i, j];
double fa = rnd.NextDouble() * 2.0 * Math.PI - Math.PI;
fz = fz + fa;
//if (fz > Math.PI) fz = fz - Math.PI;
//if (fz < -Math.PI) fz = fz + Math.PI;
if (am <= 0)
{
fz = 0; // По шаблону
}
//if (a > 0) a = rnd.NextDouble() * Math.PI ; else a = 0;
array[i, j] = Complex.FromPolarCoordinates(am, fz);
}
}
}
public void SetImage(ZArrayDescriptor zArray)
{
this.imageBox.Invoke
(
(MethodInvoker) delegate
{
Vizual.Vizual_Picture(zArray, this.imageBox);
this.imageBox.Refresh();
}
);
}
//--------------------------------------------------------------------------------------------------------------------
// Конструктор array из zArray
// если изображение меньше чем Nx, Ny, то оно помещается в центре, а по краям 0
// если изображение больше, то оно обрезается
public ZArrayDescriptor(ZArrayDescriptor zArrayPicture, int Nx, int Ny)
{
if (zArrayPicture == null)
{
MessageBox.Show("zArrayPicture = NULL"); return;
}
width = Nx;
height = Ny;
array = new double[Nx, Ny];
int NxP = zArrayPicture.width;
int NyP = zArrayPicture.height;
// MessageBox.Show("NX= " + Convert.ToString(Nx) + "Ny= " + Convert.ToString(Nx));
// MessageBox.Show("NxP= " + Convert.ToString(NxP) + "NyP= " + Convert.ToString(NyP));
int N2 = 0;
if (Nx > NxP)
{
N2 = (Nx - NxP) / 2;
for (int i = 0; i < N2; i++)
{
for (int j = 0; j < Ny; j++)
{
array[i, j] = 0.0;
}
}
for (int i = N2; i < Nx - N2; i++)
{
Stolb_a(i, N2, zArrayPicture, Ny, NyP);
}
for (int i = Nx - N2; i < Nx; i++)
{
for (int j = 0; j < Ny; j++)
{
array[i, j] = 0.0;
}
}
}
else
{
for (int i = 0; i < Nx; i++)
{
Stolb_a(i, 0, zArrayPicture, Ny, NyP);
}
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Конструктор для заполения реальной части и мнимой части
// 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 ZComplexDescriptor(ZArrayDescriptor phase, ZArrayDescriptor amp)
{
if (amp == null)
{
MessageBox.Show("Ampl (ZComplexDescriptor) == NULL"); return;
}
if (phase == null)
{
MessageBox.Show("Phase (ZComplexDescriptor) == NULL"); return;
}
width = amp.width;
height = amp.height;
int NX = phase.width;
int NY = phase.height;
if (NX > width)
{
NX = width;
}
if (NY > height)
{
NY = height;
}
if (NX < width)
{
width = NX;
}
if (NY < height)
{
height = NY;
}
array = new Complex[width, height];
//double max = SumClass.getMax(phase);
//double min = SumClass.getMin(phase);
//MessageBox.Show("width =" + Convert.ToString(width) + "height =" + Convert.ToString(height));
for (int i = 0; i < NX; i++)
{
for (int j = 0; j < NY; j++)
{
array[i, j] = Complex.FromPolarCoordinates(amp.array[i, j], phase.array[i, j]);
}
}
}
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 ZArrayDescriptor Intensity2(double nu, int Nx, int Ny, int dx, double gamma) // От черного к белому
{
int Nx1 = Nx;
Nx = Nx + dx * 2;
ZArrayDescriptor cmpl = new ZArrayDescriptor(Nx, Ny);
int k = (int)(Nx1 / (nu + 1));
double[] ag = new double[Nx1];
double max = double.MinValue;
double min = double.MaxValue;
for (int i = 0; i < Nx1; i++)
{
double a = Math.Pow(255 - i / k, gamma);
ag[i] = a;
if (a > max)
{
max = a;
}
if (a < min)
{
min = a;
}
}
for (int i = 0; i < Nx1; i++)
{
ag[i] = (ag[i] - min) * nu / (max - min);
}
for (int j = 0; j < Ny; j++)
{
for (int i = 0; i < Nx1; i++)
{
cmpl.array[i + dx, j] = ag[i];
}
}
cmpl = Intens(0, 255, dx, cmpl); // Белая и черная полоса по краям
return(cmpl);
}
// Сложение с минимальным
public static ZArrayDescriptor Model_FAZA_SUM(ZArrayDescriptor z1, ZArrayDescriptor z2, double n1)
{
int NX = z2.width;
int NY = z2.height;
ZArrayDescriptor cmpl = new ZArrayDescriptor(NX, NY); // Результирующий фронт
for (int i = 0; i < NX; i++)
{
for (int j = 0; j < NY; j++)
{
cmpl.array[i, j] = z1.array[i, j] + z2.array[i, j] * n1;
}
}
return(cmpl);
}
//-----------------------------------------------------------------------------------------------------------------------------------
public static ZArrayDescriptor DitheringVZ(double fz, double n_polos, int N_kvant, int N_urovn) // Матрица возбуждения
{
int NX = 1024;
int NY = 1024;
ZArrayDescriptor cmpl = new ZArrayDescriptor(NX, NY); // Результирующий фронт
double kx = 2.0 * Math.PI / NX;
for (int i = 0; i < NX; i++) // Приведение к числу уровней
{
for (int j = 0; j < NY; j++)
{
double fz1 = (Math.Sin(kx * i * n_polos + fz) + 1) / 2;
int ifz1 = (int)(fz1 * N_urovn) + 1;
if (ifz1 > N_urovn)
{
ifz1 = N_urovn; // Чтобы избежать sin=1
}
cmpl.array[i, j] = ifz1 - 1;
}
}
int n = 8; // N_urovn / 32;
double[,] D = new double[8, 8];
D = Model_VZ(8);
for (int x = 0; x < NX; x++) // Приведение к числу уровней
{
for (int y = 0; y < NY; y++)
{
int i = (x % n);
int j = (y % n);
if (cmpl.array[x, y] / 4 < D[i, j])
{
cmpl.array[x, y] = 0;
}
else
{
cmpl.array[x, y] = 255;
}
}
}
return(cmpl);
}
public static ZArrayDescriptor Sub_zArray(ZArrayDescriptor a, ZArrayDescriptor b)
{
int w1 = a.width;
int h1 = a.height;
ZArrayDescriptor res_array = new ZArrayDescriptor(w1, h1);
//double min = getMin(amp);
for (int i = 0; i < w1; i++) // По строкам
{
for (int j = 0; j < h1; j++)
{
res_array.array[i, j] = a.array[i, j] - b.array[i, j];
}
}
return(res_array);
}
// Конструктор для заполнения реальной части и мнимой части = 0
public ZComplexDescriptor(ZArrayDescriptor descriptorToCopy)
{
if (descriptorToCopy == null)
{
MessageBox.Show("ZArrayDescriptor == NULL"); return;
}
width = descriptorToCopy.width;
height = descriptorToCopy.height;
array = new Complex[width, height];
for (int i = 0; i < width; i++)
{
for (int j = 0; j < height; j++)
{
array[i, j] = new Complex(descriptorToCopy.array[i, j], 0.0);
}
}
}
/// <summary>
/// Суммирование строк в массиве от Y1 до Y2
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns></returns>
public static ZArrayDescriptor Sum_zArrayY(ZArrayDescriptor zArray, int y1, int y2)
{
if (zArray == null)
{
MessageBox.Show(" Sum_zArrayY: zArrayDescriptor == null"); return(null);
}
int w1 = zArray.width;
int h1 = zArray.height;
if (y2 < y1)
{
MessageBox.Show(" y2 < y1"); return(null);
}
if (y2 > h1)
{
MessageBox.Show(" y2 > h1"); return(null);
}
if (y1 < 0)
{
MessageBox.Show(" y1 < 0"); return(null);
}
ZArrayDescriptor res_array = new ZArrayDescriptor(w1, h1);
double[] array_line = new double[w1];
for (int i = 0; i < w1; i++)
{
for (int j = y1; j < y2; j++)
{
array_line[i] += zArray.array[i, j];
}
}
for (int i = 0; i < w1; i++)
{
for (int j = 0; j < h1; j++)
{
res_array.array[i, j] = array_line[i] / (y2 - y1);
}
}
return(res_array);
}
public static ZArrayDescriptor Inversia(ZArrayDescriptor amp)
{
int w1 = amp.width;
int h1 = amp.height;
ZArrayDescriptor res_array = new ZArrayDescriptor(w1, h1);
double max = getMax(amp);
//double min = getMin(amp);
for (int i = 0; i < w1; i++) // По строкам
{
for (int j = 0; j < h1; j++)
{
res_array.array[i, j] = (max - amp.array[i, j]);
}
}
return(res_array);
}
public ZArrayDescriptor(ZArrayDescriptor descriptorToCopy)
{
if (descriptorToCopy == null)
{
MessageBox.Show("zArrayPicture = NULL"); return;
}
array = new double[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];
}
}
}
private static void Fill_Circle_Outside(ZArrayDescriptor zArrayDescriptor, BitmapData data2, int width, int height, Color c2) // Заполнение цветом
{
Color c;
Color red = c2;
Color green = Color.FromArgb(0, 0, 0);
for (int j = 0; j < width; j++)
{
for (int i = 0; i < height; i++)
{
c = ImageProcessor.getPixel(j, i, data2);
//if (c != red) ImageProcessor.setPixel(data2, j, i, green); else break;
if (c != red)
{
zArrayDescriptor.array[j, i] = 0;
}
else
{
break;
}
}
}
for (int j = 0; j < width; j++)
{
for (int i = height - 1; i >= 0; i--)
{
c = ImageProcessor.getPixel(j, i, data2);
if (c == green)
{
continue;
}
// if (c != red ) ImageProcessor.setPixel(data2, j, i, green); else break;
if (c != red)
{
zArrayDescriptor.array[j, i] = 0;
}
else
{
break;
}
}
}
}
public static double getAverage(ZArrayDescriptor 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];
}
}
a = a / (newDescriptor.width * newDescriptor.height);
return(a);
}
// Вычитание двух профилей
public static ZArrayDescriptor Model_FAZA_T(ZArrayDescriptor z1, ZArrayDescriptor z2, double n123, double n23)
{
int NX = z2.width;
int NY = z2.height;
ZArrayDescriptor cmpl = new ZArrayDescriptor(NX, NY); // Результирующий фронт
//double n123 = n12 * n23 / (Math.Abs(n12 - n23));
for (int i = 0; i < NX; i++)
{
for (int j = 0; j < NY; j++)
{
double rzn = z1.array[i, j] * n123 - z2.array[i, j] * n23;
int k = Convert.ToInt32(rzn / (Math.PI * n23)); //Convert.ToInt32
cmpl.array[i, j] = k * Math.PI * n23;
}
}
return(cmpl);
}