示例#1
0
        public static par Right(ZIntDescriptor a, int j)
        {
            int s    = 0;
            int ind1 = a.ind1;
            int ind2 = a.ind2;
            int b    = j;
            int i1   = 0;
            int cntr = 0;

            for (int i = j; i < ind2; i++, s++)
            {
                b = i; if (a.GetValue(i) >= 0)
                {
                    cntr = 1; i1 = i; break;
                }
            }
            if (cntr != 1)
            {
                for (int i = -ind1 + 1; i < ind2; i++, s++)
                {
                    if (a.GetValue(i) >= 0)
                    {
                        i1 = i; break;
                    }
                }
            }

            par c;

            c.s = s;
            c.i = i1;
            return(c);
        }
示例#2
0
        public static ZIntDescriptor Diag_array(ZIntDescriptor a) // Заполнение -1 ближайшей не равной 0 величиной
        {
            int            ind1 = a.ind1;
            int            ind2 = a.ind2;
            ZIntDescriptor b    = new ZIntDescriptor(ind1, ind2);

            //MessageBox.Show(" ind1 -- " + ind1 + " ind2 -- " + ind2);
            for (int j = -ind1; j <= ind2; j++)
            {
                //a.SetValue(j, -2);
                //MessageBox.Show(" j= " + j + " a.GetValue(j) = " + a.GetValue(j));
                if (a.GetValue(j) < 0)
                {
                    par par1 = Left(a, j);
                    par par2 = Right(a, j);
                    int bmin = a.GetValue(par1.i);              // Индекс левого элемента
                    int bmax = a.GetValue(par2.i);              // Индекс правого элемента
                    //MessageBox.Show(" j= " + j + " min_left= " + par1.s + " min_right= " + par2.s + " il= " + bmin + " ir= " + bmax);
                    if (par1.s < par2.s)
                    {
                        b.SetValue(j, bmin);
                    }
                    else
                    {
                        b.SetValue(j, bmax);
                    }
                }
                else
                {
                    b.SetValue(j, a.GetValue(j));
                }
            }
            return(b);
        }
示例#3
0
        // Таблица увеличивается на множитель точности

        public static ZIntDescriptor  Diag_array_Mngtl(ZIntDescriptor a, int Mngtl)
        {
            if (Mngtl == 1)
            {
                return(a);
            }

            int            n1 = a.ind1 * Mngtl;
            int            n2 = a.ind2 * Mngtl;
            ZIntDescriptor b  = new ZIntDescriptor(n1, n2);
            int            i1 = a.ind1;

            for (int i = -n1; i < 0; i += Mngtl)
            {
                i1 = i / Mngtl;
                //if (i1>a.ind2) MessageBox.Show("i " + i + " i1 " + i1);
                int c = a.GetValue(i1);

                for (int j = 0; j < Mngtl; j++)
                {
                    b.SetValue(i + j, c);
                }
            }

            for (int i = 0; i <= n2 - Mngtl; i += Mngtl)
            {
                i1 = i / Mngtl;
                //if (i1>a.ind2) MessageBox.Show("i " + i + " i1 " + i1);
                int c = a.GetValue(i1);

                for (int j = 0; j < Mngtl; j++)
                {
                    b.SetValue(i + j, c);
                }
            }

            return(b);
        }
