public FreshEffect()
        {
            var globalCurve = new Curve(CurveInterpolation.NaturalCubicSpline)
            {
                Points = new[]
                {
                    new Point(0, 0),
                    new Point(167, 195),
                    new Point(255, 255),
                }
            };

            var redCurve = new Curve(CurveInterpolation.NaturalCubicSpline)
            {
                Points = new[]
                {
                    new Point(0, 19),
                    new Point(147, 116),
                    new Point(184, 184),
                    new Point(255, 255)
                }
            };

            var greenCurve = new Curve(CurveInterpolation.NaturalCubicSpline)
            {
                Points = new[]
                {
                    new Point(0, 0),
                    new Point(142, 133),
                    new Point(183, 183),
                    new Point(255, 255)
                }
            };

            var blueCurve = new Curve(CurveInterpolation.NaturalCubicSpline)
            {
                Points = new[]
                {
                    new Point(0, 0),
                    new Point(155, 130),
                    new Point(205, 181),
                    new Point(255, 255)
                }
            };

            LayerList = new LayerList()
            {
                new AdjustmentLayer(LayerStyle.Normal(), new ContrastEffect(0.2)),
                new AdjustmentLayer(LayerStyle.Normal(), new CurvesEffect(globalCurve)),
                new AdjustmentLayer(LayerStyle.Darken(), new CurvesEffect(redCurve, greenCurve, blueCurve))
            };
        }
Example #2
0
        public OpalEffect()
        {
            m_cachingEffect = new CachingEffect();
            var clarityList = new LayerList(
                new AdjustmentLayer(LayerStyle.Normal(), m_cachingEffect),
                new AdjustmentLayer(LayerStyle.Softlight(), new SDKTestApp_Native.HighpassEffect(100, true, 8))
                );

            m_selectiveColorEffect = new SelectiveColorEffect
            {
                Red = new CMYK {
                    Yellow = 5
                },
                Yellow = new CMYK {
                    Yellow = 40, Key = 15
                },
                Green = new CMYK {
                    Cyan = 20, Yellow = 20, Key = 30
                },
                Cyan = new CMYK {
                    Key = 61
                },
                Blue = new CMYK {
                    Key = 30
                }
            };

            LayerList.AddRange(

                // Clarity
                new Layer(LayerStyle.Darken(0.5), context => clarityList.ToImageProvider(context.BackgroundImage, context.HintedRenderSize)),
                new AdjustmentLayer(LayerStyle.Normal(), m_selectiveColorEffect),

                new AdjustmentLayer(LayerStyle.Normal(), new HueSaturationEffect(0.0, 0.06)),
                new AdjustmentLayer(LayerStyle.Normal(), new VibranceEffect()
            {
                Level = 0.1
            }),

                new Layer(LayerStyle.Overlay(), context => new ColorImageSource(context.HintedRenderSize, Color.FromArgb(0xFF, 0xFF, 0xE6, 0x99)))
                );

            /*            Editors.Add(new RangeEditorViewModel<OpalEffect>("SaturationLevel", -1.0, 1.0, this, filter => filter.SaturationLevel, (filter, value) => filter.SaturationLevel = value));
             *          //    Editors.Add(new RangeEditorViewModel<OpalEffect>("ContrastLevel", -1.0, 1.0, this, filter => filter.ContrastLevel, (filter, value) => filter.ContrastLevel = value));
             *          Editors.Add(new RangeEditorViewModel<OpalEffect>("VibranceLevel", 0, 1.0, this, filter => filter.VibranceLevel, (filter, value) => filter.VibranceLevel = value));
             *          Editors.Add(new RangeEditorViewModel<OpalEffect>("ShadowsHue", 0, 365, this, filter => filter.ShadowsHue, (filter, value) => filter.ShadowsHue = (int)value));
             *          Editors.Add(new RangeEditorViewModel<OpalEffect>("ShadowsSaturation", 0, 100, this, filter => filter.ShadowsSaturation, (filter, value) => filter.ShadowsSaturation = (int)value));
             *          Editors.Add(new RangeEditorViewModel<OpalEffect>("HighlightsHue", 0, 365, this, filter => filter.HighlightsHue, (filter, value) => filter.HighlightsHue = (int)value));
             *          Editors.Add(new RangeEditorViewModel<OpalEffect>("HighlightsSaturation", 0, 100, this, filter => filter.HighlightsSaturation, (filter, value) => filter.HighlightsSaturation = (int)value));
             */
        }
