public void Apply()
        {
            string output_dir = @"C:\Users\yaoyichi\Desktop\";
            string inputPath  = output_dir + "1.png";

            Log.SetLogDir(output_dir);
            Log.SetOutputDir(output_dir);

            HoughCircleTransformation circleTransform = new HoughCircleTransformation(35);
            // apply Hough circle transform
            Bitmap srcimg = new Bitmap(inputPath);

            AForge.Imaging.Filters.BradleyLocalThresholding bradley = new AForge.Imaging.Filters.BradleyLocalThresholding();
            Image <Gray, Byte> img    = new Image <Gray, Byte>(inputPath);
            Bitmap             dstimg = bradley.Apply(img.Bitmap);

            circleTransform.ProcessImage(dstimg);
            Bitmap houghCirlceImage = circleTransform.ToBitmap();

            // get circles using relative intensity
            HoughCircle[] circles = circleTransform.GetCirclesByRelativeIntensity(0.2);
            Graphics      g       = Graphics.FromImage(ImageUtils.AnyToFormat24bppRgb(srcimg));

            foreach (HoughCircle circle in circles)
            {
                //circle.RelativeIntensity
                g.DrawEllipse(new Pen(Color.Red), circle.X, circle.Y, circle.Radius, circle.Radius);
            }
            g.Dispose();
            srcimg.Save(output_dir + "1_.png");
        }
 public static string ApplyBradleyLocalThresholding(string inputPath, string outputPath)
 {
     AForge.Imaging.Filters.BradleyLocalThresholding bradley = new AForge.Imaging.Filters.BradleyLocalThresholding();
     Image<Gray, Byte> img = new Image<Gray, Byte>(inputPath);
     Bitmap dstimg = bradley.Apply(img.Bitmap);
     dstimg.Save(outputPath);
     dstimg.Dispose();
     dstimg = null;
     img.Dispose();
     img = null;
     return outputPath;
 }
示例#3
0
        public static string ApplyBradleyLocalThresholding(string inputPath, string outputPath)
        {
            AForge.Imaging.Filters.BradleyLocalThresholding bradley = new AForge.Imaging.Filters.BradleyLocalThresholding();
            Image <Gray, Byte> img    = new Image <Gray, Byte>(inputPath);
            Bitmap             dstimg = bradley.Apply(img.Bitmap);

            dstimg.Save(outputPath);
            dstimg.Dispose();
            dstimg = null;
            img.Dispose();
            img = null;
            return(outputPath);
        }
示例#4
0
        public static Bitmap ProcessDataSetImage(Bitmap bitmap)
        {
            //var uProcessed = AForge.Imaging.UnmanagedImage.FromManagedImage(bitmap);
            AForge.Imaging.Filters.Grayscale grayFilter = new AForge.Imaging.Filters.Grayscale(0.2125, 0.7154, 0.0721);
            //AForge.Imaging.Filters.Grayscale grayFilter = new AForge.Imaging.Filters.Grayscale(0.5, 0.5, 0.5);
            var uProcessed = grayFilter.Apply(AForge.Imaging.UnmanagedImage.FromManagedImage(bitmap));

            AForge.Imaging.Filters.BradleyLocalThresholding threshldFilter = new AForge.Imaging.Filters.BradleyLocalThresholding();
            threshldFilter.PixelBrightnessDifferenceLimit = 0.15f;
            //AForge.Imaging.Filters.Threshold threshldFilter = new AForge.Imaging.Filters.Threshold(95);
            threshldFilter.ApplyInPlace(uProcessed);

            processSample(ref uProcessed);

            return(uProcessed.ToManagedImage());
        }
        public static void test(String directory)
        {
            ColorSegmentationWorker cs = new ColorSegmentationWorker();
            //cs.Apply(@"C:\Users\yaoyichi\Desktop\", @"C:\Users\yaoyichi\Desktop\", "WMSImage_ms.png");

            //            AForge.Imaging.Filters.OtsuThreshold otsu = new AForge.Imaging.Filters.OtsuThreshold();
            AForge.Imaging.Filters.BradleyLocalThresholding bradley = new AForge.Imaging.Filters.BradleyLocalThresholding();
            Image<Gray, Byte> img = new Image<Gray, Byte>(@"C:\Users\yaoyichi\Desktop\Images-22-10\576800_mc1024_k64.png");
            Bitmap dstimg =bradley.Apply(img.Bitmap);

            dstimg.Save(@"C:\Users\yaoyichi\Desktop\Images-22-10\576800_mc1024_k64-2.png");
              //  Image<Gray, Byte> img = new Image<Gray, Byte>(@"C:\Users\yaoyichi\Desktop\Images-22-10\576800_mc1024_k64.png");

            img = img.ThresholdAdaptive(new Gray(255),
              Emgu.CV.CvEnum.ADAPTIVE_THRESHOLD_TYPE.CV_ADAPTIVE_THRESH_GAUSSIAN_C,Emgu.CV.CvEnum.THRESH.CV_THRESH_BINARY,15,new Gray(0));

            img.Save(@"C:\Users\yaoyichi\Desktop\Images-22-10\576800_mc1024_k64-1.png");
        }
