Пример #1
0
        /// <summary>
        /// Строит луч от пикселя вверх 
        /// </summary>
        /// <param name="image">Изображение, представляющее границы</param>
        /// <param name="fillingImage">Изображение для карты SWT</param>
        /// <param name="comparator">Функция сравнение интенсивностей пикселей</param>
        /// <param name="row">Номер строки пикселя, от которого строится луч</param>
        /// <param name="column">Номер столбца пикселя, от которого строится луч</param>
        private void TrackRayUp(GreyImage image, GreyImage fillingImage, List<Ray> rays, CompareIntensity comparator, int row, int column)
        {
            try
            {
                int imageHeight = image.Height;
                int rowFrom = row;
                row -= 1;

              //  while (row >= 0 && image.Pixels[row, column].BorderType != BorderType.Border.STRONG)
               //     --row;

                for (; ;)
                {
                    if (row < 0 || image.Pixels[row, column].BorderType == BorderType.Border.STRONG ||
                        (image.Pixels[row, column + 1].BorderType == BorderType.Border.STRONG &&
                        image.Pixels[row, column - 1].BorderType == BorderType.Border.STRONG) ||

                        (image.Pixels[row, column + 1].BorderType == BorderType.Border.STRONG &&
                        image.Pixels[row - 1, column - 1].BorderType == BorderType.Border.STRONG) ||

                        (image.Pixels[row, column - 1].BorderType == BorderType.Border.STRONG &&
                        image.Pixels[row - 1, column + 1].BorderType == BorderType.Border.STRONG))
                        break;
                    --row;
                }

                if (row >= 0)
                {
                    int intensityI = 0;
                    int intensityJ = 0;
                    GetNeighboringPixel(comparator, row, column, ref intensityI, ref intensityJ);

                    if (column == intensityJ && intensityI == row + 1)
                    {
                        fillingImage.Pixels[row, column].StrokeWidth.WasProcessed = true;
                        fillingImage.Pixels[rowFrom, column].StrokeWidth.WasProcessed = true;
                        FillColumnWithStrokeWidth(fillingImage, row + 1, rowFrom, column, rowFrom - row - 1);
                    }
                    else
                    {
                        fillingImage.Pixels[rowFrom, column].StrokeWidth.WasProcessed = true;
                        FillColumnWithStrokeWidth(fillingImage, row + 1, rowFrom, column, rowFrom - row - 1);
                    }
                    Ray ray = new Ray();
                    ray.RowBeginIndex = row + 1;
                    ray.RowEndIndex = rowFrom;
                    ray.ColumnBeginIndex = column;
                    ray.Direction = RayDirection.UP;

                    rays.Add(ray);
                }
            }
            catch (Exception exception)
            {
                throw exception;
            }
        }
Пример #2
0
        /// <summary>
        /// Строит луч от пикселя вправо 
        /// </summary>
        /// <param name="image">Изображение, представляющее границы</param>
        /// <param name="fillingImage">Изображение для карты SWT</param>
        /// <param name="comparator">Функция сравнение интенсивностей пикселей</param>
        /// <param name="row">Номер строки пикселя, от которого строится луч</param>
        /// <param name="column">Номер столбца пикселя, от которого строится луч</param>
        private void TrackRayRight(GreyImage image, GreyImage fillingImage, List<Ray> rays, CompareIntensity comparator, int row, int column)
        {
            try
            {
                int imageWidth = image.Width;
                int columnFrom = column;
                column += 1;
                while (column < imageWidth && image.Pixels[row, column].BorderType != BorderType.Border.STRONG)
                    ++column;

                if (column < imageWidth)
                {
                    int intensityI = 0;
                    int intensityJ = 0;
                    GetNeighboringPixel(comparator, row, column, ref intensityI, ref intensityJ);

                    if (intensityI == row && intensityJ == column - 1)
                    {
                        fillingImage.Pixels[row, column].StrokeWidth.WasProcessed = true;
                        fillingImage.Pixels[row, columnFrom].StrokeWidth.WasProcessed = true;
                        FillRowWithStrokeWidth(fillingImage, columnFrom + 1, column, row, column - columnFrom - 1);
                    }
                    else
                    {
                        fillingImage.Pixels[row, columnFrom].StrokeWidth.WasProcessed = true;
                        FillRowWithStrokeWidth(fillingImage, columnFrom + 1, column, row, column - columnFrom - 1);
                    }
                    Ray ray = new Ray();
                    ray.ColumnBeginIndex = columnFrom + 1;
                    ray.ColumnEndIndex = column;
                    ray.RowBeginIndex = row;
                    ray.Direction = RayDirection.RIGHT;

                    rays.Add(ray);
                }
            }
            catch (Exception exception)
            {
                throw exception;
            }
        }