Example #3
0
 public void FactoryMethodsGiveCorrectBlendFunction()
 {
     Assert.AreEqual(BlendFunction.Normal, LayerStyle.Normal().BlendFunction);
     Assert.AreEqual(BlendFunction.Add, LayerStyle.Add().BlendFunction);
     Assert.AreEqual(BlendFunction.Color, LayerStyle.Color().BlendFunction);
     Assert.AreEqual(BlendFunction.Colorburn, LayerStyle.Colorburn().BlendFunction);
     Assert.AreEqual(BlendFunction.Colordodge, LayerStyle.Colordodge().BlendFunction);
     Assert.AreEqual(BlendFunction.Darken, LayerStyle.Darken().BlendFunction);
     Assert.AreEqual(BlendFunction.Difference, LayerStyle.Difference().BlendFunction);
     Assert.AreEqual(BlendFunction.Exclusion, LayerStyle.Exclusion().BlendFunction);
     Assert.AreEqual(BlendFunction.Hardlight, LayerStyle.Hardlight().BlendFunction);
     Assert.AreEqual(BlendFunction.Hue, LayerStyle.Hue().BlendFunction);
     Assert.AreEqual(BlendFunction.Lighten, LayerStyle.Lighten().BlendFunction);
     Assert.AreEqual(BlendFunction.Lineardodge, LayerStyle.Lineardodge().BlendFunction);
     Assert.AreEqual(BlendFunction.Linearlight, LayerStyle.Linearlight().BlendFunction);
     Assert.AreEqual(BlendFunction.Multiply, LayerStyle.Multiply().BlendFunction);
     Assert.AreEqual(BlendFunction.Overlay, LayerStyle.Overlay().BlendFunction);
     Assert.AreEqual(BlendFunction.Screen, LayerStyle.Screen().BlendFunction);
     Assert.AreEqual(BlendFunction.Softlight, LayerStyle.Softlight().BlendFunction);
     Assert.AreEqual(BlendFunction.Vividlight, LayerStyle.Vividlight().BlendFunction);
 }
Example #4
0
 public void FactoryMethodsGiveCorrectOpacity()
 {
     Assert.AreEqual(0.4, LayerStyle.Normal(0.4).Opacity);
     Assert.AreEqual(0.4, LayerStyle.Add(0.4).Opacity);
     Assert.AreEqual(0.4, LayerStyle.Color(0.4).Opacity);
     Assert.AreEqual(0.4, LayerStyle.Colorburn(0.4).Opacity);
     Assert.AreEqual(0.4, LayerStyle.Colordodge(0.4).Opacity);
     Assert.AreEqual(0.4, LayerStyle.Darken(0.4).Opacity);
     Assert.AreEqual(0.4, LayerStyle.Difference(0.4).Opacity);
     Assert.AreEqual(0.4, LayerStyle.Exclusion(0.4).Opacity);
     Assert.AreEqual(0.4, LayerStyle.Hardlight(0.4).Opacity);
     Assert.AreEqual(0.4, LayerStyle.Hue(0.4).Opacity);
     Assert.AreEqual(0.4, LayerStyle.Lighten(0.4).Opacity);
     Assert.AreEqual(0.4, LayerStyle.Lineardodge(0.4).Opacity);
     Assert.AreEqual(0.4, LayerStyle.Linearlight(0.4).Opacity);
     Assert.AreEqual(0.4, LayerStyle.Multiply(0.4).Opacity);
     Assert.AreEqual(0.4, LayerStyle.Overlay(0.4).Opacity);
     Assert.AreEqual(0.4, LayerStyle.Screen(0.4).Opacity);
     Assert.AreEqual(0.4, LayerStyle.Softlight(0.4).Opacity);
     Assert.AreEqual(0.4, LayerStyle.Vividlight(0.4).Opacity);
 }
