tsai
/
ImageSharp
mirror of https://github.com/SixLabors/ImageSharp
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Add quantizer property tests

pull/2500/head
James Jackson-South 3 years ago
parent
d196b229dc
commit
fc7219d1fa
4 changed files with 95 additions and 78 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 39
      tests/ImageSharp.Tests/Formats/Bmp/BmpEncoderTests.cs
  2. 3
      tests/ImageSharp.Tests/Formats/Gif/GifEncoderTests.cs
  3. 55
      tests/ImageSharp.Tests/Formats/Png/PngEncoderTests.cs
  4. 76
      tests/ImageSharp.Tests/Formats/Tiff/TiffEncoderTests.cs

39
tests/ImageSharp.Tests/Formats/Bmp/BmpEncoderTests.cs
View File

@ -46,17 +46,20 @@ public class BmpEncoderTests
{ Bit32Rgb, BmpBitsPerPixel.Pixel32 }
};
[Fact]
public void BmpEncoderDefaultInstanceHasQuantizer() => Assert.NotNull(BmpEncoder.Quantizer);
[Theory]
[MemberData(nameof(RatioFiles))]
public void Encode_PreserveRatio(string imagePath, int xResolution, int yResolution, PixelResolutionUnit resolutionUnit)
{
var testFile = TestFile.Create(imagePath);
TestFile testFile = TestFile.Create(imagePath);
using Image<Rgba32> input = testFile.CreateRgba32Image();
using var memStream = new MemoryStream();
using MemoryStream memStream = new();
input.Save(memStream, BmpEncoder);
memStream.Position = 0;
using var output = Image.Load<Rgba32>(memStream);
using Image<Rgba32> output = Image.Load<Rgba32>(memStream);
ImageMetadata meta = output.Metadata;
Assert.Equal(xResolution, meta.HorizontalResolution);
Assert.Equal(yResolution, meta.VerticalResolution);
@ -67,13 +70,13 @@ public class BmpEncoderTests
[MemberData(nameof(BmpBitsPerPixelFiles))]
public void Encode_PreserveBitsPerPixel(string imagePath, BmpBitsPerPixel bmpBitsPerPixel)
{
var testFile = TestFile.Create(imagePath);
TestFile testFile = TestFile.Create(imagePath);
using Image<Rgba32> input = testFile.CreateRgba32Image();
using var memStream = new MemoryStream();
using MemoryStream memStream = new();
input.Save(memStream, BmpEncoder);
memStream.Position = 0;
using var output = Image.Load<Rgba32>(memStream);
using Image<Rgba32> output = Image.Load<Rgba32>(memStream);
BmpMetadata meta = output.Metadata.GetBmpMetadata();
Assert.Equal(bmpBitsPerPixel, meta.BitsPerPixel);
@ -196,8 +199,8 @@ public class BmpEncoderTests
where TPixel : unmanaged, IPixel<TPixel>
{
// arrange
var encoder = new BmpEncoder() { BitsPerPixel = bitsPerPixel };
using var memoryStream = new MemoryStream();
BmpEncoder encoder = new() { BitsPerPixel = bitsPerPixel };
using MemoryStream memoryStream = new();
using Image<TPixel> input = provider.GetImage(BmpDecoder.Instance);
// act
@ -205,7 +208,7 @@ public class BmpEncoderTests
memoryStream.Position = 0;
// assert
using var actual = Image.Load<TPixel>(memoryStream);
using Image<TPixel> actual = Image.Load<TPixel>(memoryStream);
ImageSimilarityReport similarityReport = ImageComparer.Exact.CompareImagesOrFrames(input, actual);
Assert.True(similarityReport.IsEmpty, "encoded image does not match reference image");
}
@ -218,8 +221,8 @@ public class BmpEncoderTests
where TPixel : unmanaged, IPixel<TPixel>
{
// arrange
var encoder = new BmpEncoder() { BitsPerPixel = bitsPerPixel };
using var memoryStream = new MemoryStream();
BmpEncoder encoder = new() { BitsPerPixel = bitsPerPixel };
using MemoryStream memoryStream = new();
using Image<TPixel> input = provider.GetImage(BmpDecoder.Instance);
// act
@ -227,7 +230,7 @@ public class BmpEncoderTests
memoryStream.Position = 0;
// assert
using var actual = Image.Load<TPixel>(memoryStream);
using Image<TPixel> actual = Image.Load<TPixel>(memoryStream);
ImageSimilarityReport similarityReport = ImageComparer.Exact.CompareImagesOrFrames(input, actual);
Assert.True(similarityReport.IsEmpty, "encoded image does not match reference image");
}
@ -266,7 +269,7 @@ public class BmpEncoderTests
}
using Image<TPixel> image = provider.GetImage();
var encoder = new BmpEncoder
BmpEncoder encoder = new()
{
BitsPerPixel = BmpBitsPerPixel.Pixel8,
Quantizer = new WuQuantizer()
@ -298,7 +301,7 @@ public class BmpEncoderTests
}
using Image<TPixel> image = provider.GetImage();
var encoder = new BmpEncoder
BmpEncoder encoder = new()
{
BitsPerPixel = BmpBitsPerPixel.Pixel8,
Quantizer = new OctreeQuantizer()
@ -333,11 +336,11 @@ public class BmpEncoderTests
ImageSharp.Metadata.Profiles.Icc.IccProfile expectedProfile = input.Metadata.IccProfile;
byte[] expectedProfileBytes = expectedProfile.ToByteArray();
using var memStream = new MemoryStream();
using MemoryStream memStream = new();
input.Save(memStream, new BmpEncoder());
memStream.Position = 0;
using var output = Image.Load<Rgba32>(memStream);
using Image<Rgba32> output = Image.Load<Rgba32>(memStream);
ImageSharp.Metadata.Profiles.Icc.IccProfile actualProfile = output.Metadata.IccProfile;
byte[] actualProfileBytes = actualProfile.ToByteArray();
@ -353,7 +356,7 @@ public class BmpEncoderTests
Exception exception = Record.Exception(() =>
{
using Image image = new Image<Rgba32>(width, height);
using var memStream = new MemoryStream();
using MemoryStream memStream = new();
image.Save(memStream, BmpEncoder);
});
@ -387,7 +390,7 @@ public class BmpEncoderTests
image.Mutate(c => c.MakeOpaque());
}
var encoder = new BmpEncoder
BmpEncoder encoder = new()
{
BitsPerPixel = bitsPerPixel,
SupportTransparency = supportTransparency,

3
tests/ImageSharp.Tests/Formats/Gif/GifEncoderTests.cs
View File

@ -33,6 +33,9 @@ public class GifEncoderTests
}
}
[Fact]
public void GifEncoderDefaultInstanceHasNullQuantizer() => Assert.Null(new GifEncoder().Quantizer);
[Theory]
[WithTestPatternImages(100, 100, TestPixelTypes, false)]
[WithTestPatternImages(100, 100, TestPixelTypes, false)]

