public void Test_Image_ByteArray()
{
using (Image img = Image.FromFile(Files.Coders.PageTIF))
{
byte[] bytes = null;
using (MemoryStream memStream = new MemoryStream())
{
img.Save(memStream, ImageFormat.Tiff);
bytes = memStream.GetBuffer();
}
using (MagickImage image = new MagickImage(bytes))
{
image.CompressionMethod = CompressionMethod.Group4;
using (MemoryStream memStream = new MemoryStream())
{
image.Write(memStream);
memStream.Position = 0;
using (MagickImage before = new MagickImage(Files.Coders.PageTIF))
{
using (MagickImage after = new MagickImage(memStream))
{
Assert.AreEqual(0.0, before.Compare(after, ErrorMetric.RootMeanSquared));
}
}
}
}
}
}
private static void Test_Clone_Area(MagickImage area, MagickImage part)
{
Assert.AreEqual(area.Width, part.Width);
Assert.AreEqual(area.Height, part.Height);
Assert.AreEqual(0.0, area.Compare(part, ErrorMetric.RootMeanSquared));
}
public void CompareImages([CallerMemberName] string testName = "")
{
string expectedPath = Path.Combine(testDirectory, testName + ".expected.png");
string actualPath = Path.Combine(testDirectory, testName + ".wpf.out.png");
MagickImage expected = new MagickImage(expectedPath);
MagickImage actual = new MagickImage(actualPath);
MagickErrorInfo error = expected.Compare(actual);
Assert.IsNull(error);
}
protected void CompareImages([CallerMemberName] string testName = "")
{
string expectedPath = Path.Combine(OutputPath, testName + ".expected.png");
string actualPath = Path.Combine(OutputPath, testName + ".out.png");
MagickImage expected = new MagickImage(expectedPath);
MagickImage actual = new MagickImage(actualPath);
double error = expected.Compare(actual, ErrorMetric.RootMeanSquared);
if (error > 0.022)
{
Assert.True(false, actualPath + ": Error = " + error);
}
}
public double Compare(MagickImage leftImage, MagickImage rightImage, out MagickImage diffImage)
{
// See:
// [1] https://stackoverflow.com/questions/5132749/diff-an-image-using-imagemagick
// [2] https://stackoverflow.com/questions/20582620/how-to-compare-2-images-ignoring-areas#26584462
// resize image to the same size - ImageMagick requires both images to be of the same size
rightImage.Crop(leftImage.BaseWidth, leftImage.BaseHeight);
// apply the mask to the screenshot
rightImage.Composite(leftImage, CompositeOperator.DstIn);
// compare masked screenshot against reference image
diffImage = new MagickImage();
return rightImage.Compare(leftImage, ErrorMetric.Absolute, diffImage);
}
public void CompareImages([CallerMemberName] string testName = "")
{
string expectedPath = Path.Combine(testDirectory, testName + ".expected.png");
string actualPath = Path.Combine(testDirectory, testName + ".avalonia.out.png");
MagickImage expected = new MagickImage(expectedPath);
MagickImage actual = new MagickImage(actualPath);
MagickErrorInfo error = expected.Compare(actual);
if (error != null)
{
if (error.NormalizedMaximumError > 0.15)
{
Assert.Fail("NormalizedMaximumError = " + error.NormalizedMaximumError);
}
else
{
Assert.Inconclusive("Close but no cigar.");
}
}
}
public void saveResult(string FilePath1, string FilePath2, string outFilePath)
{
MagickImageCollection images = new MagickImageCollection();
// Add the first image
MagickImage first = new MagickImage(FilePath1);
// images.Add(first);
// Add the second image
MagickImage second = new MagickImage(FilePath2);
// images.Add(second);
/*
first.Composite(second, 0, 0, CompositeOperator.ModulusAdd);
first.Write(outFilePath + "compos.png");
*/
MagickImage third = new MagickImage();
first.Compare(second, ErrorMetric.Absolute, third);
third.Write(outFilePath + "third.bmp");
}
public void Test_GaussianBlur()
{
using (MagickImage gaussian = new MagickImage(Files.Builtin.Wizard))
{
gaussian.GaussianBlur(5.5, 10.2);
using (MagickImage blur = new MagickImage(Files.Builtin.Wizard))
{
blur.Blur(5.5, 10.2);
double distortion = blur.Compare(gaussian, ErrorMetric.RootMeanSquared);
#if Q8
Assert.AreEqual(0.00066, distortion, 0.00001);
#elif Q16
Assert.AreEqual(0.0000033, distortion, 0.0000001);
#elif Q16HDRI
Assert.AreEqual(0.0000011, distortion, 0.0000001);
#else
#error Not implemented!
#endif
}
}
}
public void Test_Composite_ChangeMask()
{
using (MagickImage background = new MagickImage("xc:red", 100, 100))
{
background.BackgroundColor = Color.White;
background.Extent(200, 100);
IDrawable[] drawables = new IDrawable[]
{
new DrawablePointSize(50),
new DrawableText(135, 70, "X")
};
using (MagickImage image = background.Clone())
{
image.Draw(drawables);
image.Composite(background, Gravity.Center, CompositeOperator.ChangeMask);
using (MagickImage result = new MagickImage(MagickColor.Transparent, 200, 100))
{
result.Draw(drawables);
Assert.AreEqual(0.073, result.Compare(image, ErrorMetric.RootMeanSquared), 0.001);
}
}
}
}
public void Test_Compare()
{
MagickImage first = new MagickImage(Files.SnakewarePNG);
MagickImage second = first.Clone();
MagickErrorInfo same = first.Compare(second);
Assert.IsNotNull(same);
Assert.AreEqual(0, same.MeanErrorPerPixel);
double distortion = first.Compare(second, ErrorMetric.Absolute);
Assert.AreEqual(0, distortion);
first.Threshold(new Percentage(50));
MagickErrorInfo different = first.Compare(second);
Assert.IsNotNull(different);
Assert.AreNotEqual(0, different.MeanErrorPerPixel);
distortion = first.Compare(second, ErrorMetric.Absolute);
Assert.AreNotEqual(0, distortion);
MagickImage difference = new MagickImage();
distortion = first.Compare(second, ErrorMetric.RootMeanSquared, difference);
Assert.AreNotEqual(0, distortion);
Assert.AreNotEqual(first, difference);
Assert.AreNotEqual(second, difference);
}
public void Test_Compare()
{
MagickImage first = new MagickImage(Files.ImageMagickJPG);
ExceptionAssert.Throws<ArgumentNullException>(delegate ()
{
first.Compare(null);
});
MagickImage second = first.Clone();
MagickErrorInfo same = first.Compare(second);
Assert.IsNotNull(same);
Assert.AreEqual(0, same.MeanErrorPerPixel);
double distortion = first.Compare(second, ErrorMetric.Absolute);
Assert.AreEqual(0, distortion);
first.Threshold(new Percentage(50));
MagickErrorInfo different = first.Compare(second);
Assert.IsNotNull(different);
Assert.AreNotEqual(0, different.MeanErrorPerPixel);
distortion = first.Compare(second, ErrorMetric.Absolute);
Assert.AreNotEqual(0, distortion);
MagickImage difference = new MagickImage();
distortion = first.Compare(second, ErrorMetric.RootMeanSquared, difference);
Assert.AreNotEqual(0, distortion);
Assert.AreNotEqual(first, difference);
Assert.AreNotEqual(second, difference);
second.Dispose();
first.Opaque(MagickColors.Black, MagickColors.Green);
first.Opaque(MagickColors.White, MagickColors.Green);
second = first.Clone();
second.FloodFill(MagickColors.Gray, 0, 0);
distortion = first.Compare(second, ErrorMetric.Absolute, Channels.Green);
Assert.AreEqual(0, distortion);
distortion = first.Compare(second, ErrorMetric.Absolute, Channels.Red);
Assert.AreNotEqual(0, distortion);
}
public void Test_LevelColors()
{
using (MagickImage image = new MagickImage(Files.MagickNETIconPNG))
{
image.LevelColors(MagickColors.Fuchsia, MagickColors.Goldenrod);
ColorAssert.AreEqual(new MagickColor("#ffffbed24bc3fffa"), image, 42, 75);
ColorAssert.AreEqual(new MagickColor("#ffffffff0809"), image, 62, 75);
}
using (MagickImage first = new MagickImage(Files.MagickNETIconPNG))
{
first.LevelColors(MagickColors.Fuchsia, MagickColors.Goldenrod, Channels.Blue);
first.InverseLevelColors(MagickColors.Fuchsia, MagickColors.Goldenrod, Channels.Blue);
first.Alpha(AlphaOption.Background);
using (MagickImage second = new MagickImage(Files.MagickNETIconPNG))
{
second.Alpha(AlphaOption.Background);
#if Q8
Assert.AreEqual(0.0, first.Compare(second, ErrorMetric.RootMeanSquared));
#elif Q16 || Q16HDRI
Assert.AreEqual(0.0, 0.00000001, first.Compare(second, ErrorMetric.RootMeanSquared));
#else
#error Not implemented!
#endif
}
}
}
public double saveResult(MagickImage StandartIM, MagickImage CurrentIM, string outFilePath, string outCurFilePath)
{
MagickImage resultImage = new MagickImage();
var compareResult = StandartIM.Compare(CurrentIM, ErrorMetric.Absolute, resultImage);
if (compareResult != 0)
{
CreateScreenDirectory(Path.GetDirectoryName(outFilePath));
CreateScreenDirectory(Path.GetDirectoryName(outCurFilePath));
resultImage.Write(outFilePath);
CurrentIM.Write(outCurFilePath);
Console.Out.WriteLine("Погрешность= " + compareResult + " Изображения не совпадают" + outFilePath);
}
else
{
Console.Out.WriteLine("Изображения совпадают");
}
return compareResult;
}
public void Test_RandomSeed()
{
using (MagickImage first = new MagickImage("plasma:red", 10, 10))
{
using (MagickImage second = new MagickImage("plasma:red", 10, 10))
{
Assert.AreNotEqual(0.0, first.Compare(second, ErrorMetric.RootMeanSquared));
}
}
MagickNET.SetRandomSeed(1337);
using (MagickImage first = new MagickImage("plasma:red", 10, 10))
{
using (MagickImage second = new MagickImage("plasma:red", 10, 10))
{
Assert.AreEqual(0.0, first.Compare(second, ErrorMetric.RootMeanSquared));
}
}
}
public void Test_Sharpen()
{
using (MagickImage image = new MagickImage(Files.NoisePNG))
{
image.Sharpen(10, 20);
image.Clamp();
using (MagickImage original = new MagickImage(Files.NoisePNG))
{
Assert.AreEqual(0.06675, image.Compare(original, ErrorMetric.RootMeanSquared), 0.00001);
}
}
}
public void Test_SigmoidalContrast()
{
using (MagickImage image = new MagickImage(Files.NoisePNG))
{
image.SigmoidalContrast(true, 8.0);
using (MagickImage original = new MagickImage(Files.NoisePNG))
{
Assert.AreEqual(0.07361, original.Compare(image, ErrorMetric.RootMeanSquared), 0.00001);
}
}
}
public void Test_SelectiveBlur()
{
using (MagickImage image = new MagickImage(Files.NoisePNG))
{
image.SelectiveBlur(5.0, 2.0, Quantum.Max / 2);
using (MagickImage original = new MagickImage(Files.NoisePNG))
{
Assert.AreEqual(0.07777, original.Compare(image, ErrorMetric.RootMeanSquared), 0.00002);
}
}
}
public void Test_Read()
{
MagickImage image = new MagickImage();
ExceptionAssert.Throws<ArgumentException>(delegate ()
{
image.Read(new byte[0]);
});
ExceptionAssert.Throws<ArgumentNullException>(delegate ()
{
image.Read((byte[])null);
});
ExceptionAssert.Throws<ArgumentNullException>(delegate ()
{
image.Read((Stream)null);
});
ExceptionAssert.Throws<ArgumentNullException>(delegate ()
{
image.Read((string)null);
});
ExceptionAssert.Throws<ArgumentException>(delegate ()
{
image.Read(Files.Missing);
});
ExceptionAssert.Throws<ArgumentException>(delegate ()
{
image.Read("png:" + Files.Missing);
});
image.Read(File.ReadAllBytes(Files.SnakewarePNG));
Assert.AreEqual(286, image.Width);
Assert.AreEqual(67, image.Height);
using (FileStream fs = File.OpenRead(Files.SnakewarePNG))
{
image.Read(fs);
Assert.AreEqual(286, image.Width);
Assert.AreEqual(67, image.Height);
Assert.AreEqual(MagickFormat.Png, image.Format);
}
image.Read(Files.SnakewarePNG);
Assert.AreEqual(286, image.Width);
Assert.AreEqual(67, image.Height);
Assert.AreEqual(MagickFormat.Png, image.Format);
image.Read(Files.Builtin.Rose);
Assert.AreEqual(70, image.Width);
Assert.AreEqual(46, image.Height);
Assert.AreEqual(MagickFormat.Ppm, image.Format);
image.Read(Files.RoseSparkleGIF);
Assert.AreEqual("RöseSparkle.gif", Path.GetFileName(image.FileName));
Assert.AreEqual(70, image.Width);
Assert.AreEqual(46, image.Height);
Assert.AreEqual(MagickFormat.Gif, image.Format);
image.Read("png:" + Files.SnakewarePNG);
Assert.AreEqual(286, image.Width);
Assert.AreEqual(67, image.Height);
Assert.AreEqual(MagickFormat.Png, image.Format);
MagickColor red = new MagickColor("red");
image.Read(red, 50, 50);
Assert.AreEqual(50, image.Width);
Assert.AreEqual(50, image.Height);
ColorAssert.AreEqual(red, image, 10, 10);
image.Read("xc:red", 50, 50);
Assert.AreEqual(50, image.Width);
Assert.AreEqual(50, image.Height);
ColorAssert.AreEqual(red, image, 5, 5);
using (FileStream fs = File.OpenRead(Files.ImageMagickJPG))
{
image.Read(fs);
fs.Position = 0;
using (FakePartialStream fakeStream = new FakePartialStream(fs))
{
using (MagickImage testImage = new MagickImage())
{
testImage.Read(fakeStream);
Assert.AreEqual(image.Width, testImage.Width);
Assert.AreEqual(image.Height, testImage.Height);
Assert.AreEqual(image.Format, testImage.Format);
Assert.AreEqual(0.0, image.Compare(testImage, ErrorMetric.RootMeanSquared));
}
}
}
image.Dispose();
ExceptionAssert.Throws<ObjectDisposedException>(delegate ()
{
image.BackgroundColor = MagickColors.PaleGreen;
});
}
public void Test_MotionBlur()
{
using (MagickImage motionBlurred = new MagickImage(Files.Builtin.Logo))
{
motionBlurred.MotionBlur(4.0, 5.4, 10.6);
using (MagickImage original = new MagickImage(Files.Builtin.Logo))
{
Assert.AreEqual(0.11019, motionBlurred.Compare(original, ErrorMetric.RootMeanSquared), 0.00001);
}
}
}
public void Test_Level()
{
using (MagickImage first = new MagickImage(Files.MagickNETIconPNG))
{
first.Level(new Percentage(50.0), new Percentage(10.0));
using (MagickImage second = new MagickImage(Files.MagickNETIconPNG))
{
Assert.AreNotEqual(first, second);
Assert.AreNotEqual(first.Signature, second.Signature);
second.Level((QuantumType)(Quantum.Max * 0.5), (QuantumType)(Quantum.Max * 0.1));
Assert.AreEqual(0.0, first.Compare(second, ErrorMetric.RootMeanSquared));
Assert.AreEqual(first, second);
Assert.AreEqual(first.Signature, second.Signature);
}
}
}
public void Test_Stegano()
{
using (MagickImage message = new MagickImage("label:Magick.NET is the best!", 200, 20))
{
using (MagickImage image = new MagickImage(Files.Builtin.Wizard))
{
image.Stegano(message);
FileInfo tempFile = new FileInfo(Path.GetTempFileName() + ".png");
try
{
image.Write(tempFile);
MagickReadSettings settings = new MagickReadSettings();
settings.Format = MagickFormat.Stegano;
settings.Width = 200;
settings.Height = 20;
using (MagickImage hiddenMessage = new MagickImage(tempFile, settings))
{
Assert.AreEqual(0, message.Compare(hiddenMessage, ErrorMetric.RootMeanSquared));
}
}
finally
{
if (tempFile.Exists)
tempFile.Delete();
}
}
}
}
public void Test_Enhance()
{
using (MagickImage enhanced = new MagickImage(Files.NoisePNG))
{
enhanced.Enhance();
using (MagickImage original = new MagickImage(Files.NoisePNG))
{
Assert.AreEqual(0.0115, enhanced.Compare(original, ErrorMetric.RootMeanSquared), 0.0003);
}
}
}
public void Test_UnsharpMask()
{
using (MagickImage image = new MagickImage(Files.NoisePNG))
{
image.UnsharpMask(7.0, 3.0);
using (MagickImage original = new MagickImage(Files.NoisePNG))
{
#if Q8 || Q16
Assert.AreEqual(0.06476, original.Compare(image, ErrorMetric.RootMeanSquared), 0.00002);
#elif Q16HDRI
Assert.AreEqual(0.10234, original.Compare(image, ErrorMetric.RootMeanSquared), 0.00001);
#else
#error Not implemented!
#endif
}
}
}
public void Test_Contrast()
{
using (MagickImage first = new MagickImage(Files.Builtin.Wizard))
{
first.Contrast(true);
first.Contrast(false);
using (MagickImage second = new MagickImage(Files.Builtin.Wizard))
{
Assert.AreEqual(0.003, 0.0001, first.Compare(second, ErrorMetric.RootMeanSquared));
}
}
}
public void Test_Wave()
{
using (MagickImage image = new MagickImage(Files.TestPNG))
{
image.Wave();
using (MagickImage original = new MagickImage(Files.TestPNG))
{
#if Q8
Assert.AreEqual(0.63104, original.Compare(image, ErrorMetric.RootMeanSquared), 0.00001);
#elif Q16 || Q16HDRI
Assert.AreEqual(0.63109, original.Compare(image, ErrorMetric.RootMeanSquared), 0.00001);
#else
#error Not implemented!
#endif
}
}
}
public void Test_Spread()
{
using (MagickImage image = new MagickImage(Files.FujiFilmFinePixS1ProJPG))
{
image.Spread(10);
using (MagickImage original = new MagickImage(Files.FujiFilmFinePixS1ProJPG))
{
Assert.AreEqual(0.121, original.Compare(image, ErrorMetric.RootMeanSquared), 0.002);
}
}
}
public void Test_Level()
{
using (MagickImage first = new MagickImage(Files.MagickNETIconPNG))
{
first.Level(new Percentage(50.0), new Percentage(10.0));
using (MagickImage second = new MagickImage(Files.MagickNETIconPNG))
{
Assert.AreNotEqual(first, second);
Assert.AreNotEqual(first.Signature, second.Signature);
QuantumType fifty = (QuantumType)(Quantum.Max * 0.5);
QuantumType ten = (QuantumType)(Quantum.Max * 0.1);
second.Level(fifty, ten, Channels.Red);
second.Level(fifty, ten, Channels.Green | Channels.Blue);
second.Level(fifty, ten, Channels.Alpha);
Assert.AreEqual(0.0, first.Compare(second, ErrorMetric.RootMeanSquared));
Assert.AreEqual(first, second);
Assert.AreEqual(first.Signature, second.Signature);
}
}
using (MagickImage first = new MagickImage(Files.MagickNETIconPNG))
{
first.InverseLevel(new Percentage(50.0), new Percentage(10.0));
using (MagickImage second = new MagickImage(Files.MagickNETIconPNG))
{
Assert.AreNotEqual(first, second);
Assert.AreNotEqual(first.Signature, second.Signature);
QuantumType fifty = (QuantumType)(Quantum.Max * 0.5);
QuantumType ten = (QuantumType)(Quantum.Max * 0.1);
second.InverseLevel(fifty, ten, Channels.Red);
second.InverseLevel(fifty, ten, Channels.Green | Channels.Blue);
second.InverseLevel(fifty, ten, Channels.Alpha);
Assert.AreEqual(0.0, first.Compare(second, ErrorMetric.RootMeanSquared));
Assert.AreEqual(first, second);
Assert.AreEqual(first.Signature, second.Signature);
}
}
}