Example #5
0
        public void FactoryMethodsGiveCorrectTargetArea()
        {
            Rect rect = new Rect(1, 2, 3, 4);

            Assert.AreEqual(rect, LayerStyle.Normal(1.0, null, rect).TargetArea);
            Assert.AreEqual(rect, LayerStyle.Add(1.0, null, rect).TargetArea);
            Assert.AreEqual(rect, LayerStyle.Color(1.0, null, rect).TargetArea);
            Assert.AreEqual(rect, LayerStyle.Colorburn(1.0, null, rect).TargetArea);
            Assert.AreEqual(rect, LayerStyle.Colordodge(1.0, null, rect).TargetArea);
            Assert.AreEqual(rect, LayerStyle.Darken(1.0, null, rect).TargetArea);
            Assert.AreEqual(rect, LayerStyle.Difference(1.0, null, rect).TargetArea);
            Assert.AreEqual(rect, LayerStyle.Exclusion(1.0, null, rect).TargetArea);
            Assert.AreEqual(rect, LayerStyle.Hardlight(1.0, null, rect).TargetArea);
            Assert.AreEqual(rect, LayerStyle.Hue(1.0, null, rect).TargetArea);
            Assert.AreEqual(rect, LayerStyle.Lighten(1.0, null, rect).TargetArea);
            Assert.AreEqual(rect, LayerStyle.Lineardodge(1.0, null, rect).TargetArea);
            Assert.AreEqual(rect, LayerStyle.Linearlight(1.0, null, rect).TargetArea);
            Assert.AreEqual(rect, LayerStyle.Multiply(1.0, null, rect).TargetArea);
            Assert.AreEqual(rect, LayerStyle.Overlay(1.0, null, rect).TargetArea);
            Assert.AreEqual(rect, LayerStyle.Screen(1.0, null, rect).TargetArea);
            Assert.AreEqual(rect, LayerStyle.Softlight(1.0, null, rect).TargetArea);
            Assert.AreEqual(rect, LayerStyle.Vividlight(1.0, null, rect).TargetArea);
        }
Example #6
0
        public void FactoryMethodsGiveCorrectMask()
        {
            var mask = new ColorImageSource(new Size(100, 100), Colors.AliceBlue);

            Assert.AreSame(mask, LayerStyle.Normal(1.0, mask).MaskResolver(null).Result);
            Assert.AreSame(mask, LayerStyle.Add(1.0, mask).MaskResolver(null).Result);
            Assert.AreSame(mask, LayerStyle.Color(1.0, mask).MaskResolver(null).Result);
            Assert.AreSame(mask, LayerStyle.Colorburn(1.0, mask).MaskResolver(null).Result);
            Assert.AreSame(mask, LayerStyle.Colordodge(1.0, mask).MaskResolver(null).Result);
            Assert.AreSame(mask, LayerStyle.Darken(1.0, mask).MaskResolver(null).Result);
            Assert.AreSame(mask, LayerStyle.Difference(1.0, mask).MaskResolver(null).Result);
            Assert.AreSame(mask, LayerStyle.Exclusion(1.0, mask).MaskResolver(null).Result);
            Assert.AreSame(mask, LayerStyle.Hardlight(1.0, mask).MaskResolver(null).Result);
            Assert.AreSame(mask, LayerStyle.Hue(1.0, mask).MaskResolver(null).Result);
            Assert.AreSame(mask, LayerStyle.Lighten(1.0, mask).MaskResolver(null).Result);
            Assert.AreSame(mask, LayerStyle.Lineardodge(1.0, mask).MaskResolver(null).Result);
            Assert.AreSame(mask, LayerStyle.Linearlight(1.0, mask).MaskResolver(null).Result);
            Assert.AreSame(mask, LayerStyle.Multiply(1.0, mask).MaskResolver(null).Result);
            Assert.AreSame(mask, LayerStyle.Overlay(1.0, mask).MaskResolver(null).Result);
            Assert.AreSame(mask, LayerStyle.Screen(1.0, mask).MaskResolver(null).Result);
            Assert.AreSame(mask, LayerStyle.Softlight(1.0, mask).MaskResolver(null).Result);
            Assert.AreSame(mask, LayerStyle.Vividlight(1.0, mask).MaskResolver(null).Result);
        }
        public QuartzEffect()
        {
            m_cachingEffect = new CachingEffect();

            var curve = new Curve();

            curve.SetPoint(16, 7);
            curve.SetPoint(39, 24);
            curve.SetPoint(208, 223);
            curve.SetPoint(234, 247);

            var positiveBrightnessCurve = new Curve(CurveInterpolation.Linear, new[]
            {
                new Point(48, 124),
                new Point(64, 162),
                new Point(80, 193),
                new Point(96, 214),
                new Point(112, 229),
                new Point(128, 239),
                new Point(144, 245),
                new Point(160, 249),
                new Point(192, 253),
                new Point(240, 255)
            });

            var negativeBrightnessCurve = new Curve(CurveInterpolation.Linear, new[]
            {
                new Point(160, 63),
                new Point(192, 79),
                new Point(208, 90),
                new Point(224, 106),
                new Point(236, 123),
                new Point(244, 141),
                new Point(248, 156),
                new Point(252, 183)
            });

            var brightnessCurve = Curve.Interpolate(new Curve(), positiveBrightnessCurve, 0.1, null);

            var clarityList = new LayerList(
                new AdjustmentLayer(LayerStyle.Normal(), m_cachingEffect),
                new AdjustmentLayer(LayerStyle.Softlight(), new SDKTestApp_Native.HighpassEffect(100, true, 8))
                );

            LayerList.AddRange(
                new AdjustmentLayer(LayerStyle.Normal(), new CurvesEffect(curve)),
                new AdjustmentLayer(LayerStyle.Normal(), new CurvesEffect(brightnessCurve)),

                // Clarity
                new Layer(LayerStyle.Darken(), context => clarityList.ToImageProvider(context.BackgroundImage, context.HintedRenderSize)),

                new AdjustmentLayer(LayerStyle.Normal(), new HueSaturationEffect(0, 0.65 - 1)),
                new AdjustmentLayer(LayerStyle.Normal(), new VibranceEffect()
            {
                Level = 0.1
            }),
                new AdjustmentLayer(LayerStyle.Normal(), new SDKTestApp_Native.SplitToneEffect()
            {
                HighlightsSaturation = 42, HighlightsHue = 45
            })
                );
        }
