Beispiel #1
0
        public mDitherStucki(byte thresholdValue)
        {
            BitmapType = BitmapTypes.GrayscaleBT709;

            ThresholdValue = thresholdValue;

            Effect = new StuckiDithering();
            Effect.ThresholdValue = ThresholdValue;

            filter = Effect;
        }
        private IErrorDiffusion GetDitheringInstance()
        {
            IErrorDiffusion result;

            if (floydSteinbergRadioButton.Checked)
            {
                result = new FloydSteinbergDithering();
            }
            else if (burkesRadioButton.Checked)
            {
                result = new BurksDithering();
            }
            else if (jarvisJudiceNinkeDitheringradioButton.Checked)
            {
                result = new JarvisJudiceNinkeDithering();
            }
            else if (stuckiRadioButton.Checked)
            {
                result = new StuckiDithering();
            }
            else if (sierra3RadioButton.Checked)
            {
                result = new Sierra3Dithering();
            }
            else if (sierra2RadioButton.Checked)
            {
                result = new Sierra2Dithering();
            }
            else if (sierraLiteRadioButton.Checked)
            {
                result = new SierraLiteDithering();
            }
            else if (atkinsonRadioButton.Checked)
            {
                result = new AtkinsonDithering();
            }
            else if (randomRadioButton.Checked)
            {
                result = new RandomDithering();
            }
            else
            {
                result = null;
            }

            return(result);
        }
        public void GenerateField(bool update_filters = false)
        {
            dominoes = new int[length, height];
            System.Drawing.Image i;
            if (!update_filters)
            {
                using (var bmpTemp = new System.Drawing.Bitmap(SourcePath))
                {
                    i = new System.Drawing.Bitmap(bmpTemp);
                }
            }
            else
            {
                i = ImageHelper.BitmapImageToBitmap(filters.preview);
            }
            if (length < 2)
            {
                m_length = 2;
            }
            if (height < 2)
            {
                m_height = 2;
            }
            System.Drawing.Bitmap   thumb    = new System.Drawing.Bitmap(length, height);
            System.Drawing.Graphics graphics = System.Drawing.Graphics.FromImage(thumb);
            graphics.Clear(System.Drawing.Color.White);
            if (ResizeMode == 0)
            {
                graphics.InterpolationMode = InterpolationMode.NearestNeighbor;
            }
            if (ResizeMode == 1)
            {
                graphics.InterpolationMode = InterpolationMode.Bicubic;
            }
            if (ResizeMode == 2)
            {
                graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
            }
            System.Drawing.Imaging.ImageAttributes attr = new System.Drawing.Imaging.ImageAttributes();
            System.Drawing.Imaging.ImageAttributes Att  = new System.Drawing.Imaging.ImageAttributes();
            Att.SetWrapMode(System.Drawing.Drawing2D.WrapMode.TileFlipXY);
            graphics.DrawImage(i, new System.Drawing.Rectangle(0, 0, length, height), 0, 0, i.Width, i.Height, System.Drawing.GraphicsUnit.Pixel, Att);
            //graphics.DrawImage(i, 0, 0, length, height);
            BitmapImage     bitmapImage = ImageHelper.BitmapToBitmapImage(thumb);
            BitmapSource    bitm        = new FormatConvertedBitmap(bitmapImage, PixelFormats.Bgr24, null, 0);
            WriteableBitmap b           = BitmapFactory.ConvertToPbgra32Format(bitm);

            IColorSpaceComparison comp;

            switch (ColorRegressionMode)
            {
            case 0: comp = new CmcComparison(); break;

            case 1: comp = new Cie1976Comparison(); break;

            case 2: comp = new Cie94Comparison(); break;

            default: comp = new CieDe2000Comparison(); break;
            }

            Dithering d;

            switch (DiffusionMode)
            {
            case 0: d = new NoDithering(comp, Colors); break;

            case 1: d = new FloydSteinbergDithering(comp, Colors); break;

            case 2: d = new JarvisJudiceNinkeDithering(comp, Colors); break;

            default: d = new StuckiDithering(comp, Colors); break;
            }
            dominoes = d.Dither(b, comp);

            b.Lock();
        }
