Exemplo n.º 1
0
        /// <summary>
        /// Сорирует точки в массиве так, чтобы они были последовательны и их возможно было напечатать.
        /// </summary>
        /// <param name="Arr">Массив для сортировки.</param>
        private void PointSort(ref VPoint[] Arr)
        {
            var    res = new VPoint[0];
            VPoint checked_;;
            var    first         = Arr[0]; checked_ = first;
            var    uncheckedmask = new bool[Arr.Length];

            for (int ii = 0; ii <= Arr.Length; ii++)
            {
                var mostshort = 99999.9;
                int num       = 0;
                for (int i = 0; i <= Arr.Length - 1; i++)
                {
                    if (!uncheckedmask[i])
                    {
                        var dist = Distance(checked_, Arr[i]);
                        if (dist < mostshort)
                        {
                            mostshort = dist; num = i;
                        }
                    }
                }
                checked_           = Arr[num];
                uncheckedmask[num] = true;
                Helper.InsertToArray(ref res, checked_);
            }
            Arr = res;
        }
Exemplo n.º 2
0
 /// <summary>
 /// Находит дистанцию между двумя точками.
 /// </summary>
 /// <param name="pn1">Первая точка.</param>
 /// <param name="pn2">Вторая точка.</param>
 private float Distance(VPoint pn1, VPoint pn2)
 {
     return((float)Math.Sqrt((pn2.X - pn1.X) * (pn2.X - pn1.X) + (pn2.Y - pn1.Y) * (pn2.Y - pn1.Y)));
 }
Exemplo n.º 3
0
 /// <summary>
 /// Меняет коодринаты X и Y местами.
 /// </summary>
 public static VPoint SwapCoordinates(VPoint pn)
 {
     return(new VPoint(pn.Y, pn.X, Color.Black));
 }