Example #8
0
        public GlamMeLomoEffect()
        {
            var globalCurve = new Curve(CurveInterpolation.NaturalCubicSpline, new[]
            {
                new Point(0, 0),
                new Point(41, 59),
                new Point(112, 146),
                new Point(189, 211),
                new Point(255, 255)
            });

            var redCurve = new Curve(CurveInterpolation.NaturalCubicSpline, new[]
            {
                new Point(0, 0),
                new Point(101, 45),
                new Point(191, 193),
                new Point(255, 255)
            });

            Curve.Compose(redCurve, globalCurve, redCurve);

            var greenCurve = new Curve(CurveInterpolation.NaturalCubicSpline, new[]
            {
                new Point(0, 0),
                new Point(78, 61),
                new Point(187, 199),
                new Point(255, 255)
            });

            Curve.Compose(greenCurve, globalCurve, greenCurve);

            var blueCurve = new Curve(CurveInterpolation.NaturalCubicSpline, new[]
            {
                new Point(0, 0),
                new Point(56, 71),
                new Point(204, 181),
                new Point(255, 255)
            });

            Curve.Compose(blueCurve, globalCurve, blueCurve);

            var linearGradient = new LinearGradient
            {
                StartPoint = new Point(0.0, 0.5),
                EndPoint   = new Point(1.0, 0.5),

                Stops = new[]
                {
                    new GradientStop {
                        Offset = 0, Color = Color.FromArgb(255, 135, 135, 135)
                    },
                    new GradientStop {
                        Offset = 1.0, Color = Color.FromArgb(255, 193, 193, 193)
                    }
                }
            };

            var vignetteGradient = new RadialGradient
            {
                CenterPoint   = new Point(0.5, 0.5),
                EllipseRadius = new EllipseRadius(2.0, 0),
                Stops         = new[]
                {
                    new GradientStop {
                        Offset = 0, Color = Color.FromArgb(0, 255, 255, 255)
                    },
                    new GradientStop {
                        Offset = 0.9, Color = Color.FromArgb(255, 0, 0, 0)
                    }
                }
            };

            var vignette2Gradient = new RadialGradient
            {
                CenterPoint   = new Point(0.5, 0.5),
                EllipseRadius = new EllipseRadius(1.0, 0),
                Stops         = new[]
                {
                    new GradientStop {
                        Offset = 0, Color = Color.FromArgb(0, 0, 0, 0)
                    },
                    new GradientStop {
                        Offset = 0.5, Color = Color.FromArgb(0, 0, 0, 0)
                    },
                    new GradientStop {
                        Offset = 1.0, Color = Color.FromArgb(255, 0, 0, 0)
                    }
                }
            };

            LayerList = new LayerList()
            {
                new AdjustmentLayer(LayerStyle.Normal(), new CurvesEffect(redCurve, greenCurve, blueCurve)),
                new Layer(LayerStyle.Overlay(), context => new GradientImageSource(context.BackgroundLayer.ImageSize, linearGradient)),
                new Layer(LayerStyle.Softlight(0.4), context => new GradientImageSource(context.BackgroundLayer.ImageSize, vignetteGradient)),
                new Layer(LayerStyle.Darken(0.5), context => new GradientImageSource(context.BackgroundLayer.ImageSize, vignette2Gradient))
            };
        }