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); } }