コード例 #1
0
ファイル: ImgProc.cs プロジェクト: widemeadows/TurboCV
        public static List <Mat <byte> > SplitViaOrientation(Mat <byte> src, int orientNum = 4)
        {
            int sigma = 9, lambda = 24, ksize = sigma * 6 + 1;

            List <Mat <double> > tmp = new List <Mat <double> >(orientNum);

            for (int i = 0; i < orientNum; i++)
            {
                tmp.Add(null);
            }

            Parallel.For(0, orientNum, (i) =>
            {
                Mat <double> kernel = Filter.GetGaborKernel(new Size(ksize, ksize), sigma,
                                                            Math.PI / orientNum * i, lambda, 1, 0);

                tmp[i] = ImgProc.Filter2D(src, kernel);
            });

            List <Mat <byte> > channels = new List <Mat <byte> >(orientNum);

            for (int i = 0; i < orientNum; i++)
            {
                Mat <byte> channel = new Mat <byte>(src.Size);
                channel.Set(byte.MinValue);

                channels.Add(channel);
            }

            for (int i = 0; i < src.Rows; i++)
            {
                for (int j = 0; j < src.Cols; j++)
                {
                    if (src[i, j] != byte.MinValue)
                    {
                        double maxResponse = double.MinValue;
                        int    o           = -1;

                        for (int k = 0; k < orientNum; k++)
                        {
                            tmp[k][i, j] = Math.Abs(tmp[k][i, j]);

                            if (tmp[k][i, j] > maxResponse)
                            {
                                maxResponse = tmp[k][i, j];
                                o           = k;
                            }
                        }

                        channels[o][i, j] = src[i, j];
                    }
                }
            }

            return(channels);
        }
コード例 #2
0
        public static Mat <byte> Preprocess(Mat <byte> src, Size size, bool thinning = true)
        {
            Mat <byte> revImage = ImgProc.Reverse(src);

            Mat <byte> cleanedImage = BinaryImgProc.Clean(revImage, 3);

            Mat <byte> boundingBox = BinaryImgProc.GetBoundingBox(revImage);

            int widthPadding = 0, heightPadding = 0;

            if (boundingBox.Rows < boundingBox.Cols)
            {
                heightPadding = (boundingBox.Cols - boundingBox.Rows) / 2;
            }
            else
            {
                widthPadding = (boundingBox.Rows - boundingBox.Cols) / 2;
            }
            Mat <byte> squareImage = ImgProc.CopyMakeBorder <byte>(boundingBox,
                                                                   heightPadding, heightPadding, widthPadding, widthPadding, 0);

            Size scaledSize = new Size((int)(size.Height - 2 * size.Height / 16.0),
                                       (int)(size.Width - 2 * size.Width / 16.0));
            Mat <byte> scaledImage = ImgProc.Resize(squareImage, scaledSize);

            heightPadding = (size.Height - scaledSize.Height) / 2;
            widthPadding  = (size.Width - scaledSize.Width) / 2;
            Mat <byte> paddedImage = ImgProc.CopyMakeBorder <byte>(scaledImage,
                                                                   heightPadding, heightPadding, widthPadding, widthPadding, 0);

            Mat <byte> finalImage = paddedImage.Clone();

            for (int i = 0; i < finalImage.Rows; i++)
            {
                for (int j = 0; j < finalImage.Cols; j++)
                {
                    if (finalImage[i, j] > 54)
                    {
                        finalImage[i, j] = byte.MaxValue;
                    }
                    else
                    {
                        finalImage[i, j] = 0;
                    }
                }
            }

            if (thinning)
            {
                finalImage = BinaryImgProc.Thin(finalImage);
            }

            return(finalImage);
        }
コード例 #3
0
ファイル: ImgProc.cs プロジェクト: widemeadows/TurboCV
        public static Mat <byte> Blur(Mat <byte> image, double sigma = 1.0)
        {
            Mat <double> tmp = ImgProc.Convolve2D(image, GetGaussianKernel(sigma));

            Mat <byte> result = new Mat <byte>(tmp.Size);

            for (int i = 0; i < result.Rows; i++)
            {
                for (int j = 0; j < result.Cols; j++)
                {
                    result[i, j] = (byte)tmp[i, j];
                }
            }

            return(result);
        }
コード例 #4
0
ファイル: ImgProc.cs プロジェクト: widemeadows/TurboCV
        public static Tuple <Mat <double>, Mat <double> > GetGradient(Mat <byte> image, double sigma = 1.0)
        {
            Tuple <Mat <double>, Mat <double> > kernel = GetGradientKernel(sigma);
            Mat <double> dxImage = ImgProc.Convolve2D(image, kernel.Item1);
            Mat <double> dyImage = ImgProc.Convolve2D(image, kernel.Item2);

            Mat <double> orientImage = new Mat <double>(image.Size);

            for (int i = 0; i < image.Rows; i++)
            {
                for (int j = 0; j < image.Cols; j++)
                {
                    double orient = Math.Atan2(dyImage[i, j], dxImage[i, j]);
                    while (orient >= Math.PI)
                    {
                        orient -= Math.PI;
                    }
                    while (orient < 0)
                    {
                        orient += Math.PI;
                    }

                    orientImage[i, j] = orient;
                }
            }

            Mat <double> powerImage = new Mat <double>(image.Size);

            for (int i = 0; i < image.Rows; i++)
            {
                for (int j = 0; j < image.Cols; j++)
                {
                    powerImage[i, j] = Math.Sqrt(
                        dyImage[i, j] * dyImage[i, j] + dxImage[i, j] * dxImage[i, j]);
                }
            }

            return(Tuple.Create(powerImage, orientImage));
        }