Пример #3
0
        /// <summary>
        /// Строит луч от пикселя вправо вверх 
        /// </summary>
        /// <param name="image">Изображение, представляющее границы</param>
        /// <param name="fillingImage">Изображение для карты SWT</param>
        /// <param name="comparator">Функция сравнение интенсивностей пикселей</param>
        /// <param name="row">Номер строки пикселя, от которого строится луч</param>
        /// <param name="column">Номер столбца пикселя, от которого строится луч</param>
        private void TrackRayRightUp(GreyImage image, GreyImage fillingImage, List<Ray> rays, CompareIntensity comparator, int row, int column)
        {
            try
            {
                int imageHeight = image.Height;
                int imageWidth = image.Width;
                int columnFrom = column;
                int rowfrom = row;

                column += 1;
                row -= 1;

                /*  while (row >= 0 && column < imageWidth && image.Pixels[row, column].BorderType != BorderType.Border.STRONG &&
                      (image.Pixels[row, column].BorderType != BorderType.Border.STRONG))
                  {
                      --row;
                      ++column;
                  }*/

                for (;;)
                {
                    if (row - 1 < 0 || column + 1 >= imageWidth || image.Pixels[row, column].BorderType == BorderType.Border.STRONG ||
                        (image.Pixels[row - 1, column].BorderType == BorderType.Border.STRONG &&
                        image.Pixels[row, column + 1].BorderType == BorderType.Border.STRONG))
                        break;
                    --row;
                    ++column;
                }

                if (column + 1 < imageWidth && row - 1 >= 0)
                {
                    int intensityI = 0;
                    int intensityJ = 0;
                    GetNeighboringPixel(comparator, row, column, ref intensityI, ref intensityJ);

                    if (row == intensityI - 1 && column == intensityJ + 1)
                    {
                        fillingImage.Pixels[row, column].StrokeWidth.WasProcessed = true;
                        fillingImage.Pixels[rowfrom, columnFrom].StrokeWidth.WasProcessed = true;
                        FillDiagonaWithStrokeWidth(fillingImage, row + 1, rowfrom, column - 1, -1, (int) ((rowfrom - row - 1) * Math.Sqrt(2.0)));
                    }
                    else
                    {
                        fillingImage.Pixels[rowfrom, columnFrom].StrokeWidth.WasProcessed = true;
                        FillDiagonaWithStrokeWidth(fillingImage, row + 1, rowfrom, column - 1, -1, (int) ((rowfrom - row - 1) * Math.Sqrt(2.0)));
                    }
                    Ray ray = new Ray();
                    ray.RowBeginIndex = row + 1;
                    ray.RowEndIndex = rowfrom;
                    ray.ColumnBeginIndex = column - 1;
                    ray.Direction = RayDirection.RIGHT_UP;
                    ray.ColumnStep = -1;

                    rays.Add(ray);
                }
            }
            catch (Exception exception)
            {
                throw exception;
            }
        }
Пример #4
0
        /// <summary>
        /// Строит луч от пикселя вниз 
        /// </summary>
        /// <param name="image">Изображение, представляющее границы</param>
        /// <param name="fillingImage">Изображение для карты SWT</param>
        /// <param name="comparator">Функция сравнение интенсивностей пикселей</param>
        /// <param name="row">Номер строки пикселя, от которого строится луч</param>
        /// <param name="column">Номер столбца пикселя, от которого строится луч</param>
        private void TrackRayDown(GreyImage image, GreyImage fillingImage, List<Ray> rays, CompareIntensity comparator, int row, int column)
        {
            try
            {
                int imageHeight = image.Height;
                int rowFrom = row;
                row += 1;

                while (row < imageHeight && image.Pixels[row, column].BorderType != BorderType.Border.STRONG)
                    ++row;

                if (row < imageHeight)
                {
                    int intensityI = 0;
                    int intensityJ = 0;
                    GetNeighboringPixel(comparator, row, column, ref intensityI, ref intensityJ);

                    if (column == intensityJ && intensityI == row - 1)
                    {
                        fillingImage.Pixels[row, column].StrokeWidth.WasProcessed = true;
                        fillingImage.Pixels[rowFrom, column].StrokeWidth.WasProcessed = true;
                        FillColumnWithStrokeWidth(fillingImage, rowFrom + 1, row, column, row - rowFrom - 1);
                    }
                    else
                    {
                        fillingImage.Pixels[rowFrom, column].StrokeWidth.WasProcessed = true;
                        FillColumnWithStrokeWidth(fillingImage, rowFrom + 1, row, column, row - rowFrom - 1);
                    }
                    Ray ray = new Ray();
                    ray.RowBeginIndex = rowFrom + 1;
                    ray.RowEndIndex = row;
                    ray.ColumnBeginIndex = column;
                    ray.Direction = RayDirection.DOWN;

                    rays.Add(ray);
                }

            }
            catch (Exception exception)
            {
                throw exception;
            }
        }