Beispiel #4
0
        private void video_NewFrame1(object sender, NewFrameEventArgs eventArgs)
        {
            videoCapture.Stop();
            pictureBox1.SizeMode = PictureBoxSizeMode.CenterImage;
            pictureBox2.SizeMode = PictureBoxSizeMode.CenterImage;
            pictureBox1.Image    = (Bitmap)eventArgs.Frame.Clone();
            //pictureBox2.Image = (Bitmap)eventArgs.Frame.Clone();
            image          = (Bitmap)eventArgs.Frame.Clone();
            byte[,] matrix = new byte[4, 4]
            {
                { 95, 233, 127, 255 },
                { 159, 31, 191, 63 },
                { 111, 239, 79, 207 },
                { 175, 47, 143, 15 }
            };
            switch (choice)
            {
            case 0:
            {
            }
            break;

            //Threshold
            case 1:
            {
                Grayscale g = new Grayscale(0.2125, 0.7154, 0.0721);
                image = g.Apply(image);
                Threshold filter = new Threshold(100);
                applyfilter(filter);
            }
            break;

            //OrderedDithering
            case 2:
            {
                Grayscale g = new Grayscale(0.2125, 0.7154, 0.0721);
                image = g.Apply(image);
                OrderedDithering filter = new OrderedDithering(matrix);
                applyfilter(filter);
            }
            break;

            //BayerDithering
            case 3:
            {
                Grayscale g = new Grayscale(0.2125, 0.7154, 0.0721);
                image = g.Apply(image);
                BayerDithering filter = new BayerDithering();
                applyfilter(filter);
            }
            break;

            //floyd
            case 4:
            {
                Grayscale g = new Grayscale(0.2125, 0.7154, 0.0721);
                image = g.Apply(image);
                FloydSteinbergDithering filter = new FloydSteinbergDithering();
                applyfilter(filter);
            }
            break;

            //burkes
            case 5:
            {
                Grayscale g = new Grayscale(0.2125, 0.7154, 0.0721);
                image = g.Apply(image);
                BurkesDithering filter = new BurkesDithering();
                applyfilter(filter);
            }
            break;

            //jarvis
            case 6:
            {
                Grayscale g = new Grayscale(0.2125, 0.7154, 0.0721);
                image = g.Apply(image);
                JarvisJudiceNinkeDithering filter = new JarvisJudiceNinkeDithering();
                applyfilter(filter);
            }
            break;

            //sierra
            case 7:
            {
                Grayscale g = new Grayscale(0.2125, 0.7154, 0.0721);
                image = g.Apply(image);
                SierraDithering filter = new SierraDithering();
                applyfilter(filter);
            }
            break;

            //stucki
            case 8:
            {
                Grayscale g = new Grayscale(0.2125, 0.7154, 0.0721);
                image = g.Apply(image);
                StuckiDithering filter = new StuckiDithering();
                applyfilter(filter);
            }
            break;

            //Homogenity
            case 9:
            {
                Grayscale g = new Grayscale(0.2125, 0.7154, 0.0721);
                image = g.Apply(image);
                HomogenityEdgeDetector filter = new HomogenityEdgeDetector();
                applyfilter(filter);
            }
            break;

            //rotate
            case 10:
            {
                applyfilter(new RotateChannels());
            } break;

            //sobel
            case 11:
            {
                Grayscale g = new Grayscale(0.2125, 0.7154, 0.0721);
                image = g.Apply(image);
                SobelEdgeDetector filter = new SobelEdgeDetector();
                applyfilter(filter);
            }
            break;

            //canny
            case 12:
            {
                Grayscale g = new Grayscale(0.2125, 0.7154, 0.0721);
                image = g.Apply(image);
                CannyEdgeDetector filter = new CannyEdgeDetector();
                applyfilter(filter);
            }
            break;

            case 13:
            {
                applyfilter(new YCbCrFiltering());
            } break;

            case 14:
            {
                applyfilter(new HueModifier(180));
            } break;

            //SIS Threshold
            case 15:
            {
                Grayscale g = new Grayscale(0.2125, 0.7154, 0.0721);
                image = g.Apply(image);
                SISThreshold filter = new SISThreshold();
                applyfilter(filter);
            } break;

            //Difference
            case 16:
            {
                Grayscale g = new Grayscale(0.2125, 0.7154, 0.0721);
                image = g.Apply(image);
                DifferenceEdgeDetector filter = new DifferenceEdgeDetector();
                applyfilter(filter);
            } break;

            //mirror
            case 17:
            {
                applyfilter(new Mirror(false, true));
            } break;

            //flip
            case 18:
            {
                applyfilter(new RotateBilinear(180, true));
            } break;

            //Erosion
            case 19:
            {
                applyfilter1(new Erosion());
            } break;

            //Dilatation
            case 20:
            {
                applyfilter1(new Dilatation());
            } break;

            //Opening
            case 21:
            {
                applyfilter1(new Opening());
            } break;

            //closing
            case 22:
            {
                applyfilter1(new Closing());
            } break;

            //jitter
            case 23:
            {
                applyfilter(new Jitter(15));
            } break;

            //OilPainting
            case 24:
            {
                applyfilter(new OilPainting(10));
            } break;

            //pixellate
            case 25:
            {
                applyfilter(new Pixellate(10));
            } break;
            }
        }