示例#4
0
        // ------------------------------------------------------------------------------------------------------------
        // ------------------------     Развертка
        //-------------------------------------------------------------------------------------------------------------
        public static ZArrayDescriptor Unrup_array(ZArrayDescriptor[] zArrayPicture, int k1, int k2, int N1_sin, int N2_sin, int N_diag, int sdvig, int Mngtl)
        {
            if (zArrayPicture[k1] == null)
            {
                MessageBox.Show("Unrup_array ZArrayDescriptor[k1] == NULL"); return(null);
            }
            if (zArrayPicture[k2] == null)
            {
                MessageBox.Show("Unrup_array ZArrayDescriptor[k2] == NULL"); return(null);
            }
            int NX = zArrayPicture[k1].width;
            int NY = zArrayPicture[k1].height;

            ZArrayDescriptor res = new ZArrayDescriptor(NX, NY);

            //MessageBox.Show("N1_sin " + N1_sin + " N2_sin " + N2_sin);

            ZIntDescriptor a = new ZIntDescriptor(N1_sin, N2_sin);                  // класс для считывания с отрицательными индексами

            a = Diag(a, N1_sin, N2_sin, N_diag);                                    // Формирование массива для развертки с -1
            a = Diag_array(a);                                                      // Дополнение -1 до середины отрезка значениями диагонали

            ZIntDescriptor a1 = new ZIntDescriptor(N1_sin * Mngtl, N2_sin * Mngtl); // класс для считывания с отрицательными индексами

            a1 = Diag_array_Mngtl(a, Mngtl);


            //a.SetValue(-N1_sin, 14);
            // double max1 = SumClass.getMax(zArrayPicture[k1]);
            // double min1 = SumClass.getMin(zArrayPicture[k1]); max1 = max1 - min1;
            // double max2 = SumClass.getMax(zArrayPicture[k2]);
            // double min2 = SumClass.getMin(zArrayPicture[k2]); max2 = max2 - min2;
            double max1 = 2 * Math.PI;
            double min1 = -Math.PI;
            double max2 = 2 * Math.PI;
            double min2 = -Math.PI;

            for (int i = 0; i < NX; i++)
            {
                for (int j = 0; j < NY; j++)
                {
                    double b2x = (zArrayPicture[k1].array[i, j] - min1) * (N2_sin - 1) * Mngtl / max1;
                    int    b2  = (int)b2x;
                    b2 = sdv(b2, sdvig, N2_sin * Mngtl);
                    double b1x = (zArrayPicture[k2].array[i, j] - min2) * (N1_sin - 1) * Mngtl / max2;
                    int    b1  = (int)b1x;
                    //b1 = sdv(b1, 1, N1_sin);
                    int X = a1.GetValue(b2 - b1);
                    res.array[i, j] = X * N1_sin * Mngtl + b1x;
                    //res.array[i, j] = X * N1_sin ;
                    //int x = (int)((zArrayPicture[k1].array[i, j] - min1) * (N2_sin - 1) / (max1 - min1));
                    //int y = (int)((zArrayPicture[k2].array[i, j] - min2) * (N1_sin - 1) / (max2 - min2));
                    //x = sdv(x, sdvig, N2_sin);
                    //y = y + 1;
                    //int X0 = (M * x + N * y) % MN;
                    // if (X0 < d1) res.array[i, j] = X0;
                }
            }

            return(res);
        }
示例#5
0
        public static void Tabl_Diag_Tab(ZArrayDescriptor[] zArrayPicture, PictureBox pictureBox1, int N1_sin, int N2_sin, int scale, int d)
        {
//            if (zArrayPicture[0] == null) { MessageBox.Show("zArrayPicture[k1] == NULL  Unrup.Tabl_int "); return; }
//           if (zArrayPicture[1] == null) { MessageBox.Show("zArrayPicture[k2] == NULL  Unrup.Tabl_int "); return; }

            //           int nx = zArrayPicture[1].width;
//            int ny = zArrayPicture[1].height;

            China(N1_sin, N2_sin);
            MessageBox.Show(" M1 " + M1 + " N1 " + N1 + " M2 " + M2 + " N2 " + N2);

            Graphics g = Graphics.FromHwnd(pictureBox1.Handle);

            g.Clear(Color.White);

            int d1 = d * N1_sin;                     // Максимальный диапазон

            int M  = M1 * N1;
            int N  = M2 * N2;
            int MN = N1_sin * N2_sin;

//            double max1 = SumClass.getMax(zArrayPicture[0]);
//            double min1 = SumClass.getMin(zArrayPicture[0]);
//            double max2 = SumClass.getMax(zArrayPicture[1]);
//            double min2 = SumClass.getMin(zArrayPicture[1]);
            ZIntDescriptor a = new ZIntDescriptor(N1_sin, N2_sin);

            a = Diag(a, N1_sin, N2_sin, d);
            a = Diag_array(a);

            /*          for (int i = 0; i < nx; i++)
             *        {
             *            for (int j = 0; j < ny; j++)
             *            {
             *                //double a = res.array[i, j];
             *                int b2 = (int)((zArrayPicture[0].array[i, j] - min1) * (N2_sin - 1) / (max1 - min1));
             *                int b1 = (int)((zArrayPicture[1].array[i, j] - min2) * (N1_sin - 1) / (max2 - min2));
             *                int X0 =  a.GetValue(b2 - b1);
             *                X0 = X0 * N1_sin + b1;
             *                if (X0 < d1) g.FillRectangle(new SolidBrush(Color.Green), b2 * scale, b1 * scale, 1, 1);
             *            }
             *        }
             */

            for (int i = 0; i < N2_sin; i++)
            {
                for (int j = 0; j < N1_sin; j++)
                {
                    int X0 = a.GetValue(i - j);
                    int c  = X0 * 93 % 250;
                    int c1 = X0 * 21 % 250;
                    int c3 = X0 * 80 % 250;
                    if (X0 != -1)
                    {
                        g.FillRectangle(new SolidBrush(Color.FromArgb(c, c1, c3)), i * scale, j * scale, 2, 2);
                    }
                }
            }

            a = Diag(a, N1_sin, N2_sin, d);

            for (int i = 0; i < N2_sin; i++)
            {
                for (int j = 0; j < N1_sin; j++)
                {
                    int X0 = a.GetValue(i - j + 1);
                    if (X0 != -1)
                    {
                        g.FillRectangle(new SolidBrush(Color.White), i * scale, j * scale, 2, 2);
                    }
                }
            }
        }