Exemplo n.º 4
0
        /// <summary>
        /// Основной метод класса. Выделяет те самые массивы точек, которые методом <see cref="SortPointArray(VPointEx[])"/> бьются на контура. Сортирует их и чистит от хлама. Возвращает и берет данные с соответсвущих словарей. Многопоточная операция.
        /// </summary>
        private void ImagePrData()
        {
            // == ШАГ 1: ОБЪЯВЛЕНИЕ ЛОКАЛЬНЫХ ПЕРЕМЕННЫХ ==


            //Основной счетчик. Обозначает уникальный номер области или объекта.
            int AreaMark = 0;
            //Результирующий массив контуров.
            var Contours = new VPointEx[0][];
            //Изначальное биннарное представление изображения. Если пиксель равен (0,0,0), то digMap на этом индексе будет равен 1.
            var digMap = new int[0][];
            //Само изображение данного потока.
            var ProceedImage = _imgMap[Thread.CurrentThread.ManagedThreadId];
            //Массив, с обозначенными на нем областями.
            var WhiteMap = new int[0][];

            //Массив цветов изображения.
            Color[][] BufferImage = new Color[0][];


            // == ШАГ 2: ПОДГОТОВКА ==


            //Вывод информации о выполении новой операции.
            if (_outputDebugInfo)
            {
                Console.WriteLine(string.Format(_initSay, Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.ThreadState, Thread.CurrentThread.Priority, (Milliseconds / 1000)));
                Console.WriteLine(string.Format(_stateSay, Thread.CurrentThread.ManagedThreadId, "Init", (Milliseconds / 1000)));
            }
            _proList[Thread.CurrentThread.ManagedThreadId]++;

            //Задаем размер BufferImage.
            Helper.ResizeArray(ref BufferImage, ProceedImage.Height, ProceedImage.Width);
            //Задаем размер digMap.
            Helper.ResizeArray(ref digMap, BufferImage.Length, BufferImage[0].Length);

            //Заполняем BufferImage цветами из ProceedImage.
            for (int i = 0; i <= ProceedImage.Width - 1; i++)
            {
                for (int ii = 0; ii <= ProceedImage.Height - 1; ii++)
                {
                    BufferImage[ii][i] = ProceedImage.GetPixel(i, ii);
                }
            }

            //Заполняем digMap по вышеуказанному правилу.
            for (int i = 0; i <= BufferImage.Length - 2; i++)
            {
                for (int ii = 0; ii <= BufferImage[0].Length - 2; ii++)
                {
                    if (BufferImage[i][ii].R == 0 && BufferImage[i][ii].G == 0 && BufferImage[i][ii].B == 0)
                    {
                        digMap[i][ii] = 1;
                    }
                }
            }

            //Добавляем digMap по 2 пустых ячейки с каждой стороны.
            Surround(ref digMap);
            Surround(ref digMap);

            //Создаем копию digMap.
            WhiteMap = digMap;


            // == ШАГ 3: ПОИСК ОБЛАСТЕЙ ==


            //Вывод информации о выполении новой операции.
            if (_outputDebugInfo)
            {
                Console.WriteLine(string.Format(_stateSay, Thread.CurrentThread.ManagedThreadId, "Searching For Areas", (Milliseconds / 1000)));
            }
            _proList[Thread.CurrentThread.ManagedThreadId]++;

            //Присваиваем 3, потому что 0,1 и 2 зарезервированы.
            AreaMark = 3;

            //Для каждого пикселя выполняем.
            for (int i = 1; i <= BufferImage.Length - 2; i++)
            {
                for (int ii = 1; ii <= BufferImage[0].Length - 2; ii++)
                {
                    //Если, проверяеммый пиксель пустой (что есть условием существования области)
                    if (WhiteMap[i][ii] == 0)
                    {
                        //Обозначиваем этот пиксель уникальным для области номером.
                        WhiteMap[i][ii] = AreaMark;

                        //Следующая операция выполняется для присваивания всем пикселям данной области, одного и того же номера.
                        //Некий аналог рекурсивного метода поиска объектов.
                        while (true)
                        {
                            //Указывает на то, были ли произведены какие-либо изменения.
                            bool changedSomething = false;

                            //Для каждого пикселя выполняем.
                            for (int i2 = 1; i2 <= BufferImage.Length - 2; i2++)
                            {
                                for (int ii2 = 1; ii2 <= BufferImage[0].Length - 2; ii2++)
                                {
                                    //Если есть пиксель, рядом с пикселем, помеченным нашим текущем AreaMark, то...
                                    if (WhiteMap[i2][ii2] == 0 && NearK(WhiteMap, i2, ii2, AreaMark))
                                    {
                                        //...и этот пиксель помечаем, как AreaMark.
                                        WhiteMap[i2][ii2] = AreaMark;
                                        //Помечаем, что изменили что-то.
                                        changedSomething = true;
                                    }
                                }
                            }
                            if (!changedSomething)
                            {
                                break;
                            }
                        }
                        AreaMark++;
                    }
                }
            }


            // == ШАГ 4: ПОИСК ОБЪЕКТОВ ==

            //Вывод информации о выполении новой операции.
            if (_outputDebugInfo)
            {
                Console.WriteLine(string.Format(_stateSay, Thread.CurrentThread.ManagedThreadId, "Searching For Objects", (Milliseconds / 1000)));
            }
            _proList[Thread.CurrentThread.ManagedThreadId]++;


            //Создаем копию digMap.
            var MaskArray = digMap;

            //Для отделения областей от объектов, добавляем к счетчику еще 2.
            var ObjectMark = AreaMark + 2;

            //Для каждого пикселя выполняем.
            for (int i = 1; i <= BufferImage.Length - 2; i++)
            {
                for (int ii = 1; ii <= BufferImage[0].Length - 2; ii++)
                {
                    //Если, проверяеммый пиксель не пустой (что есть условием существования объекта)
                    if (MaskArray[i][ii] == 1)
                    {
                        //tempPointArray - временный массив несортированых точек.
                        VPointEx[] tempPointArray = new VPointEx[0];

                        //Обозначиваем этот пиксель уникальным для объетка номером.
                        MaskArray[i][ii] = ObjectMark;

                        //Если, этот пиксель граничит с каким-то пикселем из области (т.е. его значение <= AreaMark)...
                        for (int d = 3; d <= AreaMark - 1; d++)
                        {
                            if (NearK(WhiteMap, i, ii, d))
                            {
                                //..., то добавляем его в наш массив.
                                Helper.InsertToArray(ref tempPointArray, new VPointEx(i, ii, d, Color.Empty));
                            }
                        }

                        //Далее выполняется аналог предыдущей операции, с некоторым изменениям.
                        while (true)
                        {
                            //Указывает на то, были ли произведены какие-либо изменения.
                            bool changedSomething = false;

                            //Для каждого пикселя выполняем.
                            for (int i2 = 1; i2 <= BufferImage.Length - 2; i2++)
                            {
                                for (int ii2 = 1; ii2 <= BufferImage[0].Length - 2; ii2++)
                                {
                                    //Если есть пиксель, рядом с пикселем, помеченным нашим текущем ObjectMark, то...
                                    if (MaskArray[i2][ii2] == 1 && NearK(MaskArray, i2, ii2, ObjectMark))
                                    {
                                        //...и этот пиксель помечаем, как ObjectMark.
                                        MaskArray[i2][ii2] = ObjectMark;
                                        //Помечаем, что изменили что-то.
                                        changedSomething = true;

                                        //В этом случаем, мы выполняем то же, что и с первым пекселем.
                                        //Если, этот пиксель граничит с каким-то пикселем из области (т.е. его значение <= AreaMark)...
                                        for (int d = 3; d <= AreaMark - 1; d++)
                                        {
                                            if (NearK(WhiteMap, i2, ii2, d))
                                            {
                                                //..., то добавляем его в наш массив.
                                                Helper.InsertToArray(ref tempPointArray, new VPointEx(i2, ii2, d, Color.Empty));
                                                break;
                                            }
                                        }
                                    }
                                }
                            }
                            if (!changedSomething)
                            {
                                break;
                            }
                        }
                        ObjectMark++;

                        //Далее сортируем наш массив.
                        var tmp = SortPointArray(tempPointArray);
                        //Сливаем его с нашим Contours.
                        Helper.ConcatArrays(ref Contours, ref tmp);
                        tmp            = null;
                        tempPointArray = null;
                    }
                }
            }


            // == ШАГ 5: ОБРАБОТКА РЕЗУЛЬТАТОВ ==


            // ШАГ 5.1: Сортировка точек.

            //Вывод информации о выполении новой операции.
            if (_outputDebugInfo)
            {
                Console.WriteLine(string.Format(_stateSay, Thread.CurrentThread.ManagedThreadId, "Sorting Points", (Milliseconds / 1000)));
            }
            _proList[Thread.CurrentThread.ManagedThreadId]++;

            //Для каждого контура...
            for (int ii = 0; ii <= Contours.Length - 1; ii++)
            {
                VPoint[] sortedArray = new VPoint[0];
                //Добавляем в новый массив необходимые точки.
                //Это необходимо из-за различия типов VPoint и VPointEx.
                for (int i = 0; i <= Contours[ii].Length - 1; i++)
                {
                    Helper.InsertToArray(ref sortedArray, Contours[ii][i].BasePoint);
                }

                //Сортируем наш массив.
                PointSort(ref sortedArray);

                //Выполняем обратную операцию пресваивания.
                for (int i = 0; i <= Contours[ii].Length - 1; i++)
                {
                    Contours[ii][i].BasePoint = sortedArray[i];
                }
                sortedArray = null;
            }

            // ШАГ 5.2: Сортировка контуров и сохранения результата.

            //Вывод информации о выполении новой операции.
            if (_outputDebugInfo)
            {
                Console.WriteLine(string.Format(_stateSay, Thread.CurrentThread.ManagedThreadId, "Sorting Contours", (Milliseconds / 1000)));
            }
            _proList[Thread.CurrentThread.ManagedThreadId]++;

            //Сортировка всех контуров.
            CSort(ref Contours);

            //Сохраняем результат.
            _imgVect.Add(ProceedImage, Contours);

            //Отмечаем что процесс завершенн.
            _endList[Thread.CurrentThread.ManagedThreadId] = true;

            //Вывод информации о завершении процесса.
            if (_outputDebugInfo)
            {
                Console.WriteLine("Stream Ended. ID: " + Thread.CurrentThread.ManagedThreadId);
            }
        }