示例#6
0
        public static string ApplyRGBColorThresholding(string inputPath, string outputPath, RGBThreshold thd, int tnum)
        {
            AForge.Imaging.Filters.BradleyLocalThresholding bradley = new AForge.Imaging.Filters.BradleyLocalThresholding();
            _srcimg.Dispose();
            _srcimg  = null;
            _srcimg  = new Bitmap(inputPath);
            _srcData = _srcimg.LockBits(
                new Rectangle(0, 0, _srcimg.Width, _srcimg.Height),
                ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
            _dstimg = new  bool[_srcimg.Height, _srcimg.Width];

            try
            {
                Thread[] thread_array = new Thread[tnum];
                for (int i = 0; i < tnum; i++)
                {
                    thread_array[i] = new Thread(new ParameterizedThreadStart(Binarization.RunRGBColorThresholding));
                    thread_array[i].Start(i);
                }
                for (int i = 0; i < tnum; i++)
                {
                    thread_array[i].Join();
                }

                _srcimg.UnlockBits(_srcData);
                _srcimg.Dispose();
                _srcimg = null;

                Bitmap img = ImageUtils.Array2DToBitmap(_dstimg);
                img.Save(outputPath);
                img.Dispose();
                img     = null;
                _dstimg = null;

                return(outputPath);
            }
            catch (Exception e)
            {
                Log.WriteLine(e.Message);
                Log.WriteLine(e.Source);
                Log.WriteLine(e.StackTrace);
                throw;
            }
        }
        public static string ApplyRGBColorThresholding(string inputPath, string outputPath, RGBThreshold thd, int tnum)
        {
            AForge.Imaging.Filters.BradleyLocalThresholding bradley = new AForge.Imaging.Filters.BradleyLocalThresholding();
            _srcimg.Dispose();
            _srcimg = null;
            _srcimg = new Bitmap(inputPath);
            _srcData = _srcimg.LockBits(
                       new Rectangle(0, 0, _srcimg.Width, _srcimg.Height),
                       ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
            _dstimg = new  bool[_srcimg.Height,_srcimg.Width];

            try
            {
                Thread[] thread_array = new Thread[tnum];
                for (int i = 0; i < tnum; i++)
                {
                    thread_array[i] = new Thread(new ParameterizedThreadStart(Binarization.RunRGBColorThresholding));
                    thread_array[i].Start(i);
                }
                for (int i = 0; i < tnum; i++)
                    thread_array[i].Join();

                _srcimg.UnlockBits(_srcData);
                _srcimg.Dispose();
                _srcimg = null;

                Bitmap img = ImageUtils.Array2DToBitmap(_dstimg);
                img.Save(outputPath);
                img.Dispose();
                img = null;
                _dstimg = null;

                return outputPath;
            }
            catch (Exception e)
            {
                Log.WriteLine(e.Message);
                Log.WriteLine(e.Source);
                Log.WriteLine(e.StackTrace);
                throw;
            }
        }
示例#8
0
        public static void test(String directory)
        {
            ColorSegmentationWorker cs = new ColorSegmentationWorker();

            //cs.Apply(@"C:\Users\yaoyichi\Desktop\", @"C:\Users\yaoyichi\Desktop\", "WMSImage_ms.png");

//            AForge.Imaging.Filters.OtsuThreshold otsu = new AForge.Imaging.Filters.OtsuThreshold();
            AForge.Imaging.Filters.BradleyLocalThresholding bradley = new AForge.Imaging.Filters.BradleyLocalThresholding();
            Image <Gray, Byte> img    = new Image <Gray, Byte>(@"C:\Users\yaoyichi\Desktop\Images-22-10\576800_mc1024_k64.png");
            Bitmap             dstimg = bradley.Apply(img.Bitmap);

            dstimg.Save(@"C:\Users\yaoyichi\Desktop\Images-22-10\576800_mc1024_k64-2.png");
            //  Image<Gray, Byte> img = new Image<Gray, Byte>(@"C:\Users\yaoyichi\Desktop\Images-22-10\576800_mc1024_k64.png");


            img = img.ThresholdAdaptive(new Gray(255),
                                        Emgu.CV.CvEnum.ADAPTIVE_THRESHOLD_TYPE.CV_ADAPTIVE_THRESH_GAUSSIAN_C, Emgu.CV.CvEnum.THRESH.CV_THRESH_BINARY, 15, new Gray(0));

            img.Save(@"C:\Users\yaoyichi\Desktop\Images-22-10\576800_mc1024_k64-1.png");
        }
示例#9
0
        public void ProcessImage(Bitmap bitmap, bool justShow)
        {
            //  «Распиливаем» изображение на 16 фрагментов - по отдельной плитке каждый

            //  Минимальная сторона изображения (обычно это высота)
            if (bitmap.Height > bitmap.Width)
            {
                throw new Exception("К такой забавной камере меня жизнь не готовила!");
            }
            int side = bitmap.Height;

            //  Отпиливаем границы, но не более половины изображения
            if (side < 4 * settings.border)
            {
                settings.border = side / 4;
            }
            side -= 2 * settings.border;

            Rectangle cropRect = new Rectangle((bitmap.Width - bitmap.Height) / 2 + settings.border, settings.border, side, side);

            original = new Bitmap(cropRect.Width, cropRect.Height);

            //  Рисуем рамки на оригинале
            Graphics g = Graphics.FromImage(original);

            g.DrawImage(bitmap, new Rectangle(0, 0, original.Width, original.Height), cropRect, GraphicsUnit.Pixel); Pen p = new Pen(Color.Red);

            //  Проверяем значение полей из settings
            if (side < 10 * settings.margin)
            {
                settings.margin = side / 10;
            }

            //  Высчитываем сторону блока для извлечения
            int sz        = side / 4 - 2 * settings.margin;
            int blockSide = side / 4;

            for (int r = 0; r < 4; ++r)
            {
                for (int c = 0; c < 4; ++c)
                {
                    g.DrawRectangle(p, new Rectangle(settings.margin + c * blockSide, settings.margin + r * blockSide, sz, sz));
                }
            }

            //  Рисуем цифры, которые распознались на предыдущем шаге?
            if (justShow)
            {
                DrawNumbersOnOriginalBitmap(g, blockSide);
            }

            //  Конвертируем изображение в градации серого
            AForge.Imaging.Filters.Grayscale grayFilter = new AForge.Imaging.Filters.Grayscale(0.2125, 0.7154, 0.0721);
            processed = grayFilter.Apply(AForge.Imaging.UnmanagedImage.FromManagedImage(original));

            //  Масштабируем изображение до 500x500 - этого достаточно
            AForge.Imaging.Filters.ResizeBilinear scaleFilter = new AForge.Imaging.Filters.ResizeBilinear(500, 500);
            original = scaleFilter.Apply(original);

            //  Если распознавание не планируем – просто выход
            if (justShow)
            {
                return;
            }

            //  Обнуляем state
            for (int i = 0; i < 16; ++i)
            {
                currentDeskState[i] = 0;
            }

            //  Пороговый фильтр применяем. Величина порога берётся из настроек, и меняется на форме
            AForge.Imaging.Filters.BradleyLocalThresholding threshldFilter = new AForge.Imaging.Filters.BradleyLocalThresholding();
            threshldFilter.PixelBrightnessDifferenceLimit = settings.differenceLim;
            threshldFilter.ApplyInPlace(processed);

            for (int r = 0; r < 4; ++r)
            {
                for (int c = 0; c < 4; ++c)
                {
                    //  Берём очередной фрагмент - с дополнительными отступами (мы же там нарисовали прямоугольники)
                    AForge.Imaging.Filters.Crop cropFilter = new AForge.Imaging.Filters.Crop(new Rectangle(2 + settings.margin + c * blockSide, 2 + settings.margin + r * blockSide, sz - 4, sz - 4));
                    arrayPics[r, c] = cropFilter.Apply(processed);

                    //arrayPics[r, c] = processed.Clone(new Rectangle(2+settings.margin + c * blockSide, 2+settings.margin + r * blockSide, sz-4, sz-4), processed.PixelFormat);
                    //  И выполняем сопоставление
                    processSample(r, c);
                }
            }
            DrawNumbersOnOriginalBitmap(g, blockSide);
        }
示例#10
0
        public Bitmap Process(Bitmap image)
        {
            Bitmap filteredImage = convertFormatTo32(image);

            if (filterLevel >= 0)
            {
                filteredImage = resize(filteredImage, ImageSize.Width, ImageSize.Height);
            }
            if (filterLevel >= 1)
            {

                if (ContrastStretch)
                {
                    AForge.Imaging.Filters.ContrastStretch stretcher = new AForge.Imaging.Filters.ContrastStretch();
                    filteredImage = stretcher.Apply(filteredImage);

                }

                if (Histogram)
                {
                    AForge.Imaging.Filters.HistogramEqualization histogrammer = new AForge.Imaging.Filters.HistogramEqualization();
                    filteredImage = histogrammer.Apply(filteredImage);

                }

                if (Gaussian)
                {
                    AForge.Imaging.Filters.GaussianBlur blurrer = new AForge.Imaging.Filters.GaussianBlur();
                    blurrer.Size = (int)GaussianStrength;
                    filteredImage = blurrer.Apply(filteredImage);
                }

                if (ContrastAdjustment)
                {
                    AForge.Imaging.Filters.ContrastCorrection contraster = new AForge.Imaging.Filters.ContrastCorrection();
                    contraster.Factor = (float)ContrastStrength;
                    filteredImage = contraster.Apply(filteredImage);
                }

                if (Greyscale)
                {
                    filteredImage = AForge.Imaging.Filters.Grayscale.CommonAlgorithms.BT709.Apply(filteredImage);
                    //Greyscale downgrades format
                    // filteredImage  = convertFormatTo32(filteredImage.InternalBitmap);
                }
                if (Threshold)
                {
                    //filteredImage.InternalBitmap = convertFormatToGS(filteredImage.InternalBitmap);
                    AForge.Imaging.Filters.Threshold thresholder = new AForge.Imaging.Filters.Threshold();
                    thresholder.ThresholdValue = (int)(((double)ThresholdStrength / 10.0) * 255.0);
                    filteredImage = thresholder.Apply(filteredImage);

                }
                if (Bradley)
                {
                    AForge.Imaging.Filters.BradleyLocalThresholding bradlifier = new AForge.Imaging.Filters.BradleyLocalThresholding();

                    filteredImage = bradlifier.Apply(filteredImage);

                }
            }

            return filteredImage;
        }
示例#11
0
        public bool ProcessImage(Bitmap bitmap)
        {
            // На вход поступает необработанное изображение с веб-камеры

            //  Минимальная сторона изображения (обычно это высота)
            if (bitmap.Height > bitmap.Width)
            {
                throw new Exception("К такой забавной камере меня жизнь не готовила!");
            }
            //  Можно было, конечено, и не кидаться эксепшенами в истерике, но идите и купите себе нормальную камеру!
            int side = bitmap.Height;

            //  Отпиливаем границы, но не более половины изображения
            if (side < 4 * settings.border)
            {
                settings.border = side / 4;
            }
            side -= 2 * settings.border;

            //  Мы сейчас занимаемся тем, что красиво оформляем входной кадр, чтобы вывести его на форму
            Rectangle cropRect = new Rectangle((bitmap.Width - bitmap.Height) / 2 + settings.left + settings.border, settings.top + settings.border, side, side);

            //  Тут создаём новый битмапчик, который будет исходным изображением
            original = new Bitmap(cropRect.Width, cropRect.Height);

            //  Объект для рисования создаём
            Graphics g = Graphics.FromImage(original);

            g.DrawImage(bitmap, new Rectangle(0, 0, original.Width, original.Height), cropRect, GraphicsUnit.Pixel);
            Pen p = new Pen(Color.Red);

            p.Width = 1;

            //  Теперь всю эту муть пилим в обработанное изображение
            AForge.Imaging.Filters.Grayscale grayFilter = new AForge.Imaging.Filters.Grayscale(0.2125, 0.7154, 0.0721);
            var uProcessed = grayFilter.Apply(AForge.Imaging.UnmanagedImage.FromManagedImage(original));


            int blockWidth  = original.Width / settings.blocksCount;
            int blockHeight = original.Height / settings.blocksCount;

            for (int r = 0; r < settings.blocksCount; ++r)
            {
                for (int c = 0; c < settings.blocksCount; ++c)
                {
                    //  Тут ещё обработку сделать
                    g.DrawRectangle(p, new Rectangle(c * blockWidth, r * blockHeight, blockWidth, blockHeight));
                }
            }


            //  Масштабируем изображение до 500x500 - этого достаточно
            AForge.Imaging.Filters.ResizeBilinear scaleFilter = new AForge.Imaging.Filters.ResizeBilinear(settings.orignalDesiredSize.Width, settings.orignalDesiredSize.Height);
            uProcessed = scaleFilter.Apply(uProcessed);
            original   = scaleFilter.Apply(original);
            g          = Graphics.FromImage(original);
            //  Пороговый фильтр применяем. Величина порога берётся из настроек, и меняется на форме
            AForge.Imaging.Filters.BradleyLocalThresholding threshldFilter = new AForge.Imaging.Filters.BradleyLocalThresholding();
            threshldFilter.PixelBrightnessDifferenceLimit = settings.differenceLim;
            threshldFilter.ApplyInPlace(uProcessed);


            if (settings.processImg)
            {
                string info = processSample(ref uProcessed);
                Font   f    = new Font(FontFamily.GenericSansSerif, 20);
                g.DrawString(info, f, Brushes.Black, 30, 30);
            }

            processed = uProcessed.ToManagedImage();

            return(true);
        }