public static void DefinesThatNeedToBeSetBeforeReadingAnImage()
{
MagickReadSettings settings = new MagickReadSettings();
// Set define that tells the jpeg coder that the output image will be 32x32
settings.SetDefine(MagickFormat.Jpeg, "size", "32x32");
// Read image from file
using (MagickImage image = new MagickImage(SampleFiles.SnakewareJpg))
{
// Create thumnail that is 32 pixels wide and 32 pixels high
image.Thumbnail(32, 32);
// Save image as tiff
image.Write(SampleFiles.OutputDirectory + "Snakeware.tiff");
}
}
public void Test_Collection_Read()
{
using (MagickImageCollection collection = new MagickImageCollection())
{
MagickReadSettings settings = new MagickReadSettings();
settings.Density = new Density(150);
collection.Read(Files.RoseSparkleGIF, settings);
Assert.AreEqual(150, collection[0].Density.X);
settings = new MagickReadSettings();
settings.FrameIndex = 1;
collection.Read(Files.RoseSparkleGIF, settings);
Assert.AreEqual(1, collection.Count);
settings = new MagickReadSettings();
settings.FrameIndex = 1;
settings.FrameCount = 2;
collection.Read(Files.RoseSparkleGIF, settings);
Assert.AreEqual(2, collection.Count);
settings = null;
collection.Read(Files.RoseSparkleGIF, settings);
}
}
public void Test_Constructor()
{
ExceptionAssert.Throws<ArgumentNullException>(() =>
{
MagickReadSettings settings = new MagickReadSettings(null);
});
}
public void Test_Disabled()
{
using (MemoryStream memStream = new MemoryStream())
{
using (StreamWriter writer = new StreamWriter(memStream))
{
writer.Write(@"
<?xml version=""1.0"" encoding=""UTF-8""?>
<image>
<read filename=""/tmp/text.gif"" />
</image>");
writer.Flush();
memStream.Position = 0;
using (MagickImage image = new MagickImage())
{
MagickReadSettings readSettings = new MagickReadSettings()
{
Format = MagickFormat.Msl
};
ExceptionAssert.Throws<MagickPolicyErrorException>(delegate ()
{
image.Read(memStream, readSettings);
});
}
}
}
}
private MagickReadSettings CreateMagickReadSettings(XmlElement element)
{
if (element == null)
return null;
MagickReadSettings result = new MagickReadSettings();
result.ColorSpace = Variables.GetValue<Nullable<ColorSpace>>(element, "colorSpace");
result.Defines = CreateIReadDefines(element["defines"]);
result.Density = Variables.GetValue<Nullable<PointD>>(element, "density");
result.Format = Variables.GetValue<Nullable<MagickFormat>>(element, "format");
result.FrameCount = Variables.GetValue<Nullable<Int32>>(element, "frameCount");
result.FrameIndex = Variables.GetValue<Nullable<Int32>>(element, "frameIndex");
result.Height = Variables.GetValue<Nullable<Int32>>(element, "height");
result.PixelStorage = CreatePixelStorageSettings(element["pixelStorage"]);
result.UseMonochrome = Variables.GetValue<Nullable<Boolean>>(element, "useMonochrome");
result.Width = Variables.GetValue<Nullable<Int32>>(element, "width");
XmlElement setDefine = (XmlElement)element.SelectSingleNode("setDefine");
if (setDefine != null)
{
MagickFormat format_ = XmlHelper.GetAttribute<MagickFormat>(setDefine, "format");
String name_ = XmlHelper.GetAttribute<String>(setDefine, "name");
String value_ = XmlHelper.GetAttribute<String>(setDefine, "value");
result.SetDefine(format_,name_,value_);
}
return result;
}
public static void ConvertPDFTOneImage()
{
MagickReadSettings settings = new MagickReadSettings();
// Settings the density to 300 dpi will create an image with a better quality
settings.Density = new PointD(300, 300);
using (MagickImageCollection images = new MagickImageCollection())
{
// Add all the pages of the pdf file to the collection
images.Read(SampleFiles.SnakewarePdf, settings);
// Create new image that appends all the pages horizontally
using (MagickImage horizontal = images.AppendHorizontally())
{
// Save result as a png
horizontal.Write(SampleFiles.OutputDirectory + "Snakeware.horizontal.png");
}
// Create new image that appends all the pages horizontally
using (MagickImage vertical = images.AppendVertically())
{
// Save result as a png
vertical.Write(SampleFiles.OutputDirectory + "Snakeware.vertical.png");
}
}
}
public void Test_AlphaUnblend()
{
MagickReadSettings settings = new MagickReadSettings()
{
Defines = new PsdReadDefines()
{
AlphaUnblend = false
}
};
using (MagickImage image = new MagickImage())
{
image.Read(Files.Coders.PlayerPSD, settings);
string define = image.Settings.GetDefine(MagickFormat.Psd, "alpha-unblend");
Assert.AreEqual("False", define);
}
using (MagickImage image = new MagickImage())
{
settings.Defines = new PsdReadDefines()
{
AlphaUnblend = true
};
image.Read(Files.Coders.PlayerPSD, settings);
string define = image.Settings.GetDefine(MagickFormat.Psd, "alpha-unblend");
Assert.IsNull(define);
}
}
public static void ConvertImageFromOneFormatToAnother()
{
// Read first frame of gif image
using (MagickImage image = new MagickImage(SampleFiles.SnakewareGif))
{
// Save frame as jpg
image.Write(SampleFiles.OutputDirectory + "Snakeware.jpg");
}
MagickReadSettings settings = new MagickReadSettings();
// Tells the xc: reader the image to create should be 800x600
settings.Width = 800;
settings.Height = 600;
using (MemoryStream memStream = new MemoryStream())
{
// Create image that is completely purple and 800x600
using (MagickImage image = new MagickImage("xc:purple", settings))
{
// Sets the output format to png
image.Format = MagickFormat.Png;
// Write the image to the memorystream
image.Write(memStream);
}
}
// Read image from file
using (MagickImage image = new MagickImage(SampleFiles.SnakewarePng))
{
// Sets the output format to jpeg
image.Format = MagickFormat.Jpeg;
// Create byte array that contains a jpeg file
byte[] data = image.ToByteArray();
}
}
public void Test_Disabled()
{
using (MemoryStream memStream = new MemoryStream())
{
using (StreamWriter writer = new StreamWriter(memStream))
{
writer.Write(@"push graphic-context
viewbox 0 0 640 480
image over 0,0 0,0 ""label:Magick.NET""
pop graphic-context");
writer.Flush();
memStream.Position = 0;
using (MagickImage image = new MagickImage())
{
ExceptionAssert.Throws<MagickMissingDelegateErrorException>(delegate ()
{
image.Read(memStream);
});
ExceptionAssert.Throws<MagickPolicyErrorException>(delegate ()
{
MagickReadSettings settings = new MagickReadSettings()
{
Format = MagickFormat.Mvg
};
image.Read(memStream, settings);
});
}
}
}
}
public void Test_Image_Exceptions()
{
ExceptionAssert.Throws<ArgumentException>(delegate ()
{
MagickReadSettings settings = new MagickReadSettings();
settings.FrameCount = 2;
new MagickImage(Files.RoseSparkleGIF, settings);
});
}
private void ApplyDimensions(MagickReadSettings settings)
{
if (settings.Width.HasValue && settings.Height.HasValue)
Size = settings.Width + "x" + settings.Height;
else if (settings.Width.HasValue)
Size = settings.Width + "x";
else if (settings.Height.HasValue)
Size = "x" + settings.Height;
}
private void ApplyFrame(MagickReadSettings settings)
{
if (!settings.FrameIndex.HasValue && !settings.FrameCount.HasValue)
return;
Scenes = settings.GetScenes();
Scene = settings.FrameIndex.HasValue ? settings.FrameIndex.Value : 0;
NumberScenes = settings.FrameCount.HasValue ? settings.FrameCount.Value : 1;
}
private static MagickReadSettings CreateSettings()
{
MagickReadSettings settings = new MagickReadSettings();
settings.PixelStorage = new PixelStorageSettings(StorageType.Double, "RGBA");
settings.Width = 2;
settings.Height = 1;
return settings;
}
internal MagickReadSettings(MagickReadSettings settings)
{
Copy(settings);
ApplyDefines(settings);
ApplyDimensions(settings);
ApplyFrame(settings);
PixelStorage = settings.PixelStorage?.Clone();
}
private void ApplyDefines(MagickReadSettings settings)
{
if (settings.Defines == null)
return;
foreach (IDefine define in settings.Defines.Defines)
{
SetOption(GetDefineKey(define), define.Value);
}
}
public PdfCov(String src, String dst_f, int maxw = 768, int maxh = 1024, double densityx = 96, double densityy = 96, int beg = 0) : base(src, dst_f, maxw, maxh, beg)
{
this.DensityX = densityx;
this.DensityY = densityy;
this.size = new MagickGeometry(maxw, maxh);
this.size.Greater = true;
this.settings = new MagickReadSettings();
this.settings.Density = new PointD(this.DensityX, this.DensityY);
}
public void Test_Image_Read()
{
using (MagickImage image = new MagickImage())
{
MagickReadSettings settings = new MagickReadSettings();
settings.Density = new PointD(300);
image.Read(Files.SnakewarePNG, settings);
Assert.AreEqual(300, image.Density.X);
settings = null;
image.Read(Files.ImageMagickJPG, settings);
}
using (MagickImage image = new MagickImage(Files.RoseSparkleGIF))
{
MagickImage imageA = new MagickImage();
MagickImage imageB = new MagickImage();
MagickReadSettings settings = new MagickReadSettings();
imageA.Read(Files.RoseSparkleGIF, settings);
Assert.AreEqual(image, imageA);
settings = new MagickReadSettings();
settings.FrameIndex = 1;
imageA.Read(Files.RoseSparkleGIF, settings);
Assert.AreNotEqual(image, imageA);
imageB.Read(Files.RoseSparkleGIF + "[1]");
Assert.AreEqual(imageA, imageB);
settings = new MagickReadSettings();
settings.FrameIndex = 2;
imageA.Read(Files.RoseSparkleGIF, settings);
Assert.AreNotEqual(image, imageA);
imageB.Read(Files.RoseSparkleGIF + "[2]");
Assert.AreEqual(imageA, imageB);
ExceptionAssert.Throws<MagickOptionErrorException>(delegate ()
{
settings = new MagickReadSettings();
settings.FrameIndex = 3;
imageA.Read(Files.RoseSparkleGIF, settings);
});
imageA.Dispose();
imageB.Dispose();
}
}
// Get image from Imagick
protected byte[] GetImageFromImagick(Dictionary<string, string> chart)
{
string svgdata = chart["stream"];
if (Empty(svgdata))
return null;
svgdata = svgdata.Replace("+", " "); // Replace + to ' '
// IMPORTANT NOTE: Magick.NET does not support SVG syntax: fill="url('#id')". Need to replace the attributes:
// - fill="url('#id')" style="fill-opacity: n1; ..."
// to:
// - fill="color" style="fill-opacity: n2; ..."
// from xml below:
// <linearGradient ... id="id">
// <stop stop-opacity="0.5" stop-color="#ff0000" offset="0%"></stop>
// ...</linearGradient>
var doc = new XmlDocument();
doc.LoadXml(svgdata);
var nodes = doc.SelectNodes("//*[@fill]");
foreach (XmlElement node in nodes) {
string fill = node.GetAttribute("fill");
string style = node.GetAttribute("style");
if (fill.StartsWith("url(") && fill.Substring(5, 1) == "#") {
var id = fill.Substring(6, fill.Length - 8);
var nsmgr = new XmlNamespaceManager(doc.NameTable);
nsmgr.AddNamespace("ns", "http://www.w3.org/2000/svg");
var gnode = doc.SelectSingleNode("//*/ns:linearGradient[@id='" + id + "']", nsmgr);
if (gnode != null) {
XmlElement snode = (XmlElement)gnode.SelectSingleNode("ns:stop[@offset='0%']", nsmgr);
if (snode != null) {
var fillcolor = snode.GetAttribute("stop-color");
var fillopacity = snode.GetAttribute("stop-opacity");
if (!Empty(fillcolor))
node.SetAttribute("fill", fillcolor);
if (!Empty(fillopacity) && !Empty(style)) {
style = Regex.Replace(style, @"fill-opacity:\s*\S*;", "fill-opacity: " + fillopacity + ";");
node.SetAttribute("style", style);
}
}
}
}
}
svgdata = doc.DocumentElement.OuterXml;
ImageMagick.MagickNET.SetLogEvents(ImageMagick.LogEvents.All);
ImageMagick.MagickReadSettings settings = new ImageMagick.MagickReadSettings();
settings.ColorSpace = ImageMagick.ColorSpace.RGB;
settings.Format = ImageMagick.MagickFormat.Svg;
using var image = new ImageMagick.MagickImage(Encoding.UTF8.GetBytes(svgdata), settings);
//image.BackgroundColor = new ImageMagick.MagickColor(System.Drawing.Color.Transparent);
image.Format = ImageMagick.MagickFormat.Png;
return image.ToByteArray();
}
public void Test_Dimensions()
{
using (MagickImage image = new MagickImage())
{
MagickReadSettings settings = new MagickReadSettings();
settings.Width = 100;
image.Read(Files.Logos.MagickNETSVG, settings);
Assert.AreEqual(100, image.Width);
Assert.AreEqual(48, image.Height);
settings.Width = null;
settings.Height = 200;
image.Read(Files.Logos.MagickNETSVG, settings);
Assert.AreEqual(415, image.Width);
Assert.AreEqual(200, image.Height);
settings.Width = 300;
settings.Height = 300;
image.Read(Files.Logos.MagickNETSVG, settings);
Assert.AreEqual(300, image.Width);
Assert.AreEqual(144, image.Height);
image.Ping(Files.Logos.MagickNETSVG, settings);
Assert.AreEqual(300, image.Width);
Assert.AreEqual(144, image.Height);
using (FileStream fs = File.OpenRead(Files.Logos.MagickNETSVG))
{
fs.Seek(55, SeekOrigin.Begin);
ExceptionAssert.Throws<MagickMissingDelegateErrorException>(() =>
{
new MagickImageInfo(fs, settings);
});
fs.Seek(55, SeekOrigin.Begin);
settings.Format = MagickFormat.Svg;
MagickImageInfo info = new MagickImageInfo(fs, settings);
Assert.AreEqual(300, info.Width);
Assert.AreEqual(144, info.Height);
}
}
}
public void Test_Collection_Exceptions()
{
using (MagickImageCollection collection = new MagickImageCollection())
{
MagickReadSettings settings = new MagickReadSettings();
settings.PixelStorage = new PixelStorageSettings();
ExceptionAssert.Throws<ArgumentException>(delegate ()
{
collection.Read(Files.RoseSparkleGIF, settings);
});
}
}
public void Test_Image_Read_Density()
{
using (MagickImage image = new MagickImage())
{
MagickReadSettings settings = new MagickReadSettings();
settings.Density = new Density(300);
image.Read(Files.SnakewarePNG, settings);
Assert.AreEqual(300, image.Density.X);
settings = null;
image.Read(Files.ImageMagickJPG, settings);
}
}
public void Convert2Jpeg(bool rotate = false)
{
try
{
MagickReadSettings settings = new MagickReadSettings();
// Settings the density to 300 dpi will create an image with a better quality
settings.Density = new PointD(300, 300);
using (MagickImageCollection images = new MagickImageCollection())
{
// Add all the pages of the pdf file to the collection
images.Read(_pdf.FullName, settings);
if (images.Count > 0 && images[0].Format == MagickFormat.Pdf)
{
_logger.InfoFormat("Handle {0}", _pdf.FullName);
int page = 1;
foreach (MagickImage image in images)
{
var newFileName = GetFilePageName(page) + ".jpg";
// Need page rotation?
if (rotate)
image.Rotate(90.0);
// Write page to file that contains the page number
image.Format = MagickFormat.Jpg;
image.CompressionMethod = CompressionMethod.JPEG;
image.Quality = 75;
image.Write(newFileName);
_logger.InfoFormat("-> {0}", newFileName);
// Writing to a specific format works the same as for a single image
page++;
}
}
}
}
catch (Exception ex)
{
_logger.Error(ex.Message, ex);
}
}
public void Test_IgnoreTags()
{
using (MagickImage image = new MagickImage())
{
image.Settings.SetDefine(MagickFormat.Tiff, "ignore-tags", "32934");
image.Read(Files.Coders.IgnoreTagTIF);
}
using (MagickImage image = new MagickImage())
{
MagickReadSettings readSettings = new MagickReadSettings(new TiffReadDefines()
{
IgnoreTags = new string[] { "32934" }
});
image.Read(Files.Coders.IgnoreTagTIF, readSettings);
}
}
public void Test_FitPage()
{
MagickReadSettings settings = new MagickReadSettings()
{
Defines = new PdfReadDefines()
{
FitPage = new MagickGeometry(50, 40)
}
};
using (MagickImage image = new MagickImage())
{
image.Read(Files.Coders.CartoonNetworkStudiosLogoAI, settings);
Assert.IsTrue(image.Width <= 50);
Assert.IsTrue(image.Height <= 40);
}
}
public override Stream CompressImageData(Image image, Stream imageData, out string optimizedExtension)
{
var settings = _config.Optimizers["ImageMagickImageOptimizer"].Parameters;
int _imageQuality = Int32.Parse(settings["imageQuality"]);
MagickReadSettings magickSettings = new MagickReadSettings();
switch (image.Extension.ToLower())
{
case ".png":
magickSettings.Format = MagickFormat.Png;
break;
case ".jpg":
magickSettings.Format = MagickFormat.Jpg;
break;
case ".jpeg":
magickSettings.Format = MagickFormat.Jpeg;
break;
case ".bmp":
magickSettings.Format = MagickFormat.Bmp;
break;
default:
magickSettings.Format = MagickFormat.Jpg;
break;
}
using (MagickImage img = new MagickImage(imageData, magickSettings))
{
MemoryStream compressed = new MemoryStream();
img.Quality = _imageQuality;
img.Write(compressed);
if (compressed == null)
{
optimizedExtension = "";
return null;
}
optimizedExtension = Path.GetExtension(image.FilePath);
return compressed;
}
}
public void Test_Read_Bytes()
{
#if Q8
var bytes = new byte[] { 1, 2, 3, 4 };
#elif Q16 || Q16HDRI
var bytes = new byte[] { 1, 0, 2, 0, 3, 0, 4, 0 };
#else
#error Not implemented!
#endif
MagickReadSettings settings = new MagickReadSettings()
{
Width = 1,
Height = 1
};
settings.Format = MagickFormat.Rgba;
using (MagickImage image = new MagickImage(bytes, settings))
{
using (PixelCollection pixels = image.GetReadOnlyPixels())
{
Pixel pixel = pixels.GetPixel(0, 0);
Assert.AreEqual(4, pixel.Channels);
Assert.AreEqual(1, pixel.GetChannel(0));
Assert.AreEqual(2, pixel.GetChannel(1));
Assert.AreEqual(3, pixel.GetChannel(2));
Assert.AreEqual(4, pixel.GetChannel(3));
}
}
settings.Format = MagickFormat.Rgbo;
using (MagickImage image = new MagickImage(bytes, settings))
{
using (PixelCollection pixels = image.GetReadOnlyPixels())
{
Pixel pixel = pixels.GetPixel(0, 0);
Assert.AreEqual(4, pixel.Channels);
Assert.AreEqual(1, pixel.GetChannel(0));
Assert.AreEqual(2, pixel.GetChannel(1));
Assert.AreEqual(3, pixel.GetChannel(2));
Assert.AreEqual(Quantum.Max - 4, pixel.GetChannel(3));
}
}
}
private static void ConvertPdfToOneTif()
{
// Log all events
//MagickNET.SetLogEvents(LogEvents.All | LogEvents.Trace);
// Set the log handler (all threads use the same handler)
//MagickNET.Log += DetailedDebugInformationSamples.MagickNET_Log;
string sampleDocsDirectory = @"E:\projects\ImageProcessing\sampledocs\";
string sampleFile = "sample6.pdf";
try
{
MagickReadSettings settings = new MagickReadSettings();
settings.Density = new PointD(300, 300);
using (MagickImageCollection images = new MagickImageCollection())
{
// Add all the pages of the source file to the collection
images.Read(Path.Combine(sampleDocsDirectory, sampleFile), settings);
//Show page count
Console.WriteLine("page count for {0} {1}", sampleFile, images.Count);
string baseFileName = Path.GetFileNameWithoutExtension(sampleFile);
// Create new image that appends all the pages horizontally
//using (MagickImage vertical = images.AppendVertically())
//{
// vertical.CompressionMethod = CompressionMethod.Group4;
// Console.WriteLine("saving file: {0}", baseFileName + ".tif");
// vertical.Write(sampleDocsDirectory + baseFileName + ".tif");
//}
Console.WriteLine("saving file: {0}", baseFileName + ".tif");
images.Write(sampleDocsDirectory + baseFileName + ".tif");
}
}
catch (Exception ex)
{
Console.WriteLine("ConvertPdfToOneTif {0}", ex.Message);
}
}
public void Test_IgnoreExifPoperties()
{
MagickReadSettings settings = new MagickReadSettings()
{
Defines = new TiffReadDefines()
{
IgnoreExifPoperties = true
}
};
using (MagickImage image = new MagickImage())
{
image.Read(Files.InvitationTif);
Assert.IsNotNull(image.GetAttribute("exif:PixelXDimension"));
image.Read(Files.InvitationTif, settings);
Assert.IsNull(image.GetAttribute("exif:PixelXDimension"));
}
}
public void Test_SkipProfiles()
{
MagickReadSettings settings = new MagickReadSettings()
{
Defines = new JpegReadDefines()
{
SkipProfiles = ProfileTypes.Iptc | ProfileTypes.Icc
}
};
using (MagickImage image = new MagickImage())
{
image.Read(Files.FujiFilmFinePixS1ProJPG);
Assert.IsNotNull(image.GetIptcProfile());
image.Read(Files.FujiFilmFinePixS1ProJPG, settings);
Assert.IsNull(image.GetIptcProfile());
Assert.AreEqual("Icc,Iptc", image.GetDefine(MagickFormat.Unknown, "profile:skip"));
}
}
/// <summary>
/// Returns a decoded image from ImageMagick - assumes only a singal frame,
/// as many methods I need are internal to ImageSharp
/// </summary>
/// <typeparam name="TPixel"></typeparam>
/// <param name="configuration"></param>
/// <param name="stream"></param>
/// <returns></returns>
public Image <TPixel> Decode <TPixel>(Configuration configuration, Stream stream)
where TPixel : unmanaged, SixLabors.ImageSharp.PixelFormats.IPixel <TPixel>
{
var settings = new Magick.MagickReadSettings();
using var magickImageCollection = new Magick.MagickImageCollection(stream, settings);
if (magickImageCollection.Count == 0)
{
throw new Exception("No images found");
}
Magick.IMagickImage <ushort> magickImage = magickImageCollection[0];
var width = magickImage.Width;
var height = magickImage.Height;
var image = new Image <TPixel>(configuration, width, height);
var framePixels = image.GetPixelMemoryGroup();
using Magick.IUnsafePixelCollection <ushort> pixels = magickImage.GetPixelsUnsafe();
if (magickImage.Depth == 8 || magickImage.Depth == 6 || magickImage.Depth == 4 || magickImage.Depth == 2 || magickImage.Depth == 1 || magickImage.Depth == 10 || magickImage.Depth == 12)
{
byte[]? data = pixels.ToByteArray(Magick.PixelMapping.RGBA);
FromRgba32Bytes(configuration, data, framePixels);
}
else if (magickImage.Depth == 16 || magickImage.Depth == 14)
{
ushort[]? data = pixels.ToShortArray(Magick.PixelMapping.RGBA);
Span <byte> bytes = MemoryMarshal.Cast <ushort, byte>(data.AsSpan());
FromRgba64Bytes(configuration, bytes, framePixels);
}
else
{
throw new InvalidOperationException();
}
return(image);
}
public static void ReadImage()
{
// Read from file.
using (MagickImage image = new MagickImage(SampleFiles.SnakewareJpg))
{
}
// Read from stream.
using (MemoryStream memStream = LoadMemoryStreamImage())
{
using (MagickImage image = new MagickImage(memStream))
{
}
}
// Read from byte array.
byte[] data = LoadImageBytes();
using (MagickImage image = new MagickImage(data))
{
}
// Read image that has no predefined dimensions.
MagickReadSettings settings = new MagickReadSettings();
settings.Width = 800;
settings.Height = 600;
using (MagickImage image = new MagickImage("xc:yellow", settings))
{
}
using (MagickImage image = new MagickImage())
{
image.Read(SampleFiles.SnakewareJpg);
image.Read(data);
image.Read("xc:yellow", settings);
using (MemoryStream memStream = LoadMemoryStreamImage())
{
image.Read(memStream);
}
}
}
public void Test_Colors_Size()
{
MagickReadSettings settings = new MagickReadSettings()
{
Defines = new JpegReadDefines()
{
Colors = 100,
Size = new MagickGeometry(61, 59)
}
};
using (MagickImage image = new MagickImage())
{
image.Read(Files.ImageMagickJPG, settings);
Assert.IsTrue(image.TotalColors <= 100);
Assert.AreEqual(100, image.TotalColors, 1);
Assert.AreEqual(62, image.Width);
Assert.AreEqual(59, image.Height);
}
}
private void ExecuteFrameIndex(XmlElement element, MagickReadSettings readSettings)
{
readSettings.FrameIndex = GetValue <Nullable <Int32> >(element, "value");
}
private void ExecuteHeight(XmlElement element, MagickReadSettings readSettings)
{
readSettings.Height = GetValue <Nullable <Int32> >(element, "value");
}
private void ExecutePage(XmlElement element, MagickReadSettings readSettings)
{
readSettings.Page = GetValue <MagickGeometry>(element, "value");
}
private void ExecuteFontFamily(XmlElement element, MagickReadSettings readSettings)
{
readSettings.FontFamily = GetValue <String>(element, "value");
}
private void ExecuteTextGravity(XmlElement element, MagickReadSettings readSettings)
{
readSettings.TextGravity = GetValue <Gravity>(element, "value");
}
private void ExecuteDepth(XmlElement element, MagickReadSettings readSettings)
{
readSettings.Depth = GetValue <Int32>(element, "value");
}
private void ExecuteFontStyle(XmlElement element, MagickReadSettings readSettings)
{
readSettings.FontStyle = GetValue <FontStyleType>(element, "value");
}
private void ExecuteStrokeDashOffset(XmlElement element, MagickReadSettings readSettings)
{
readSettings.StrokeDashOffset = GetValue <double>(element, "value");
}
private void ExecuteExtractArea(XmlElement element, MagickReadSettings readSettings)
{
readSettings.ExtractArea = GetValue <MagickGeometry>(element, "value");
}
private void ExecuteTextAntiAlias(XmlElement element, MagickReadSettings readSettings)
{
readSettings.TextAntiAlias = GetValue <Boolean>(element, "value");
}
private void ExecuteUseMonochrome(XmlElement element, MagickReadSettings readSettings)
{
readSettings.UseMonochrome = GetValue <Boolean>(element, "value");
}
private void ExecuteStrokeMiterLimit(XmlElement element, MagickReadSettings readSettings)
{
readSettings.StrokeMiterLimit = GetValue <Int32>(element, "value");
}
private void ExecuteFormat(XmlElement element, MagickReadSettings readSettings)
{
readSettings.Format = GetValue <MagickFormat>(element, "value");
}
private void ExecuteTextEncoding(XmlElement element, MagickReadSettings readSettings)
{
readSettings.TextEncoding = GetValue <Encoding>(element, "value");
}
private void ExecuteFontWeight(XmlElement element, MagickReadSettings readSettings)
{
readSettings.FontWeight = GetValue <FontWeight>(element, "value");
}
private void ExecuteStrokeWidth(XmlElement element, MagickReadSettings readSettings)
{
readSettings.StrokeWidth = GetValue <double>(element, "value");
}
private void ExecuteFontPointsize(XmlElement element, MagickReadSettings readSettings)
{
readSettings.FontPointsize = GetValue <double>(element, "value");
}
private void ExecuteTextUnderColor(XmlElement element, MagickReadSettings readSettings)
{
readSettings.TextUnderColor = GetValue <MagickColor>(element, "value");
}
private void ExecuteFillRule(XmlElement element, MagickReadSettings readSettings)
{
readSettings.FillRule = GetValue <FillRule>(element, "value");
}
private void ExecuteTextKerning(XmlElement element, MagickReadSettings readSettings)
{
readSettings.TextKerning = GetValue <double>(element, "value");
}
private void ExecuteTextDirection(XmlElement element, MagickReadSettings readSettings)
{
readSettings.TextDirection = GetValue <TextDirection>(element, "value");
}
private void ExecuteStrokeLineJoin(XmlElement element, MagickReadSettings readSettings)
{
readSettings.StrokeLineJoin = GetValue <LineJoin>(element, "value");
}
private void ExecuteEndian(XmlElement element, MagickReadSettings readSettings)
{
readSettings.Endian = GetValue <Endian>(element, "value");
}
private void ExecuteStrokeDashArray(XmlElement element, MagickReadSettings readSettings)
{
readSettings.StrokeDashArray = GetDoubleArray(element);
}
private void ExecuteDensity(XmlElement element, MagickReadSettings readSettings)
{
readSettings.Density = GetValue <Density>(element, "value");
}
private void ExecuteStrokeColor(XmlElement element, MagickReadSettings readSettings)
{
readSettings.StrokeColor = GetValue <MagickColor>(element, "value");
}
private void ExecuteVerbose(XmlElement element, MagickReadSettings readSettings)
{
readSettings.Verbose = GetValue <Boolean>(element, "value");
}
private void ExecuteStrokePattern(XmlElement element, MagickReadSettings readSettings)
{
readSettings.StrokePattern = CreateMagickImage(element);
}