public void ParseNameAndProfile()
{
var filter = CodecFilter.Create(CallSyntax.Parse("codec(h264,high)"));
Assert.Equal("h264", filter.Name);
Assert.Equal("high", filter.Profile);
}
public void B()
{
var filter = UnknownFilter.Create(CallSyntax.Parse("starburst"));
Assert.Equal("starburst", filter.Name);
Assert.Empty(filter.Arguments);
}
public void A()
{
var filter = UnknownFilter.Create(CallSyntax.Parse("starburst(count:100)"));
Assert.Equal("starburst", filter.Name);
Assert.Equal("count", filter.Arguments[0].Name);
Assert.Equal("100", filter.Arguments[0].Value);
}
public void Parse2()
{
var filter = TimeFilter.Create(CallSyntax.Parse("time(110.777333s)"));
Assert.Equal(110.777333, filter.Value);
Assert.Equal("time(110.777333s)", filter.Canonicalize());
}
public void Parse()
{
var filter = TimeFilter.Create(CallSyntax.Parse("time(0.1s)"));
Assert.Equal(0.1, filter.Value);
Assert.Equal("time(0.1s)", filter.Canonicalize());
}
public void ParseNameProfileAndLevel_2()
{
var filter = CodecFilter.Create(CallSyntax.Parse("codec(h264,baseline,3)"));
Assert.Equal("h264", filter.Name);
Assert.Equal("baseline", filter.Profile);
Assert.Equal(3f, filter.Level);
}
public void ParseNameProfileAndLevel()
{
var filter = CodecFilter.Create(CallSyntax.Parse("codec(h264,high,4.1)"));
Assert.Equal("h264", filter.Name);
Assert.Equal("high", filter.Profile);
Assert.Equal(4.1f, filter.Level);
}
public void B()
{
var filter = QuantizeFilter.Create(CallSyntax.Parse("quantize(1,Octree,dither:1)"));
Assert.Equal(1, filter.MaxColors);
Assert.Equal("Octree", filter.Algorithm);
Assert.True(filter.Dither);
}
public void A()
{
var scale = ScaleTransform.Create(CallSyntax.Parse("scale(800,600)"));
Assert.Equal(800, scale.Width);
Assert.Equal(600, scale.Height);
Assert.Equal("scale(800,600,box)", scale.Canonicalize());
}
public void Parse2()
{
var filter = PaletteFilter.Create(CallSyntax.Parse("palette(10,hex8)"));
Assert.Equal(10, filter.Count);
Assert.Equal("hex8", filter.Format);
Assert.Equal("palette(10,hex8)", filter.ToString());
}
public void Parse1()
{
var filter = PaletteFilter.Create(CallSyntax.Parse("palette(256)"));
Assert.Equal(256, filter.Count);
Assert.Null(filter.Format);
Assert.Equal("palette(256)", filter.ToString());
}
public void A()
{
var filter = QuantizeFilter.Create(CallSyntax.Parse("quantize(256,algorithm:wu)"));
Assert.Equal(256, filter.MaxColors);
Assert.Equal("wu", filter.Algorithm);
Assert.Null(filter.Dither);
Assert.Equal("quantize(256,algorithm:wu)", filter.ToString());
}
public void FromFullKey()
{
var syntax = CallSyntax.Parse("text(Hello World,font:10px Helvetica,color:red)");
var draw = TextObject.Create(syntax);
Assert.Equal("Hello World", draw.Content);
Assert.Equal("red", draw.Color);
Assert.Equal("text(Hello World,color:red,font:Helvetica)", draw.ToString());
}
public void Shorthand2()
{
var pad = PadTransform.Create(CallSyntax.Parse("pad(10,20)"));
Assert.Equal(10, pad.Top);
Assert.Equal(20, pad.Right);
Assert.Equal(10, pad.Bottom);
Assert.Equal(20, pad.Left);
Assert.Equal("pad(10,20)", pad.Canonicalize());
}
public void A()
{
var pad = PadTransform.Create(CallSyntax.Parse("pad(1,2,3,4)"));
Assert.Equal(1, pad.Top);
Assert.Equal(2, pad.Right);
Assert.Equal(3, pad.Bottom);
Assert.Equal(4, pad.Left);
Assert.Equal("pad(1,2,3,4)", pad.Canonicalize());
}
public void B()
{
var scale = new ScaleTransform(800, 600, InterpolaterMode.Lanczos3);
Assert.Equal("scale(800,600,lanczos3)", scale.Canonicalize());
scale = ScaleTransform.Create(CallSyntax.Parse(scale.Canonicalize()));
Assert.Equal(800, scale.Width);
Assert.Equal(600, scale.Height);
Assert.Equal(InterpolaterMode.Lanczos3, scale.Mode);
}
public static Shape Parse(string text)
{
var syntax = CallSyntax.Parse(text);
switch (syntax.Name)
{
case "circle": return(Circle.Create(syntax));
case "image": return(ImageSource.Create(syntax));
case "path": return(PathShape.Create(syntax));
case "rectangle": return(Rect.Create(syntax));
case "square": return(Rect.Create(syntax));
case "text": return(TextObject.Create(syntax));
}
throw new Exception("Invalid Command:" + syntax.Name);
}
public void Parse()
{
var filter = SepiaFilter.Create(CallSyntax.Parse("sepia(0.5)"));
Assert.Equal(0.5, filter.Amount);
}
public void ThrowsOnInvalidLevel()
{
Assert.Throws <FormatException>(() => CodecFilter.Create(CallSyntax.Parse("codec(h264,high,a)")));
}
public void ParseName()
{
var filter = CodecFilter.Create(CallSyntax.Parse("codec(vp9)"));
Assert.Equal("vp9", filter.Name);
}
// Assert.Equal(360, Rotate.Parse("rotate(1rad)").Angle);
private static RotateTransform Parse(string text)
{
return(RotateTransform.Create(CallSyntax.Parse(text)));
}
public Call(CallSyntax syntax, Package containingPackage, Expression expression, IEnumerable <Expression> arguments)
: base(syntax, containingPackage)
{
Expression = expression;
Arguments = arguments.ToList();
}
public void SupportsPercentageUnit()
{
var filter = SepiaFilter.Create(CallSyntax.Parse("sepia(50%)"));
Assert.Equal(0.5, filter.Amount);
}
public void ClampsWhenGreaterThan100P()
{
var filter = SepiaFilter.Create(CallSyntax.Parse("sepia(101%)"));
Assert.Equal(1, filter.Amount);
}
public void ThrowsWhenGreaterThan10x()
{
Assert.Throws <ArgumentOutOfRangeException>(() => ContrastFilter.Create(CallSyntax.Parse("contrast(-1001%)")));
Assert.Throws <ArgumentOutOfRangeException>(() => ContrastFilter.Create(CallSyntax.Parse("contrast(1001%)")));
}
public void A()
{
var scale = PageFilter.Create(CallSyntax.Parse("page(11)"));
Assert.Equal("page(11)", scale.Canonicalize());
}
public void Parse()
{
var filter = ContrastFilter.Create(CallSyntax.Parse("contrast(0.5)"));
Assert.Equal(0.5, filter.Amount);
}
public static IProcessor Parse(string text)
{
var syntax = CallSyntax.Parse(text);
switch (syntax.Name)
{
// transforms
case "resize": return(ResizeTransform.Parse(text));
case "scale": return(ScaleTransform.Create(syntax));
case "crop": return(CropTransform.Create(syntax));
case "rotate": return(RotateTransform.Create(syntax));
case "flip": return(FlipTransform.Create(syntax));
case "orient": return(OrientTransform.Create(syntax));
case "pad": return(PadTransform.Create(syntax));
case "page": return(PageFilter.Create(syntax));
case "frame": return(FrameFilter.Create(syntax));
case "timestamp": return(TimestampFilter.Create(syntax));
case "background": return(BackgroundFilter.Create(syntax));
// web filters
case "blur": return(BlurFilter.Create(syntax));
case "brightness": return(BrightnessFilter.Create(syntax));
case "contrast": return(ContrastFilter.Create(syntax));
case "grayscale": return(GrayscaleFilter.Create(syntax));
case "rotateHue": return(HueRotateFilter.Create(syntax));
case "hueRotate": return(HueRotateFilter.Create(syntax));
case "hue-rotate": return(HueRotateFilter.Create(syntax));
case "invert": return(InvertFilter.Create(syntax));
case "opacity": return(OpacityFilter.Create(syntax));
case "saturate": return(SaturateFilter.Create(syntax));
case "sepia": return(SepiaFilter.Create(syntax));
// other filters
case "highlight": return(HighlightFilter.Create(syntax));
case "gamma": return(GammaFilter.Create(syntax));
case "halftone": return(HalftoneFilter.Create(syntax));
case "pixelate": return(PixelateFilter.Create(syntax));
case "quantize": return(QuantizeFilter.Create(syntax));
case "sharpen": return(SharpenFilter.Create(syntax));
case "vibrance": return(VibranceFilter.Create(syntax));
case "detect": return(DetectFilter.Create(syntax));
// Audio Filters
case "volume": return(VolumeFilter.Create(syntax));
// Container Filters
case "bitrate": return(BitRateFilter.Create(syntax));
// Drawing
case "draw": return(DrawCommand.Parse(text.AsSpan()));
// Other
case "colors": return(ColorsFilter.Create(syntax));
case "metadata": return(MetadataFilter.Parse(text));
case "quality": return(QualityFilter.Create(syntax));
case "expires": return(ExpiresFilter.Create(syntax));
case "tune": return(TuneFilter.Create(syntax));
case "profile": return(ProfileFilter.Create(syntax));
case "preset": return(PresetFilter.Create(syntax));
// Flags
case "lossless": return(LosslessFlag.Default);
case "poster": return(FrameFilter.Poster);
case "debug": return(DebugFilter.Default);
default:
// JPEG::encode
if (text.Contains("encode"))
{
return(EncodeParameters.Parse(text));
}
else
{
return(CustomFilter.Create(syntax));
}
}
}
public void ThrowsWheNegtive()
{
Assert.Throws <ArgumentOutOfRangeException>(() => SepiaFilter.Create(CallSyntax.Parse("sepia(-1%)")));
}
public void SupportsPercentageUnit()
{
var filter = ContrastFilter.Create(CallSyntax.Parse("contrast(50%)"));
Assert.Equal(0.5, filter.Amount);
}
