public void TestGrayFilter24()
        {
            BMPImage image = new BMPImage("../../../TestFiles/input24.bmp");

            GrayFilter.Gray(image);
            image.WriteToFile("../../../TestFiles/output.bmp");
            FileAssert.AreEqual("../../../TestFiles/output.bmp", "../../../TestFiles/Gray24.bmp");
            Assert.Pass();
        }
        public static bool ApplyFilter(BitMapReading input, string filterName, string output)
        {
            uint width    = input.Width;
            uint height   = input.Height;
            int  channels = input.BitsPerPixel / 8;

            byte[][] image = input.Image;
            byte[][] filteredImage;

            switch (filterName)
            {
            case "GRAY":
                filteredImage = GrayFilter.ApplyFilter(width, height, channels, image);
                break;

            case "MEDIAN":
                filteredImage = MedianFilter.ApplyFilter(width, height, channels, image);
                break;

            case "GAUSS":
                filteredImage = ConvolutionFilters.GaussFilter(width, height, channels, image);
                break;

            case "SOBELX":
                filteredImage = ConvolutionFilters.SobelXFilter(width, height, channels, image);
                break;

            case "SOBELY":
                filteredImage = ConvolutionFilters.SobelYFilter(width, height, channels, image);
                break;

            case "SOBEL":
            case "SOBELXY":
                filteredImage = ConvolutionFilters.SobelFilter(width, height, channels, image);
                break;

            default:
                return(false);
            }

            try
            {
                new BitMapWriting(output, input.Header, filteredImage);
            }
            catch (Exception)
            {
                Console.WriteLine("Could not open\\create output file");
                Environment.Exit(3);
            }

            Console.WriteLine($"{filterName} filter was applied successfully");
            return(true);
        }
        static void Main(string[] args)
        {
            PrintDescription();

            if (args.Length != 3)
            {
                Console.WriteLine(
                    "Неверное количество аргументов. Формат: <программа> <имя_входного_файла> <название_фильтра> <имя выходного файла>");
                return;
            }

            string currentFilter = args[1];

            if (!currentFilter.Equals("median") && !currentFilter.Equals("gauss") && !currentFilter.Equals("sobelx") &&
                !currentFilter.Equals("sobely") && !currentFilter.Equals("gray"))
            {
                Console.WriteLine("Введённый фильтр не относится к списку доступных. Попробуйте ещё раз.");
                return;
            }

            FileStream fileIn;

            try
            {
                fileIn = new FileStream(args[0], FileMode.Open, FileAccess.ReadWrite);
            }
            catch (FileNotFoundException)
            {
                Console.WriteLine("Ошибка! Входной файл не был найден! Попробуйте ещё раз.");
                return;
            }

            FileStream fileOut;

            try
            {
                fileOut = new FileStream(args[2], FileMode.Create, FileAccess.ReadWrite);
            }
            catch (Exception)
            {
                fileIn.Close();
                Console.WriteLine("Ошибка! Не удалось создать/открыть выходной файл. Попробуйте ещё раз.");
                return;
            }

            BitMapFile file = new(fileIn);

            fileIn.Close();

            if (currentFilter.Equals("gray"))
            {
                Console.WriteLine("Выбран фильтр серого");
                GrayFilter.ApplyFilter(file);
            }
            else if (currentFilter.Equals("median"))
            {
                Console.WriteLine("Выбран усредняющий фильтр");
                MedianFilter.ApplyFilter(file);
            }
            else if (currentFilter.Equals("gauss"))
            {
                Console.WriteLine("Выбран фильтр Гаусса");
                GaussFilter.ApplyFilter(file);
            }
            else if (currentFilter.Equals("sobelx"))
            {
                Console.WriteLine("Выбран фильтр Собеля по X");
                SobelFilter.ApplyFilter(file, SobelFilter.Type.X);
            }
            else if (currentFilter.Equals("sobely"))
            {
                Console.WriteLine("Выбран фильтр Собеля по Y");
                SobelFilter.ApplyFilter(file, SobelFilter.Type.Y);
            }

            Console.WriteLine("Фильтр был успешно применён");

            file.WriteResult(fileOut);
            fileOut.Close();
        }
Example #4
0
        private void ApplyFilter(FilterType filterType, int windowSize = 0)
        {
            Invoke(new ArgUtils.Action(delegate
            {
                pictureBox2.Image = null;
            }));

            IFilter       filter       = null;
            IBinarization binarization = null;

            switch (filterType)
            {
            case FilterType.AdaptiveBinarization:
                binarization = new AdaptiveBinarizatoinFilter(UpdateProgtessBar);
                break;

            case FilterType.BinarizationByOtsu:
                binarization = new BinarizationByOtsu(UpdateProgtessBar);
                break;

            case FilterType.Gaus:
                filter = new GausFilter(windowSize, false, UpdateProgtessBar);
                break;

            case FilterType.Median:
                filter = new Filters.MedianFilter(windowSize, false, UpdateProgtessBar);
                break;

            case FilterType.Gray:
                filter = new GrayFilter();
                break;

            case FilterType.Edge:
                filter = new Filters.EdgeFilter();
                break;

            case FilterType.Sharpen:
                filter = new SharpenFilter();
                break;
            }

            var    bitmap = GetInitialBitmap();
            Bitmap result = null;

            Invoke(new ArgUtils.Action(delegate
            {
                progressBar1.Value = 0;
            }));

            if (filter != null)
            {
                result = filter.GetFilteredImage(bitmap);
            }
            else if (binarization != null)
            {
                result = binarization.GetBinaryImage(bitmap);
            }

            Invoke(new ArgUtils.Action(delegate
            {
                if (progressBar1.Value < 100)
                {
                    progressBar1.Value = 100;
                }
                pictureBox2.Image = result;
            }));
        }
 public GrayFilterOptions(GrayFilter filter)
 {
     _filter = filter;
     InitializeComponent();
 }
Example #6
0
 public static byte[][] SobelYFilter(uint width, uint height, int channels, byte[][] image)
 {
     image = GrayFilter.ApplyFilter(width, height, channels, image);
     double[] kernel = { -1, 0, 1, -2, 0, 2, -1, 0, 1 };
     return(Convolution(width, height, channels, image, kernel));
 }