Exemplo n.º 5
0
 /// <summary>
 /// Находит растояние между двумя точками.
 /// </summary>
 /// <param name="ar1">Первая точка.</param>
 /// <param name="ar2">Вторая точка.</param>
 private double Distance(VPoint ar1, VPoint ar2)
 {
     return(Math.Sqrt((ar1.X - ar2.X) * (ar1.X - ar2.X) + (ar1.Y - ar2.Y) * (ar1.Y - ar2.Y)));
 }
Exemplo n.º 6
0
 /// <summary>
 /// Создает новый екземпляр объекта <see cref="VPointEx"/>. С координатами (Х,Y) параметром n и цветом С.
 /// </summary>
 /// <param name="x">Х точки.</param>
 /// <param name="y">Y точки.</param>
 /// <param name="n">Параметр точки.</param>
 /// <param name="c">Цвет точки (нигде не используется).</param>
 public VPointEx(double x, double y, double n, Color c)
 {
     BasePoint = new VPoint(x, y, c);
     BordWith  = (int)n;
 }
Exemplo n.º 7
0
 /// <summary>
 /// Создает новый екземпляр объекта <see cref="VPointEx"/>. С координатами (Х,Y).
 /// </summary>
 /// <param name="x">Х точки.</param>
 /// <param name="y">Y точки.</param>
 public VPointEx(double x, double y)
 {
     BasePoint = new VPoint(x, y, Color.Black);
     BordWith  = 0;
 }