Beispiel #5
0
        private IErrorDiffusion GetDitheringInstance()
        {
            IErrorDiffusion result;


            if (rb_FloySteinbergDither.Checked)
            {
                result = new FloydSteinbergDithering();
            }
            else if (rb_BurkesDither.Checked)
            {
                result = new BurksDithering();
            }
            else if (rb_JarvisJudiceDither.Checked)
            {
                result = new JarvisJudiceNinkeDithering();
            }
            else if (rb_StuckiDither.Checked)
            {
                result = new StuckiDithering();
            }
            else if (rb_SierraDither.Checked)
            {
                result = new Sierra3Dithering();
            }
            else if (rb_TwoRowSierraDither.Checked)
            {
                result = new Sierra2Dithering();
            }
            else if (rb_SierraLiteDither.Checked)
            {
                result = new SierraLiteDithering();
            }
            else if (rb_AtkinsonDither.Checked)
            {
                result = new AtkinsonDithering();
            }
            else if (rb_RandomNoiseDither.Checked)
            {
                result = new RandomDithering();
            }
            else if (rb_Bayer2Dither.Checked)
            {
                result = new Bayer2();
            }
            else if (rb_Bayer3Dither.Checked)
            {
                result = new Bayer3();
            }
            else if (rb_Bayer4Dither.Checked)
            {
                result = new Bayer4();
            }
            else if (rb_Bayer8Dither.Checked)
            {
                result = new Bayer8();
            }
            else
            {
                result = null;
            }

            return(result);
        }
Beispiel #6
0
        public static Bitmap ApplyFiliter(ImageFiliter imgFilter, Bitmap bmp, byte Value, byte Value2)
        {
            Bitmap newImage = null;

            //ContrastCorrection filter2 = new ContrastCorrection(1.0);
            //newImage = filter2.Apply(bmp);
            if (imgFilter != ImageFiliter.None)
            {
                IFilter filter3 = Grayscale.CommonAlgorithms.Y;
                newImage = filter3.Apply(bmp);

                if (imgFilter == ImageFiliter.Threshold)
                {
                    IFilter filter = null;
                    if (Value == 0)
                    {
                        filter = new Threshold();
                    }
                    else
                    {
                        filter = new Threshold(Value);
                    }
                    newImage = filter.Apply(newImage);

                    //IterativeThreshold filter = new IterativeThreshold(Value2, Value);
                    //// apply the filter
                    // newImage = filter.Apply(newImage);
                }
                if (imgFilter == ImageFiliter.ThresholdWithCarry)
                {
                    IFilter filter = new ThresholdWithCarry();
                    newImage = filter.Apply(newImage);
                }
                else if (imgFilter == ImageFiliter.OrderedDithering)
                {
                    IFilter filter = new OrderedDithering();
                    newImage = filter.Apply(newImage);
                }
                else if (imgFilter == ImageFiliter.BayerDithering)
                {
                    IFilter filter = new BayerDithering();
                    newImage = filter.Apply(newImage);
                }
                else if (imgFilter == ImageFiliter.FloydSteinbergDithering)
                {
                    IFilter filter = new FloydSteinbergDithering();
                    newImage = filter.Apply(newImage);
                }
                else if (imgFilter == ImageFiliter.BurkesDithering)
                {
                    IFilter filter = new BurkesDithering();
                    newImage = filter.Apply(newImage);
                }
                else if (imgFilter == ImageFiliter.JarvisJudiceNinkeDithering)
                {
                    IFilter filter = new JarvisJudiceNinkeDithering();
                    newImage = filter.Apply(newImage);
                }
                else if (imgFilter == ImageFiliter.SierraDithering)
                {
                    IFilter filter = new SierraDithering();
                    newImage = filter.Apply(newImage);
                }
                else if (imgFilter == ImageFiliter.StuckiDithering)
                {
                    IFilter filter = new StuckiDithering();
                    newImage = filter.Apply(newImage);
                }
                else if (imgFilter == ImageFiliter.Convolution)
                {
                    // create filter
                    //OtsuThreshold filter = new OtsuThreshold();
                    //// apply the filter
                    //filter.ApplyInPlace(newImage);

                    //// create filter
                    //IterativeThreshold filter = new IterativeThreshold(0);
                    //// apply the filter
                    //newImage = filter.Apply(newImage);

                    int[,] kernel =
                    {
                        { -2, -1, 0 },
                        { -1,  1, 1 },
                        {  0,  1, 2 }
                    };
                    // create filter
                    Convolution filter = new Convolution(kernel);
                    // apply the filter
                    filter.ApplyInPlace(newImage);
                }
                newImage = BitmapTo1Bpp(newImage);
            }
            else
            {
                newImage = BitmapTo1Bpp(bmp);
            }
            //轉換成 1bit bps
            return(newImage);
        }