Пример #5
0
        /// <summary>
        /// Вычисление среднего значения ширины штриха для горизонтального луча
        /// </summary>
        /// <param name="swtImage">SWT - Карта</param>
        /// <param name="ray">лучи</param>
        /// <returns>среднее</returns>
        private double CountSWTMeanRowRay(GreyImage swtImage, Ray ray)
        {
            try
            {
                double summ = 0.0;
                int pixelsNumberInRay = 0;
                int row = ray.RowBeginIndex;

                for (int i = ray.ColumnBeginIndex; i < ray.ColumnEndIndex; i++)
                {
                    summ += swtImage.Pixels[row, i].StrokeWidth.Width;
                    ++pixelsNumberInRay;
                }
                return (double) summ / (double) pixelsNumberInRay;
            }
            catch (Exception exception)
            {
                throw exception;
            }
        }
Пример #6
0
        /// <summary>
        /// Вычисление среднего значения ширины штриха для диагонального луча
        /// </summary>
        /// <param name="swtImage">SWT - Карта</param>
        /// <param name="ray">лучи</param>
        /// <returns>среднее</returns>
        private double CountSWTMeanDiagonalRay(GreyImage swtImage, Ray ray)
        {
            try
            {
                double summ = 0.0;
                int pixelsNumberInRay = 0;

                for (int i = ray.RowBeginIndex, j = ray.ColumnBeginIndex; i < ray.RowEndIndex; i++, j += ray.ColumnStep)
                {
                    summ += swtImage.Pixels[i, j].StrokeWidth.Width;
                    ++pixelsNumberInRay;
                }

                return (double)summ / (double)pixelsNumberInRay;
            }
            catch (Exception exception)
            {
                throw exception;
            }
        }
Пример #7
0
        /// <summary>
        /// Усреднение значений ширины штриха для пикселей горизонтального луча
        /// </summary>
        /// <param name="swtImage">SWT - карта</param>
        /// <param name="ray">Лучи</param>
        /// <param name="mean">Среднее значение ширины штриха</param>
        private void AveragingRowRayPixels(GreyImage swtImage, Ray ray, double mean)
        {
            try
            {
                int row = ray.RowBeginIndex;

                for (int i = ray.ColumnBeginIndex; i < ray.ColumnEndIndex; i++)
                {
                    if (swtImage.Pixels[row, i].StrokeWidth.Width > mean)
                        swtImage.Pixels[row, i].StrokeWidth.Width = (int) mean;
                }
            }
            catch (Exception exception)
            {
                throw exception;
            }
        }
Пример #8
0
 /// <summary>
 /// Усреднение значений ширины штриха для пикселей диагонального луча
 /// </summary>
 /// <param name="swtImage">SWT - карта</param>
 /// <param name="ray">Лучи</param>
 /// <param name="mean">Среднее значение ширины штриха</param>
 private void AveragingDiagonalRayPixels(GreyImage swtImage, Ray ray, double mean)
 {
     try
     {
         for (int i = ray.RowBeginIndex, j = ray.ColumnBeginIndex; i < ray.RowEndIndex; i++, j += ray.ColumnStep)
         {
             if (swtImage.Pixels[i, j].StrokeWidth.Width > mean)
                 swtImage.Pixels[i, j].StrokeWidth.Width = (int) mean;
         }
     }
     catch (Exception exception)
     {
         throw exception;
     }
 }