public void TolerantComparer_VerifySimilarity_ModifiedImage()
{
Assert.Throws <ImageDifferenceIsOverThresholdException>(() =>
{
ImageComparer.Tolerant().VerifySimilarity(BaseImage, ModifiedImage);
});
}
public static Image <TPixel> CompareToOriginal <TPixel>(
this Image <TPixel> image,
ITestImageProvider provider)
where TPixel : struct, IPixel <TPixel>
{
return(CompareToOriginal(image, provider, ImageComparer.Tolerant()));
}
private void CompareMipMaps(MipMap[] mipMaps, string name)
{
string filename;
if (this.TextureType == TestTextureType.Flat)
{
string[] fileParts = Path.GetFileName(this.InputFile).Split(' ');
filename = fileParts[0];
}
else
{
filename = this.TextureType.ToString().ToLower();
if (!string.IsNullOrEmpty(name))
{
filename = $"{filename}-{name}";
}
}
filename = $"{filename}.png";
string baselinePath = Path.Combine(TestEnvironment.BaselineDirectoryFullPath, this.TextureType.ToString(), filename);
using var imageExpected = Image.Load <Rgba32>(baselinePath);
using Image testImage = mipMaps[0].GetImage();
using Image <Rgba32> imageActual = testImage.CloneAs <Rgba32>();
var comparer = ImageComparer.Tolerant(1F);
comparer.VerifySimilarity(imageExpected, imageActual);
}
public void ImageShouldApplyPixelateFilterInBox <TPixel>(TestImageProvider <TPixel> provider, int value)
where TPixel : struct, IPixel <TPixel>
{
using (Image <TPixel> source = provider.GetImage())
using (var image = source.Clone())
{
var bounds = new Rectangle(image.Width / 4, image.Height / 4, image.Width / 2, image.Height / 2);
image.Mutate(x => x.Pixelate(value, bounds));
image.DebugSave(provider, value);
for (int y = 0; y < image.Height; y++)
{
for (int x = 0; x < image.Width; x++)
{
int tx = x;
int ty = y;
TPixel sourceColor = source[tx, ty];
if (bounds.Contains(tx, ty))
{
int sourceX = tx - ((tx - bounds.Left) % value) + (value / 2);
int sourceY = ty - ((ty - bounds.Top) % value) + (value / 2);
sourceColor = image[sourceX, sourceY];
}
Assert.Equal(sourceColor, image[tx, ty]);
}
}
ImageComparer.Tolerant().VerifySimilarityIgnoreRegion(source, image, bounds);
}
}
// DEBUG ONLY!
// The PDF.js output should be saved by "tests\ImageSharp.Tests\Formats\Jpg\pdfjs\jpeg-converter.htm"
// into "\tests\Images\ActualOutput\JpegDecoderTests\"
//[Theory]
//[WithFile(TestImages.Jpeg.Progressive.Progress, PixelTypes.Rgba32, "PdfJsOriginal_progress.png")]
public void ValidateProgressivePdfJsOutput <TPixel>(TestImageProvider <TPixel> provider,
string pdfJsOriginalResultImage)
where TPixel : struct, IPixel <TPixel>
{
// tests\ImageSharp.Tests\Formats\Jpg\pdfjs\jpeg-converter.htm
string pdfJsOriginalResultPath = Path.Combine(
provider.Utility.GetTestOutputDir(),
pdfJsOriginalResultImage);
byte[] sourceBytes = TestFile.Create(TestImages.Jpeg.Progressive.Progress).Bytes;
provider.Utility.TestName = nameof(DecodeProgressiveJpegOutputName);
var comparer = ImageComparer.Tolerant(0, 0);
using (Image <TPixel> expectedImage = provider.GetReferenceOutputImage <TPixel>(appendPixelTypeToFileName: false))
using (var pdfJsOriginalResult = Image.Load(pdfJsOriginalResultPath))
using (var pdfJsPortResult = Image.Load(sourceBytes, PdfJsJpegDecoder))
{
ImageSimilarityReport originalReport = comparer.CompareImagesOrFrames(expectedImage, pdfJsOriginalResult);
ImageSimilarityReport portReport = comparer.CompareImagesOrFrames(expectedImage, pdfJsPortResult);
this.Output.WriteLine($"Difference for PDF.js ORIGINAL: {originalReport.DifferencePercentageString}");
this.Output.WriteLine($"Difference for PORT: {portReport.DifferencePercentageString}");
}
}
public void TolerantComparer_VerifySimilarity_TwoFramesImage()
{
Assert.Throws <ImageFramesMismatchException>(() =>
{
ImageComparer.Tolerant().VerifySimilarity(BaseImage, TwoFramesImage);
});
}
protected static void TestTiffEncoderCore <TPixel>(
TestImageProvider <TPixel> provider,
TiffBitsPerPixel?bitsPerPixel,
TiffPhotometricInterpretation photometricInterpretation,
TiffCompression compression = TiffCompression.None,
TiffPredictor predictor = TiffPredictor.None,
bool useExactComparer = true,
float compareTolerance = 0.001f,
IImageDecoder imageDecoder = null)
where TPixel : unmanaged, IPixel <TPixel>
{
using Image <TPixel> image = provider.GetImage();
var encoder = new TiffEncoder
{
PhotometricInterpretation = photometricInterpretation,
BitsPerPixel = bitsPerPixel,
Compression = compression,
HorizontalPredictor = predictor
};
// Does DebugSave & load reference CompareToReferenceInput():
image.VerifyEncoder(
provider,
"tiff",
bitsPerPixel,
encoder,
useExactComparer ? ImageComparer.Exact : ImageComparer.Tolerant(compareTolerance),
referenceDecoder: imageDecoder ?? ReferenceDecoder);
}
public void TolerantComparer_VerifySimilarity_SmallerImage()
{
Assert.Throws <ImageDimensionsMismatchException>(() =>
{
ImageComparer.Tolerant().VerifySimilarity(BaseImage, SmallerImage);
});
}
public void TolerantComparer_VerifySimilarityIgnoreRegionNone_ModifiedImage()
{
Assert.Throws <ImageDifferenceIsOverThresholdException>(() =>
{
ImageComparer.Tolerant().VerifySimilarityIgnoreRegion(BaseImage, ModifiedImage, new Rectangle(0, 0, 0, 0));
});
}
public static void CompareWithReferenceDecoder <TPixel>(
TestImageProvider <TPixel> provider,
Image <TPixel> image,
bool useExactComparer = true,
float compareTolerance = 0.01f)
where TPixel : struct, IPixel <TPixel>
{
string path = TestImageProvider <TPixel> .GetFilePathOrNull(provider);
if (path == null)
{
throw new InvalidOperationException("CompareToOriginal() works only with file providers!");
}
var testFile = TestFile.Create(path);
Image <Rgba32> magickImage = DecodeWithMagick <Rgba32>(Configuration.Default, new FileInfo(testFile.FullPath));
if (useExactComparer)
{
ImageComparer.Exact.VerifySimilarity(magickImage, image);
}
else
{
ImageComparer.Tolerant(compareTolerance).VerifySimilarity(magickImage, image);
}
}
private static void TestPngEncoderCore <TPixel>(
TestImageProvider <TPixel> provider,
PngColorType pngColorType,
PngFilterMethod pngFilterMethod,
int compressionLevel = 6,
int paletteSize = 255,
bool appendPngColorType = false,
bool appendPngFilterMethod = false,
bool appendPixelType = false,
bool appendCompressionLevel = false,
bool appendPaletteSize = false)
where TPixel : struct, IPixel <TPixel>
{
using (Image <TPixel> image = provider.GetImage())
{
if (!HasAlpha(pngColorType))
{
image.Mutate(c => c.MakeOpaque());
}
var encoder = new PngEncoder
{
PngColorType = pngColorType,
PngFilterMethod = pngFilterMethod,
CompressionLevel = compressionLevel,
Quantizer = new WuQuantizer(paletteSize)
};
string pngColorTypeInfo = appendPngColorType ? pngColorType.ToString() : string.Empty;
string pngFilterMethodInfo = appendPngFilterMethod ? pngFilterMethod.ToString() : string.Empty;
string compressionLevelInfo = appendCompressionLevel ? $"_C{compressionLevel}" : string.Empty;
string paletteSizeInfo = appendPaletteSize ? $"_PaletteSize-{paletteSize}" : string.Empty;
string debugInfo = $"{pngColorTypeInfo}{pngFilterMethodInfo}{compressionLevelInfo}{paletteSizeInfo}";
//string referenceInfo = $"{pngColorTypeInfo}";
// Does DebugSave & load reference CompareToReferenceInput():
string actualOutputFile = ((ITestImageProvider)provider).Utility.SaveTestOutputFile(image, "png", encoder, debugInfo, appendPixelType);
if (TestEnvironment.IsMono)
{
// There are bugs in mono's System.Drawing implementation, reference decoders are not always reliable!
return;
}
IImageDecoder referenceDecoder = TestEnvironment.GetReferenceDecoder(actualOutputFile);
string referenceOutputFile = ((ITestImageProvider)provider).Utility.GetReferenceOutputFileName("png", debugInfo, appendPixelType, true);
using (var actualImage = Image.Load <TPixel>(actualOutputFile, referenceDecoder))
using (var referenceImage = Image.Load <TPixel>(referenceOutputFile, referenceDecoder))
{
float paletteToleranceHack = 80f / paletteSize;
paletteToleranceHack = paletteToleranceHack * paletteToleranceHack;
ImageComparer comparer = pngColorType == PngColorType.Palette
? ImageComparer.Tolerant(ToleranceThresholdForPaletteEncoder * paletteToleranceHack)
: ImageComparer.Exact;
comparer.VerifySimilarity(referenceImage, actualImage);
}
}
}
public static Image <TPixel> CompareToOriginal <TPixel>(
this Image <TPixel> image,
ITestImageProvider provider,
IImageDecoder referenceDecoder = null)
where TPixel : unmanaged, IPixel <TPixel>
{
return(CompareToOriginal(image, provider, ImageComparer.Tolerant(), referenceDecoder));
}
private static void TestTiffDecoder <TPixel>(TestImageProvider <TPixel> provider, IImageDecoder referenceDecoder = null, bool useExactComparer = true, float compareTolerance = 0.001f)
where TPixel : unmanaged, IPixel <TPixel>
{
using Image <TPixel> image = provider.GetImage(TiffDecoder);
image.DebugSave(provider);
image.CompareToOriginal(
provider,
useExactComparer ? ImageComparer.Exact : ImageComparer.Tolerant(compareTolerance),
referenceDecoder ?? ReferenceDecoder);
}
public void TolerantComparer_CompareImagesOrFrames_ModifiedImage()
{
var report = ImageComparer.Tolerant().CompareImagesOrFrames(BaseImage, ModifiedImage);
Assert.Equal(10000, report.Differences.Length);
Assert.False(report.IsEmpty);
Assert.Equal("0.1646%", report.DifferencePercentageString);
Assert.Equal(0.001646257f, report.TotalNormalizedDifference);
Assert.StartsWith("Total difference:", report.ToString());
}
static void RunTest(string providerDump)
{
TestImageProvider <TPixel> provider =
BasicSerializer.Deserialize <TestImageProvider <TPixel> >(providerDump);
using Image <TPixel> image = provider.GetImage(JpegDecoder);
image.DebugSave(provider);
provider.Utility.TestName = DecodeBaselineJpegOutputName;
image.CompareToReferenceOutput(ImageComparer.Tolerant(BaselineTolerance), provider, appendPixelTypeToFileName: false);
}
public void TolerantComparer_VerifySimilarity_SmallChangeImage()
{
var perPixelManhattanThresholdValue = ImageComparer.CalculatePerPixelManhattanThresholdValue(3, ImageComparer.DefaultPerPixelChannelManhattanThreshold);
ImageComparer.Tolerant(0, perPixelManhattanThresholdValue).VerifySimilarity(BaseImage, SmallChangeImage);
perPixelManhattanThresholdValue = ImageComparer.CalculatePerPixelManhattanThresholdValue(1, ImageComparer.DefaultPerPixelChannelManhattanThreshold);
Assert.Throws <ImageDifferenceIsOverThresholdException>(() =>
{
ImageComparer.Tolerant(0, perPixelManhattanThresholdValue).VerifySimilarity(BaseImage, SmallChangeImage);
});
}
private static ImageComparer GetComparer(int quality)
{
float tolerance = 0.01f; // ~1.0%
if (quality < 30)
{
tolerance = 0.02f; // ~2.0%
}
return(ImageComparer.Tolerant(tolerance));
}
private const float ProgressiveTolerance_PdfJs = 1.5f / 100; // PDF.js Progressive output is wrong on spectral level!
private ImageComparer GetImageComparerForOrigDecoder <TPixel>(TestImageProvider <TPixel> provider)
where TPixel : struct, IPixel <TPixel>
{
string file = provider.SourceFileOrDescription;
if (!CustomToleranceValues.TryGetValue(file, out float tolerance))
{
tolerance = file.ToLower().Contains("baseline") ? BaselineTolerance_Orig : ProgressiveTolerance_Orig;
}
return(ImageComparer.Tolerant(tolerance));
}
public void Encode_Lossy_WorksWithTestPattern <TPixel>(TestImageProvider <TPixel> provider)
where TPixel : unmanaged, IPixel <TPixel>
{
using Image <TPixel> image = provider.GetImage();
var encoder = new WebpEncoder()
{
FileFormat = WebpFileFormatType.Lossy
};
image.VerifyEncoder(provider, "webp", string.Empty, encoder, ImageComparer.Tolerant(0.04f));
}
public void JpegDecoder_IsNotBoundToSinglePixelType <TPixel>(TestImageProvider <TPixel> provider)
where TPixel : unmanaged, IPixel <TPixel>
{
using Image <TPixel> image = provider.GetImage(JpegDecoder);
image.DebugSave(provider);
provider.Utility.TestName = DecodeBaselineJpegOutputName;
image.CompareToReferenceOutput(
ImageComparer.Tolerant(BaselineTolerance),
provider,
appendPixelTypeToFileName: false);
}
public void JpegDecoder_IsNotBoundToSinglePixelType <TPixel>(TestImageProvider <TPixel> provider, bool useOldDecoder)
where TPixel : struct, IPixel <TPixel>
{
IImageDecoder decoder = useOldDecoder ? OrigJpegDecoder : PdfJsJpegDecoder;
using (Image <TPixel> image = provider.GetImage(decoder))
{
image.DebugSave(provider);
provider.Utility.TestName = DecodeBaselineJpegOutputName;
image.CompareToReferenceOutput(provider, ImageComparer.Tolerant(BaselineTolerance_PdfJs), appendPixelTypeToFileName: false);
}
}
public static void RunEncodeLossy_WithPeakImage()
{
var provider = TestImageProvider <Rgba32> .File(TestImageLossyFullPath);
using Image <Rgba32> image = provider.GetImage();
var encoder = new WebpEncoder()
{
FileFormat = WebpFileFormatType.Lossy
};
image.VerifyEncoder(provider, "webp", string.Empty, encoder, ImageComparer.Tolerant(0.04f));
}
private static ImageComparer GetImageComparer <TPixel>(TestImageProvider <TPixel> provider)
where TPixel : unmanaged, IPixel <TPixel>
{
string file = provider.SourceFileOrDescription;
if (!CustomToleranceValues.TryGetValue(file, out float tolerance))
{
bool baseline = file.IndexOf("baseline", StringComparison.OrdinalIgnoreCase) >= 0;
tolerance = baseline ? BaselineTolerance : ProgressiveTolerance;
}
return(ImageComparer.Tolerant(tolerance));
}
public void ImageShouldApplyGrayscaleFilterInBox <TPixel>(TestImageProvider <TPixel> provider, GrayscaleMode value)
where TPixel : struct, IPixel <TPixel>
{
using (Image <TPixel> source = provider.GetImage())
using (var image = source.Clone())
{
var bounds = new Rectangle(image.Width / 4, image.Height / 4, image.Width / 2, image.Height / 2);
image.Mutate(x => x.Grayscale(value, bounds));
image.DebugSave(provider, value.ToString());
ImageComparer.Tolerant().VerifySimilarityIgnoreRegion(source, image, bounds);
}
}
/// <summary>
/// Utility method for doing the following in one step:
/// 1. Executing an operation (taken as a delegate)
/// 2. Executing DebugSave()
/// 3. Executing CompareToReferenceOutput()
/// </summary>
internal static void VerifyOperation <TPixel>(
this TestImageProvider <TPixel> provider,
Action <Image <TPixel> > operation,
FormattableString testOutputDetails,
bool appendPixelTypeToFileName = true,
bool appendSourceFileOrDescription = true)
where TPixel : unmanaged, IPixel <TPixel>
=> provider.VerifyOperation(
ImageComparer.Tolerant(),
operation,
testOutputDetails,
appendPixelTypeToFileName,
appendSourceFileOrDescription);
public void ApplyDitherFilterInBox <TPixel>(TestImageProvider <TPixel> provider)
where TPixel : struct, IPixel <TPixel>
{
using (Image <TPixel> source = provider.GetImage())
using (Image <TPixel> image = source.Clone())
{
var bounds = new Rectangle(10, 10, image.Width / 2, image.Height / 2);
image.Mutate(x => x.Dither(DefaultDitherer, bounds));
image.DebugSave(provider);
ImageComparer.Tolerant().VerifySimilarityIgnoreRegion(source, image, bounds);
}
}
public void TolerantImageComparer_ApprovesSimilarityBelowTolerance <TPixel>(TestImageProvider <TPixel> provider)
where TPixel : struct, IPixel <TPixel>
{
using (Image <TPixel> image = provider.GetImage())
{
using (Image <TPixel> clone = image.Clone())
{
ImagingTestCaseUtility.ModifyPixel(clone, 0, 0, 1);
var comparer = ImageComparer.Tolerant();
comparer.VerifySimilarity(image, clone);
}
}
}
public void DecodeProgressiveJpeg_PdfJs <TPixel>(TestImageProvider <TPixel> provider)
where TPixel : struct, IPixel <TPixel>
{
using (Image <TPixel> image = provider.GetImage(PdfJsJpegDecoder))
{
image.DebugSave(provider);
provider.Utility.TestName = DecodeProgressiveJpegOutputName;
image.CompareToReferenceOutput(
provider,
ImageComparer.Tolerant(ProgressiveTolerance_PdfJs),
appendPixelTypeToFileName: false);
}
}
public void ImageShouldApplyBinaryThresholdInBox <TPixel>(TestImageProvider <TPixel> provider, float value)
where TPixel : struct, IPixel <TPixel>
{
using (Image <TPixel> source = provider.GetImage())
using (var image = source.Clone())
{
var bounds = new Rectangle(10, 10, image.Width / 2, image.Height / 2);
image.Mutate(x => x.BinaryThreshold(value, bounds));
image.DebugSave(provider, value);
ImageComparer.Tolerant().VerifySimilarityIgnoreRegion(source, image, bounds);
}
}
public void ApplyOilPaintFilterInBox <TPixel>(TestImageProvider <TPixel> provider, int levels, int brushSize)
where TPixel : struct, IPixel <TPixel>
{
using (Image <TPixel> source = provider.GetImage())
using (Image <TPixel> image = source.Clone())
{
var bounds = new Rectangle(10, 10, image.Width / 2, image.Height / 2);
image.Mutate(x => x.OilPaint(levels, brushSize, bounds));
image.DebugSave(provider, string.Join("-", levels, brushSize));
ImageComparer.Tolerant().VerifySimilarityIgnoreRegion(source, image, bounds);
}
}