55
tests/ImageSharp.Tests/Formats/Png/PngEncoderTests.cs
View File

@ -99,6 +99,9 @@ public partial class PngEncoderTests
{ TestImages.Png.Ratio4x1, 4, 1, PixelResolutionUnit.AspectRatio }
};
[Fact]
public void PngEncoderDefaultInstanceHasNullQuantizer() => Assert.Null(PngEncoder.Quantizer);
[Theory]
[WithFile(TestImages.Png.Palette8Bpp, nameof(PngColorTypes), PixelTypes.Rgba32)]
[WithTestPatternImages(nameof(PngColorTypes), 48, 24, PixelTypes.Rgba32)]
@ -129,8 +132,8 @@ public partial class PngEncoderTests
PngFilterMethod.Adaptive,
PngBitDepth.Bit8,
interlaceMode,
appendPixelType: true,
appendPngColorType: true);
appendPngColorType: true,
appendPixelType: true);
}
}
@ -321,7 +324,7 @@ public partial class PngEncoderTests
where TPixel : unmanaged, IPixel<TPixel>
{
using Image<TPixel> image = provider.GetImage();
using var ms = new MemoryStream();
using MemoryStream ms = new();
image.Save(ms, PngEncoder);
byte[] data = ms.ToArray().Take(8).ToArray();
@ -344,13 +347,13 @@ public partial class PngEncoderTests
[MemberData(nameof(RatioFiles))]
public void Encode_PreserveRatio(string imagePath, int xResolution, int yResolution, PixelResolutionUnit resolutionUnit)
{
var testFile = TestFile.Create(imagePath);
TestFile testFile = TestFile.Create(imagePath);
using Image<Rgba32> input = testFile.CreateRgba32Image();
using var memStream = new MemoryStream();
using MemoryStream memStream = new();
input.Save(memStream, PngEncoder);
memStream.Position = 0;
using var output = Image.Load<Rgba32>(memStream);
using Image<Rgba32> output = Image.Load<Rgba32>(memStream);
ImageMetadata meta = output.Metadata;
Assert.Equal(xResolution, meta.HorizontalResolution);
Assert.Equal(yResolution, meta.VerticalResolution);
@ -361,13 +364,13 @@ public partial class PngEncoderTests
[MemberData(nameof(PngBitDepthFiles))]
public void Encode_PreserveBits(string imagePath, PngBitDepth pngBitDepth)
{
var testFile = TestFile.Create(imagePath);
TestFile testFile = TestFile.Create(imagePath);
using Image<Rgba32> input = testFile.CreateRgba32Image();
using var memStream = new MemoryStream();
using MemoryStream memStream = new();
input.Save(memStream, PngEncoder);
memStream.Position = 0;
using var output = Image.Load<Rgba32>(memStream);
using Image<Rgba32> output = Image.Load<Rgba32>(memStream);
PngMetadata meta = output.Metadata.GetPngMetadata();
Assert.Equal(pngBitDepth, meta.BitDepth);
@ -380,8 +383,8 @@ public partial class PngEncoderTests
public void Encode_WithPngTransparentColorBehaviorClear_Works(PngColorType colorType)
{
// arrange
var image = new Image<Rgba32>(50, 50);
var encoder = new PngEncoder()
Image<Rgba32> image = new(50, 50);
PngEncoder encoder = new()
{
TransparentColorMode = PngTransparentColorMode.Clear,
ColorType = colorType
@ -391,7 +394,7 @@ public partial class PngEncoderTests
{
for (int y = 0; y < image.Height; y++)
{
System.Span<Rgba32> rowSpan = accessor.GetRowSpan(y);
Span<Rgba32> rowSpan = accessor.GetRowSpan(y);
// Half of the test image should be transparent.
if (y > 25)
@ -407,12 +410,12 @@ public partial class PngEncoderTests
});
// act
using var memStream = new MemoryStream();
using MemoryStream memStream = new();
image.Save(memStream, encoder);
// assert
memStream.Position = 0;
using var actual = Image.Load<Rgba32>(memStream);
using Image<Rgba32> actual = Image.Load<Rgba32>(memStream);
Rgba32 expectedColor = Color.Blue;
if (colorType is PngColorType.Grayscale or PngColorType.GrayscaleWithAlpha)
{
@ -424,7 +427,7 @@ public partial class PngEncoderTests
{
for (int y = 0; y < accessor.Height; y++)
{
System.Span<Rgba32> rowSpan = accessor.GetRowSpan(y);
Span<Rgba32> rowSpan = accessor.GetRowSpan(y);
if (y > 25)
{
@ -443,15 +446,15 @@ public partial class PngEncoderTests
[MemberData(nameof(PngTrnsFiles))]
public void Encode_PreserveTrns(string imagePath, PngBitDepth pngBitDepth, PngColorType pngColorType)
{
var testFile = TestFile.Create(imagePath);
TestFile testFile = TestFile.Create(imagePath);
using Image<Rgba32> input = testFile.CreateRgba32Image();
PngMetadata inMeta = input.Metadata.GetPngMetadata();
Assert.True(inMeta.HasTransparency);
using var memStream = new MemoryStream();
using MemoryStream memStream = new();
input.Save(memStream, PngEncoder);
memStream.Position = 0;
using var output = Image.Load<Rgba32>(memStream);
using Image<Rgba32> output = Image.Load<Rgba32>(memStream);
PngMetadata outMeta = output.Metadata.GetPngMetadata();
Assert.True(outMeta.HasTransparency);
@ -501,8 +504,8 @@ public partial class PngEncoderTests
PngFilterMethod.Adaptive,
PngBitDepth.Bit8,
interlaceMode,
appendPixelType: true,
appendPngColorType: true);
appendPngColorType: true,
appendPixelType: true);
}
}
@ -523,8 +526,8 @@ public partial class PngEncoderTests
PngFilterMethod.Adaptive,
PngBitDepth.Bit8,
interlaceMode,
appendPixelType: true,
appendPngColorType: true);
appendPngColorType: true,
appendPixelType: true);
}
}
@ -538,8 +541,8 @@ public partial class PngEncoderTests
public void EncodeFixesInvalidOptions()
{
// https://github.com/SixLabors/ImageSharp/issues/935
using var ms = new MemoryStream();
var testFile = TestFile.Create(TestImages.Png.Issue935);
using MemoryStream ms = new();
TestFile testFile = TestFile.Create(TestImages.Png.Issue935);
using Image<Rgba32> image = testFile.CreateRgba32Image(PngDecoder.Instance);
image.Save(ms, new PngEncoder { ColorType = PngColorType.RgbWithAlpha });
@ -563,7 +566,7 @@ public partial class PngEncoderTests
where TPixel : unmanaged, IPixel<TPixel>
{
using Image<TPixel> image = provider.GetImage();
var encoder = new PngEncoder
PngEncoder encoder = new()
{
ColorType = pngColorType,
FilterMethod = pngFilterMethod,
@ -581,7 +584,7 @@ public partial class PngEncoderTests
string pngBitDepthInfo = appendPngBitDepth ? bitDepth.ToString() : string.Empty;
string pngInterlaceModeInfo = interlaceMode != PngInterlaceMode.None ? $"_{interlaceMode}" : string.Empty;
string debugInfo = $"{pngColorTypeInfo}{pngFilterMethodInfo}{compressionLevelInfo}{paletteSizeInfo}{pngBitDepthInfo}{pngInterlaceModeInfo}";
string debugInfo = pngColorTypeInfo + pngFilterMethodInfo + compressionLevelInfo + paletteSizeInfo + pngBitDepthInfo + pngInterlaceModeInfo;
string actualOutputFile = provider.Utility.SaveTestOutputFile(image, "png", encoder, debugInfo, appendPixelType);

76
tests/ImageSharp.Tests/Formats/Tiff/TiffEncoderTests.cs
View File

@ -11,6 +11,9 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff;
[Trait("Format", "Tiff")]
public class TiffEncoderTests : TiffEncoderBaseTester
{
[Fact]
public void TiffEncoderDefaultInstanceHasQuantizer() => Assert.NotNull(new TiffEncoder().Quantizer);
[Theory]
[InlineData(null, TiffBitsPerPixel.Bit24)]
[InlineData(TiffPhotometricInterpretation.Rgb, TiffBitsPerPixel.Bit24)]
@ -28,18 +31,18 @@ public class TiffEncoderTests : TiffEncoderBaseTester
public void EncoderOptions_SetPhotometricInterpretation_Works(TiffPhotometricInterpretation? photometricInterpretation, TiffBitsPerPixel expectedBitsPerPixel)
{
// arrange
var tiffEncoder = new TiffEncoder { PhotometricInterpretation = photometricInterpretation };
TiffEncoder tiffEncoder = new() { PhotometricInterpretation = photometricInterpretation };
using Image input = expectedBitsPerPixel is TiffBitsPerPixel.Bit16
? new Image<L16>(10, 10)
: new Image<Rgb24>(10, 10);
using var memStream = new MemoryStream();
using MemoryStream memStream = new();
// act
input.Save(memStream, tiffEncoder);
// assert
memStream.Position = 0;
using var output = Image.Load<Rgba32>(memStream);
using Image<Rgba32> output = Image.Load<Rgba32>(memStream);
TiffFrameMetadata frameMetaData = output.Frames.RootFrame.Metadata.GetTiffMetadata();
Assert.Equal(expectedBitsPerPixel, frameMetaData.BitsPerPixel);
Assert.Equal(TiffCompression.None, frameMetaData.Compression);
@ -54,16 +57,17 @@ public class TiffEncoderTests : TiffEncoderBaseTester
public void EncoderOptions_SetBitPerPixel_Works(TiffBitsPerPixel bitsPerPixel)
{
// arrange
var tiffEncoder = new TiffEncoder { BitsPerPixel = bitsPerPixel };
TiffEncoder tiffEncoder = new()
{ BitsPerPixel = bitsPerPixel };
using Image input = new Image<Rgb24>(10, 10);
using var memStream = new MemoryStream();
using MemoryStream memStream = new();
// act
input.Save(memStream, tiffEncoder);
// assert
memStream.Position = 0;
using var output = Image.Load<Rgba32>(memStream);
using Image<Rgba32> output = Image.Load<Rgba32>(memStream);
TiffFrameMetadata frameMetaData = output.Frames.RootFrame.Metadata.GetTiffMetadata();
Assert.Equal(bitsPerPixel, frameMetaData.BitsPerPixel);
@ -81,16 +85,17 @@ public class TiffEncoderTests : TiffEncoderBaseTester
public void EncoderOptions_UnsupportedBitPerPixel_DefaultTo24Bits(TiffBitsPerPixel bitsPerPixel)
{
// arrange
var tiffEncoder = new TiffEncoder { BitsPerPixel = bitsPerPixel };
TiffEncoder tiffEncoder = new()
{ BitsPerPixel = bitsPerPixel };
using Image input = new Image<Rgb24>(10, 10);
using var memStream = new MemoryStream();
using MemoryStream memStream = new();
// act
input.Save(memStream, tiffEncoder);
// assert
memStream.Position = 0;
using var output = Image.Load<Rgba32>(memStream);
using Image<Rgba32> output = Image.Load<Rgba32>(memStream);
TiffFrameMetadata frameMetaData = output.Frames.RootFrame.Metadata.GetTiffMetadata();
Assert.Equal(TiffBitsPerPixel.Bit24, frameMetaData.BitsPerPixel);
@ -103,16 +108,17 @@ public class TiffEncoderTests : TiffEncoderBaseTester
public void EncoderOptions_WithInvalidCompressionAndPixelTypeCombination_DefaultsToRgb(TiffPhotometricInterpretation photometricInterpretation, TiffCompression compression)
{
// arrange
var tiffEncoder = new TiffEncoder { PhotometricInterpretation = photometricInterpretation, Compression = compression };
TiffEncoder tiffEncoder = new()
{ PhotometricInterpretation = photometricInterpretation, Compression = compression };
using Image input = new Image<Rgb24>(10, 10);
using var memStream = new MemoryStream();
using MemoryStream memStream = new();
// act
input.Save(memStream, tiffEncoder);
// assert
memStream.Position = 0;
using var output = Image.Load<Rgba32>(memStream);
using Image<Rgba32> output = Image.Load<Rgba32>(memStream);
TiffFrameMetadata frameMetaData = output.Frames.RootFrame.Metadata.GetTiffMetadata();
Assert.Equal(TiffBitsPerPixel.Bit24, frameMetaData.BitsPerPixel);
@ -149,18 +155,19 @@ public class TiffEncoderTests : TiffEncoderBaseTester
TiffCompression expectedCompression)
{
// arrange
var tiffEncoder = new TiffEncoder { PhotometricInterpretation = photometricInterpretation, Compression = compression };
TiffEncoder tiffEncoder = new()
{ PhotometricInterpretation = photometricInterpretation, Compression = compression };
using Image input = expectedBitsPerPixel is TiffBitsPerPixel.Bit16
? new Image<L16>(10, 10)
: new Image<Rgb24>(10, 10);
using var memStream = new MemoryStream();
using MemoryStream memStream = new();
// act
input.Save(memStream, tiffEncoder);
// assert
memStream.Position = 0;
using var output = Image.Load<Rgba32>(memStream);
using Image<Rgba32> output = Image.Load<Rgba32>(memStream);
TiffFrameMetadata rootFrameMetaData = output.Frames.RootFrame.Metadata.GetTiffMetadata();
Assert.Equal(expectedBitsPerPixel, rootFrameMetaData.BitsPerPixel);
Assert.Equal(expectedCompression, rootFrameMetaData.Compression);
@ -178,16 +185,16 @@ public class TiffEncoderTests : TiffEncoderBaseTester
where TPixel : unmanaged, IPixel<TPixel>
{
// arrange
var tiffEncoder = new TiffEncoder();
TiffEncoder tiffEncoder = new();
using Image<TPixel> input = provider.GetImage();
using var memStream = new MemoryStream();
using MemoryStream memStream = new();
// act
input.Save(memStream, tiffEncoder);
// assert
memStream.Position = 0;
using var output = Image.Load<Rgba32>(memStream);
using Image<Rgba32> output = Image.Load<Rgba32>(memStream);
TiffFrameMetadata frameMetaData = output.Frames.RootFrame.Metadata.GetTiffMetadata();
Assert.Equal(expectedBitsPerPixel, frameMetaData.BitsPerPixel);
}
@ -196,17 +203,17 @@ public class TiffEncoderTests : TiffEncoderBaseTester
public void TiffEncoder_PreservesBitsPerPixel_WhenInputIsL8()
{
// arrange
var tiffEncoder = new TiffEncoder();
TiffEncoder tiffEncoder = new();
using Image input = new Image<L8>(10, 10);
using var memStream = new MemoryStream();
TiffBitsPerPixel expectedBitsPerPixel = TiffBitsPerPixel.Bit8;
using MemoryStream memStream = new();
const TiffBitsPerPixel expectedBitsPerPixel = TiffBitsPerPixel.Bit8;
// act
input.Save(memStream, tiffEncoder);
// assert
memStream.Position = 0;
using var output = Image.Load<Rgba32>(memStream);
using Image<Rgba32> output = Image.Load<Rgba32>(memStream);
TiffFrameMetadata frameMetaData = output.Frames.RootFrame.Metadata.GetTiffMetadata();
Assert.Equal(expectedBitsPerPixel, frameMetaData.BitsPerPixel);
}
@ -220,16 +227,16 @@ public class TiffEncoderTests : TiffEncoderBaseTester
where TPixel : unmanaged, IPixel<TPixel>
{
// arrange
var tiffEncoder = new TiffEncoder();
TiffEncoder tiffEncoder = new();
using Image<TPixel> input = provider.GetImage();
using var memStream = new MemoryStream();
using MemoryStream memStream = new();
// act
input.Save(memStream, tiffEncoder);
// assert
memStream.Position = 0;
using var output = Image.Load<Rgba32>(memStream);
using Image<Rgba32> output = Image.Load<Rgba32>(memStream);
Assert.Equal(expectedCompression, output.Frames.RootFrame.Metadata.GetTiffMetadata().Compression);
}
@ -242,16 +249,16 @@ public class TiffEncoderTests : TiffEncoderBaseTester
where TPixel : unmanaged, IPixel<TPixel>
{
// arrange
var tiffEncoder = new TiffEncoder();
TiffEncoder tiffEncoder = new();
using Image<TPixel> input = provider.GetImage();
using var memStream = new MemoryStream();
using MemoryStream memStream = new();
// act
input.Save(memStream, tiffEncoder);
// assert
memStream.Position = 0;
using var output = Image.Load<Rgba32>(memStream);
using Image<Rgba32> output = Image.Load<Rgba32>(memStream);
TiffFrameMetadata frameMetadata = output.Frames.RootFrame.Metadata.GetTiffMetadata();
Assert.Equal(expectedPredictor, frameMetadata.Predictor);
}
@ -261,8 +268,8 @@ public class TiffEncoderTests : TiffEncoderBaseTester
public void TiffEncoder_WritesIfdOffsetAtWordBoundary()
{
// arrange
var tiffEncoder = new TiffEncoder();
using var memStream = new MemoryStream();
TiffEncoder tiffEncoder = new();
using MemoryStream memStream = new();
using Image<Rgba32> image = new(1, 1);
byte[] expectedIfdOffsetBytes = { 12, 0 };
@ -286,16 +293,16 @@ public class TiffEncoderTests : TiffEncoderBaseTester
where TPixel : unmanaged, IPixel<TPixel>
{
// arrange
var encoder = new TiffEncoder() { Compression = compression, BitsPerPixel = TiffBitsPerPixel.Bit1 };
TiffEncoder encoder = new() { Compression = compression, BitsPerPixel = TiffBitsPerPixel.Bit1 };
using Image<TPixel> input = provider.GetImage();
using var memStream = new MemoryStream();
using MemoryStream memStream = new();
// act
input.Save(memStream, encoder);
// assert
memStream.Position = 0;
using var output = Image.Load<Rgba32>(memStream);
using Image<Rgba32> output = Image.Load<Rgba32>(memStream);
TiffFrameMetadata frameMetaData = output.Frames.RootFrame.Metadata.GetTiffMetadata();
Assert.Equal(TiffBitsPerPixel.Bit1, frameMetaData.BitsPerPixel);
Assert.Equal(expectedCompression, frameMetaData.Compression);
@ -545,7 +552,8 @@ public class TiffEncoderTests : TiffEncoderBaseTester
provider.LimitAllocatorBufferCapacity().InPixelsSqrt(200);
using Image<TPixel> image = provider.GetImage();
var encoder = new TiffEncoder { PhotometricInterpretation = photometricInterpretation };
TiffEncoder encoder = new()
{ PhotometricInterpretation = photometricInterpretation };
image.DebugSave(provider, encoder);
}
}

Write Preview
Loading…
Cancel
Save