public void GetWhitePixel()
        {
            originalPicture[0, 0] = new Pixel(200, 200, 200);
            resultPicture         = new BrightnessFilter().ChangeImage(originalPicture, 500);

            Assert.IsTrue(resultPicture[0, 0].Equals(new Pixel(255, 255, 255)));
        }
        private void ConfigurePreparedFilters()
        {
            PreparedFilter preset = (PreparedFilter)GetFieldValue(FieldType.PREPARED_FILTER_HIGHLIGHT);

            while (Filters.Count > 0)
            {
                Remove(Filters[0]);
            }
            switch (preset)
            {
            case PreparedFilter.TEXT_HIGHTLIGHT:
                Add(new HighlightFilter(this));
                break;

            case PreparedFilter.AREA_HIGHLIGHT:
                AbstractFilter bf = new BrightnessFilter(this);
                bf.Invert = true;
                Add(bf);
                bf        = new BlurFilter(this);
                bf.Invert = true;
                Add(bf);
                break;

            case PreparedFilter.GRAYSCALE:
                AbstractFilter f = new GrayscaleFilter(this);
                f.Invert = true;
                Add(f);
                break;

            case PreparedFilter.MAGNIFICATION:
                Add(new MagnifierFilter(this));
                break;
            }
        }
        public void GetDarkPixel()
        {
            originalPicture[0, 0] = new Pixel(10, 10, 10);
            resultPicture         = new BrightnessFilter().ChangeImage(originalPicture, 10);

            Assert.IsTrue(resultPicture[0, 0].Equals(new Pixel(1, 1, 1)));
        }
        private Bitmap RenderImage()
        {
            BrightnessFilter filter = new BrightnessFilter(valueTrackBar.Value);

            return(filter.ApplyFilter(new List <Bitmap>()
            {
                image
            }));
        }
示例#5
0
        private void УвеличитьЯркостьToolStripMenuItem_Click(object sender, EventArgs e)
        {
            var bm = new Bitmap(pictureBox1.Image);

            old_image = image;
            image     = bm;
            Filters filter = new BrightnessFilter();

            backgroundWorker1.RunWorkerAsync(filter);
        }
示例#6
0
 private static BrightnessFilter BrightnessForm(Bitmap bitmap, int value)
 {
     using (BrightnessForm form = new BrightnessForm(bitmap, value)) {
         if (form.ShowDialog() == DialogResult.OK)
         {
             BrightnessFilter newFilter = form.resultFilter;
             return(newFilter);
         }
         return(null);
     }
 }
        private void brightnessButtonClick(object sender, RoutedEventArgs e)
        {
            if (imageHandler != null)
            {
                // TODO Background worker
                new Thread(() =>
                {
                    int a = -100;
                    BrightnessFilter filter = new BrightnessFilter(a);
                    imageHandler.ApplyFilter(image => filter.ApplyFilter(image));

                    Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.ApplicationIdle, new Action(() =>
                    {
                        filteredImage.Source = BitmapLoader.loadBitmap(imageHandler.getFiltered());
                    }));
                }).Start();
            }
        }
示例#8
0
        public static bool ModifyFilter(int index)
        {
            Model.Node     selectedNode = ImageProcessingController.Instance.GetNode(index);
            AbstractFilter filter       = selectedNode.Filter;
            Type           t            = filter.GetType();

            /*
             #region Gaussian Blur Filter : Update
             * if (t == typeof(GaussianBlurFilter)) {
             *  GaussianBlurFilter updatedFilter = (GaussianBlurFilter)filter;
             *  updatedFilter = GaussianBlurForm(updatedFilter);
             *
             *  if (updatedFilter != null) {
             *      ImageProcessingController.Instance.GetNode(index).SetFilter(updatedFilter);
             *      return true;
             *  }
             * }
             #endregion
             *
             #region Gaussian Sharpen Filter : Update
             * if (t == typeof(GaussianSharpenFilter)) {
             *  GaussianSharpenFilter updatedFilter = (GaussianSharpenFilter)filter;
             *  updatedFilter = GaussianSharpenForm(updatedFilter);
             *
             *  if (updatedFilter != null) {
             *      ImageProcessingController.Instance.GetNode(index).SetFilter(updatedFilter);
             *      return true;
             *  }
             * }
             #endregion
             */

            /*
             #region Median Blur Filter : Update
             * if (t == typeof(MedianBlurFilter)) {
             *  MedianBlurFilter updatedFilter = (MedianBlurFilter)filter;
             *  updatedFilter = MedianBlurForm(updatedFilter);
             *
             *  if (updatedFilter != null) {
             *      ImageProcessingController.Instance.GetNode(index).SetFilter(updatedFilter);
             *      return true;
             *  }
             * }
             #endregion
             */

            #region Black White Filter : Update
            if (t == typeof(BlackWhiteFilter))
            {
                BlackWhiteFilter updatedFilter = (BlackWhiteFilter)filter;
                updatedFilter = BlackWhiteForm(selectedNode.Input, updatedFilter);

                if (updatedFilter != null)
                {
                    ImageProcessingController.Instance.GetNode(index).SetFilter(updatedFilter);
                    return(true);
                }
            }
            #endregion


            #region Brightness Filter
            if (t == typeof(BrightnessFilter))
            {
                BrightnessFilter updatedFilter = (BrightnessFilter)filter;
                updatedFilter = BrightnessForm(selectedNode.Input, updatedFilter.Value);

                if (updatedFilter != null)
                {
                    ImageProcessingController.Instance.GetNode(index).SetFilter(updatedFilter);
                    return(true);
                }
            }
            #endregion

            #region Contrast Filter
            if (t == typeof(ContrastFilter))
            {
                ContrastFilter oldFilter = (ContrastFilter)filter;
                AbstractFilter newFilter = ContrastForm(selectedNode.Input, oldFilter.Value);

                if (newFilter != null)
                {
                    ImageProcessingController.Instance.GetNode(index).SetFilter(newFilter);
                    return(true);
                }
            }
            #endregion

            #region Contrast Stretch Filter
            if (t == typeof(ContrastStretchFilter))
            {
                AbstractFilter updatedFilter = ContrastStretchForm(selectedNode.Input);

                if (updatedFilter != null)
                {
                    ImageProcessingController.Instance.GetNode(index).SetFilter(updatedFilter);
                    return(true);
                }
            }
            #endregion

            return(false);
        }
 private void okButton_Click(object sender, EventArgs e)
 {
     resultFilter = new BrightnessFilter(valueTrackBar.Value);
     DialogResult = DialogResult.OK;
 }