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

Add Compression, PhotometricInterpretation and Predictor to TiffFrameMetadata

pull/1553/head
Brian Popow 5 years ago
parent
d22692ee8f
commit
11a4e2027b
6 changed files with 134 additions and 59 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 27
      src/ImageSharp/Formats/Tiff/TiffDecoderOptionsParser.cs
  2. 15
      src/ImageSharp/Formats/Tiff/TiffEncoderCore.cs
  3. 58
      src/ImageSharp/Formats/Tiff/TiffFrameMetadata.cs
  4. 2
      src/ImageSharp/Metadata/Profiles/Exif/ExifProfile.cs
  5. 34
      tests/ImageSharp.Tests/Formats/Tiff/TiffEncoderTests.cs
  6. 57
      tests/ImageSharp.Tests/Formats/Tiff/TiffMetadataTests.cs

27
src/ImageSharp/Formats/Tiff/TiffDecoderOptionsParser.cs
View File

@ -14,8 +14,6 @@ namespace SixLabors.ImageSharp.Formats.Tiff
/// </summary> /// </summary>
internal static class TiffDecoderOptionsParser internal static class TiffDecoderOptionsParser
{ {
private const TiffPredictor DefaultPredictor = TiffPredictor.None;
private const TiffPlanarConfiguration DefaultPlanarConfiguration = TiffPlanarConfiguration.Chunky; private const TiffPlanarConfiguration DefaultPlanarConfiguration = TiffPlanarConfiguration.Chunky;
/// <summary> /// <summary>
@ -23,8 +21,8 @@ namespace SixLabors.ImageSharp.Formats.Tiff
/// </summary> /// </summary>
/// <param name="options">The options.</param> /// <param name="options">The options.</param>
/// <param name="exifProfile">The exif profile of the frame to decode.</param> /// <param name="exifProfile">The exif profile of the frame to decode.</param>
/// <param name="entries">The IFD entries container to read the image format information for.</param> /// <param name="frameMetadata">The IFD entries container to read the image format information for current frame.</param>
public static void VerifyAndParse(this TiffDecoderCore options, ExifProfile exifProfile, TiffFrameMetadata entries) public static void VerifyAndParse(this TiffDecoderCore options, ExifProfile exifProfile, TiffFrameMetadata frameMetadata)
{ {
if (exifProfile.GetValue(ExifTag.TileOffsets)?.Value != null) if (exifProfile.GetValue(ExifTag.TileOffsets)?.Value != null)
{ {
@ -42,8 +40,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff
TiffThrowHelper.ThrowNotSupported("The lower-order bits of the byte FillOrder is not supported."); TiffThrowHelper.ThrowNotSupported("The lower-order bits of the byte FillOrder is not supported.");
} }
TiffPredictor predictor = (TiffPredictor?)exifProfile.GetValue(ExifTag.Predictor)?.Value ?? DefaultPredictor; if (frameMetadata.Predictor == TiffPredictor.FloatingPoint)
if (predictor == TiffPredictor.FloatingPoint)
{ {
TiffThrowHelper.ThrowNotSupported("TIFF images with FloatingPoint horizontal predictor are not supported."); TiffThrowHelper.ThrowNotSupported("TIFF images with FloatingPoint horizontal predictor are not supported.");
} }
@ -68,14 +65,13 @@ namespace SixLabors.ImageSharp.Formats.Tiff
VerifyRequiredFieldsArePresent(exifProfile); VerifyRequiredFieldsArePresent(exifProfile);
options.PlanarConfiguration = (TiffPlanarConfiguration?)exifProfile.GetValue(ExifTag.PlanarConfiguration)?.Value ?? DefaultPlanarConfiguration; options.PlanarConfiguration = (TiffPlanarConfiguration?)exifProfile.GetValue(ExifTag.PlanarConfiguration)?.Value ?? DefaultPlanarConfiguration;
options.Predictor = predictor; options.Predictor = frameMetadata.Predictor ?? TiffFrameMetadata.DefaultPredictor;
options.PhotometricInterpretation = exifProfile.GetValue(ExifTag.PhotometricInterpretation) != null ? options.PhotometricInterpretation = frameMetadata.PhotometricInterpretation ?? TiffFrameMetadata.DefaultPhotometricInterpretation;
(TiffPhotometricInterpretation)exifProfile.GetValue(ExifTag.PhotometricInterpretation).Value : TiffPhotometricInterpretation.BlackIsZero; options.BitsPerPixel = frameMetadata.BitsPerPixel != null ? (int)frameMetadata.BitsPerPixel.Value : (int)TiffFrameMetadata.DefaultBitsPerPixel;
options.BitsPerPixel = entries.BitsPerPixel != null ? (int)entries.BitsPerPixel.Value : (int)TiffBitsPerPixel.Bit24; options.BitsPerSample = GetBitsPerSample(frameMetadata.BitsPerPixel);
options.BitsPerSample = GetBitsPerSample(entries.BitsPerPixel);
options.ParseColorType(exifProfile);
ParseColorType(options, exifProfile); options.ParseCompression(frameMetadata.Compression, exifProfile);
ParseCompression(options, exifProfile);
} }
private static void VerifyRequiredFieldsArePresent(ExifProfile exifProfile) private static void VerifyRequiredFieldsArePresent(ExifProfile exifProfile)
@ -222,9 +218,8 @@ namespace SixLabors.ImageSharp.Formats.Tiff
} }
} }
private static void ParseCompression(this TiffDecoderCore options, ExifProfile exifProfile) private static void ParseCompression(this TiffDecoderCore options, TiffCompression? compression, ExifProfile exifProfile)
{ {
TiffCompression compression = exifProfile.GetValue(ExifTag.Compression) != null ? (TiffCompression)exifProfile.GetValue(ExifTag.Compression).Value : TiffCompression.None;
switch (compression) switch (compression)
{ {
case TiffCompression.None: case TiffCompression.None:

15
src/ImageSharp/Formats/Tiff/TiffEncoderCore.cs
View File

@ -111,19 +111,12 @@ namespace SixLabors.ImageSharp.Formats.Tiff
: rootFramePhotometricInterpretation; : rootFramePhotometricInterpretation;
ImageFrameMetadata rootFrameMetaData = image.Frames.RootFrame.Metadata; ImageFrameMetadata rootFrameMetaData = image.Frames.RootFrame.Metadata;
ExifProfile rootFrameExifProfile = image.Frames.RootFrame.Metadata.ExifProfile; TiffFrameMetadata rootFrameTiffMetaData = rootFrameMetaData.GetTiffMetadata();
TiffBitsPerPixel? rootFrameBitsPerPixel = rootFrameMetaData.GetTiffMetadata().BitsPerPixel; TiffBitsPerPixel? rootFrameBitsPerPixel = rootFrameTiffMetaData.BitsPerPixel;
// If the user has not chosen a predictor or compression, set the values from the decoded image, if present. // If the user has not chosen a predictor or compression, set the values from the decoded image, if present.
if (!this.HorizontalPredictor.HasValue && rootFrameExifProfile?.GetValue(ExifTag.Predictor) != null) this.HorizontalPredictor ??= rootFrameTiffMetaData.Predictor;
{ this.CompressionType ??= rootFrameTiffMetaData.Compression;
this.HorizontalPredictor = (TiffPredictor)rootFrameExifProfile?.GetValue(ExifTag.Predictor).Value;
}
if (!this.CompressionType.HasValue && rootFrameExifProfile?.GetValue(ExifTag.Compression) != null)
{
this.CompressionType = (TiffCompression)rootFrameExifProfile?.GetValue(ExifTag.Compression).Value;
}
this.SetBitsPerPixel(rootFrameBitsPerPixel, image.PixelType.BitsPerPixel, photometricInterpretation); this.SetBitsPerPixel(rootFrameBitsPerPixel, image.PixelType.BitsPerPixel, photometricInterpretation);
this.SetPhotometricInterpretation(photometricInterpretation); this.SetPhotometricInterpretation(photometricInterpretation);

58
src/ImageSharp/Formats/Tiff/TiffFrameMetadata.cs
View File

@ -1,6 +1,7 @@
// Copyright (c) Six Labors. // Copyright (c) Six Labors.
// Licensed under the Apache License, Version 2.0. // Licensed under the Apache License, Version 2.0.
using SixLabors.ImageSharp.Formats.Tiff.Constants;
using SixLabors.ImageSharp.Metadata.Profiles.Exif; using SixLabors.ImageSharp.Metadata.Profiles.Exif;
namespace SixLabors.ImageSharp.Formats.Tiff namespace SixLabors.ImageSharp.Formats.Tiff
@ -10,6 +11,26 @@ namespace SixLabors.ImageSharp.Formats.Tiff
/// </summary> /// </summary>
public class TiffFrameMetadata : IDeepCloneable public class TiffFrameMetadata : IDeepCloneable
{ {
/// <summary>
/// The default predictor is None.
/// </summary>
public const TiffPredictor DefaultPredictor = TiffPredictor.None;
/// <summary>
/// The default bits per pixel is Bit24.
/// </summary>
public const TiffBitsPerPixel DefaultBitsPerPixel = TiffBitsPerPixel.Bit24;
/// <summary>
/// The default compression is None.
/// </summary>
public const TiffCompression DefaultCompression = TiffCompression.None;
/// <summary>
/// The default photometric interpretation is BlackIsZero.
/// </summary>
public const TiffPhotometricInterpretation DefaultPhotometricInterpretation = TiffPhotometricInterpretation.BlackIsZero;
/// <summary> /// <summary>
/// Initializes a new instance of the <see cref="TiffFrameMetadata"/> class. /// Initializes a new instance of the <see cref="TiffFrameMetadata"/> class.
/// </summary> /// </summary>
@ -28,6 +49,21 @@ namespace SixLabors.ImageSharp.Formats.Tiff
/// </summary> /// </summary>
public TiffBitsPerPixel? BitsPerPixel { get; set; } public TiffBitsPerPixel? BitsPerPixel { get; set; }
/// <summary>
/// Gets or sets the compression scheme used on the image data.
/// </summary>
public TiffCompression? Compression { get; set; }
/// <summary>
/// Gets or sets the color space of the image data.
/// </summary>
public TiffPhotometricInterpretation? PhotometricInterpretation { get; set; }
/// <summary>
/// Gets or sets a mathematical operator that is applied to the image data before an encoding scheme is applied.
/// </summary>
public TiffPredictor? Predictor { get; set; }
/// <summary> /// <summary>
/// Returns a new <see cref="TiffFrameMetadata"/> instance parsed from the given Exif profile. /// Returns a new <see cref="TiffFrameMetadata"/> instance parsed from the given Exif profile.
/// </summary> /// </summary>
@ -52,6 +88,13 @@ namespace SixLabors.ImageSharp.Formats.Tiff
ushort[] bitsPerSample = profile.GetValue(ExifTag.BitsPerSample)?.Value; ushort[] bitsPerSample = profile.GetValue(ExifTag.BitsPerSample)?.Value;
meta.BitsPerPixel = BitsPerPixelFromBitsPerSample(bitsPerSample); meta.BitsPerPixel = BitsPerPixelFromBitsPerSample(bitsPerSample);
meta.Compression = (TiffCompression?)profile.GetValue(ExifTag.Compression)?.Value ?? DefaultCompression;
meta.PhotometricInterpretation = (TiffPhotometricInterpretation?)profile.GetValue(ExifTag.PhotometricInterpretation)?.Value ?? DefaultPhotometricInterpretation;
meta.Predictor = (TiffPredictor?)profile.GetValue(ExifTag.Predictor)?.Value ?? DefaultPredictor;
profile.RemoveValue(ExifTag.Compression);
profile.RemoveValue(ExifTag.PhotometricInterpretation);
profile.RemoveValue(ExifTag.Predictor);
} }
/// <summary> /// <summary>
@ -63,7 +106,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff
{ {
if (bitsPerSample == null) if (bitsPerSample == null)
{ {
return TiffBitsPerPixel.Bit24; return DefaultBitsPerPixel;
} }
int bitsPerPixel = 0; int bitsPerPixel = 0;
@ -76,6 +119,17 @@ namespace SixLabors.ImageSharp.Formats.Tiff
} }
/// <inheritdoc/> /// <inheritdoc/>
public IDeepCloneable DeepClone() => new TiffFrameMetadata(this); public IDeepCloneable DeepClone()
{
var clone = new TiffFrameMetadata
{
BitsPerPixel = this.BitsPerPixel,
Compression = this.Compression,
PhotometricInterpretation = this.PhotometricInterpretation,
Predictor = this.Predictor
};
return clone;
}
} }
} }

2
src/ImageSharp/Metadata/Profiles/Exif/ExifProfile.cs
View File

@ -167,7 +167,7 @@ namespace SixLabors.ImageSharp.Metadata.Profiles.Exif
/// </summary> /// </summary>
/// <param name="tag">The tag of the EXIF value.</param> /// <param name="tag">The tag of the EXIF value.</param>
/// <returns> /// <returns>
/// The <see cref="bool"/>. /// True, if the value was removed, otherwise false.
/// </returns> /// </returns>
public bool RemoveValue(ExifTag tag) public bool RemoveValue(ExifTag tag)
{ {

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

@ -48,15 +48,14 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
// assert // assert
memStream.Position = 0; memStream.Position = 0;
using var output = Image.Load<Rgba32>(Configuration, memStream); using var output = Image.Load<Rgba32>(Configuration, memStream);
ExifProfile exifProfile = output.Frames.RootFrame.Metadata.ExifProfile; TiffFrameMetadata frameMetaData = output.Frames.RootFrame.Metadata.GetTiffMetadata();
var frameMetaData = TiffFrameMetadata.Parse(exifProfile);
Assert.Equal(expectedBitsPerPixel, frameMetaData.BitsPerPixel); Assert.Equal(expectedBitsPerPixel, frameMetaData.BitsPerPixel);
Assert.Equal(TiffCompression.None, (TiffCompression)exifProfile.GetValue(ExifTag.Compression).Value); Assert.Equal(TiffCompression.None, frameMetaData.Compression);
} }
[Theory] [Theory]
[InlineData(TiffBitsPerPixel.Bit24)] [InlineData(TiffBitsPerPixel.Bit24)]
[InlineData(TiffBitsPerPixel.Bit8)] [InlineData(TiffBitsPerPixel.Bit8)]
[InlineData(TiffBitsPerPixel.Bit4)] [InlineData(TiffBitsPerPixel.Bit4)]
[InlineData(TiffBitsPerPixel.Bit1)] [InlineData(TiffBitsPerPixel.Bit1)]
public void EncoderOptions_SetBitPerPixel_Works(TiffBitsPerPixel bitsPerPixel) public void EncoderOptions_SetBitPerPixel_Works(TiffBitsPerPixel bitsPerPixel)
@ -73,10 +72,9 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
memStream.Position = 0; memStream.Position = 0;
using var output = Image.Load<Rgba32>(Configuration, memStream); using var output = Image.Load<Rgba32>(Configuration, memStream);
ExifProfile exifProfile = output.Frames.RootFrame.Metadata.ExifProfile;
TiffFrameMetadata frameMetaData = output.Frames.RootFrame.Metadata.GetTiffMetadata(); TiffFrameMetadata frameMetaData = output.Frames.RootFrame.Metadata.GetTiffMetadata();
Assert.Equal(bitsPerPixel, frameMetaData.BitsPerPixel); Assert.Equal(bitsPerPixel, frameMetaData.BitsPerPixel);
Assert.Equal(TiffCompression.None, (TiffCompression)exifProfile.GetValue(ExifTag.Compression).Value); Assert.Equal(TiffCompression.None, frameMetaData.Compression);
} }
[Theory] [Theory]
@ -112,10 +110,9 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
// assert // assert
memStream.Position = 0; memStream.Position = 0;
using var output = Image.Load<Rgba32>(Configuration, memStream); using var output = Image.Load<Rgba32>(Configuration, memStream);
ExifProfile exifProfile = output.Frames.RootFrame.Metadata.ExifProfile;
TiffFrameMetadata rootFrameMetaData = output.Frames.RootFrame.Metadata.GetTiffMetadata(); TiffFrameMetadata rootFrameMetaData = output.Frames.RootFrame.Metadata.GetTiffMetadata();
Assert.Equal(expectedBitsPerPixel, rootFrameMetaData.BitsPerPixel); Assert.Equal(expectedBitsPerPixel, rootFrameMetaData.BitsPerPixel);
Assert.Equal(expectedCompression, (TiffCompression)exifProfile.GetValue(ExifTag.Compression).Value); Assert.Equal(expectedCompression, rootFrameMetaData.Compression);
} }
[Theory] [Theory]
@ -151,7 +148,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
var tiffEncoder = new TiffEncoder(); var tiffEncoder = new TiffEncoder();
using Image input = new Image<L8>(10, 10); using Image input = new Image<L8>(10, 10);
using var memStream = new MemoryStream(); using var memStream = new MemoryStream();
var expectedBitsPerPixel = TiffBitsPerPixel.Bit8; TiffBitsPerPixel expectedBitsPerPixel = TiffBitsPerPixel.Bit8;
// act // act
input.Save(memStream, tiffEncoder); input.Save(memStream, tiffEncoder);
@ -183,8 +180,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
// assert // assert
memStream.Position = 0; memStream.Position = 0;
using var output = Image.Load<Rgba32>(Configuration, memStream); using var output = Image.Load<Rgba32>(Configuration, memStream);
ExifProfile exifProfile = output.Frames.RootFrame.Metadata.ExifProfile; Assert.Equal(expectedCompression, output.Frames.RootFrame.Metadata.GetTiffMetadata().Compression);
Assert.Equal(expectedCompression, (TiffCompression)exifProfile.GetValue(ExifTag.Compression).Value);
} }
[Theory] [Theory]
@ -206,8 +202,8 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
// assert // assert
memStream.Position = 0; memStream.Position = 0;
using var output = Image.Load<Rgba32>(Configuration, memStream); using var output = Image.Load<Rgba32>(Configuration, memStream);
ExifProfile exifProfile = output.Frames.RootFrame.Metadata.ExifProfile; TiffFrameMetadata frameMetadata = output.Frames.RootFrame.Metadata.GetTiffMetadata();
Assert.Equal(expectedPredictor, (TiffPredictor)exifProfile.GetValue(ExifTag.Predictor).Value); Assert.Equal(expectedPredictor, frameMetadata.Predictor);
} }
[Theory] [Theory]
@ -229,10 +225,9 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
// assert // assert
memStream.Position = 0; memStream.Position = 0;
using var output = Image.Load<Rgba32>(Configuration, memStream); using var output = Image.Load<Rgba32>(Configuration, memStream);
ExifProfile exifProfile = output.Frames.RootFrame.Metadata.ExifProfile; TiffFrameMetadata frameMetaData = output.Frames.RootFrame.Metadata.GetTiffMetadata();
var frameMetaData = TiffFrameMetadata.Parse(exifProfile);
Assert.Equal(TiffBitsPerPixel.Bit1, frameMetaData.BitsPerPixel); Assert.Equal(TiffBitsPerPixel.Bit1, frameMetaData.BitsPerPixel);
Assert.Equal(expectedCompression, (TiffCompression)exifProfile.GetValue(ExifTag.Compression).Value); Assert.Equal(expectedCompression, frameMetaData.Compression);
} }
[Theory] [Theory]
@ -402,9 +397,8 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
var tiffEncoder = new TiffEncoder() { PhotometricInterpretation = photometricInterpretation, Compression = compression }; var tiffEncoder = new TiffEncoder() { PhotometricInterpretation = photometricInterpretation, Compression = compression };
using Image<TPixel> input = provider.GetImage(); using Image<TPixel> input = provider.GetImage();
using var memStream = new MemoryStream(); using var memStream = new MemoryStream();
ExifProfile exifProfileInput = input.Frames.RootFrame.Metadata.ExifProfile; TiffFrameMetadata inputMeta = input.Frames.RootFrame.Metadata.GetTiffMetadata();
var inputCompression = (TiffCompression)exifProfileInput.GetValue(ExifTag.Compression).Value; TiffCompression inputCompression = inputMeta.Compression ?? TiffCompression.None;
var inputMeta = TiffFrameMetadata.Parse(exifProfileInput);
// act // act
input.Save(memStream, tiffEncoder); input.Save(memStream, tiffEncoder);
@ -413,7 +407,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
memStream.Position = 0; memStream.Position = 0;
using var output = Image.Load<Rgba32>(Configuration, memStream); using var output = Image.Load<Rgba32>(Configuration, memStream);
ExifProfile exifProfileOutput = output.Frames.RootFrame.Metadata.ExifProfile; ExifProfile exifProfileOutput = output.Frames.RootFrame.Metadata.ExifProfile;
var outputMeta = TiffFrameMetadata.Parse(exifProfileOutput); TiffFrameMetadata outputMeta = output.Frames.RootFrame.Metadata.GetTiffMetadata();
ImageFrame<Rgba32> rootFrame = output.Frames.RootFrame; ImageFrame<Rgba32> rootFrame = output.Frames.RootFrame;
Number rowsPerStrip = exifProfileOutput.GetValue(ExifTag.RowsPerStrip) != null ? exifProfileOutput.GetValue(ExifTag.RowsPerStrip).Value : TiffConstants.RowsPerStripInfinity; Number rowsPerStrip = exifProfileOutput.GetValue(ExifTag.RowsPerStrip) != null ? exifProfileOutput.GetValue(ExifTag.RowsPerStrip).Value : TiffConstants.RowsPerStripInfinity;

57
tests/ImageSharp.Tests/Formats/Tiff/TiffMetadataTests.cs
View File

@ -45,6 +45,41 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
Assert.False(meta.ByteOrder == clone.ByteOrder); Assert.False(meta.ByteOrder == clone.ByteOrder);
} }
[Theory]
[WithFile(SampleMetadata, PixelTypes.Rgba32)]
public void TiffFrameMetadata_CloneIsDeep<TPixel>(TestImageProvider<TPixel> provider)
where TPixel : unmanaged, IPixel<TPixel>
{
using (Image<TPixel> image = provider.GetImage(TiffDecoder))
{
TiffFrameMetadata meta = image.Frames.RootFrame.Metadata.GetTiffMetadata();
var cloneSameAsSampleMetaData = (TiffFrameMetadata)meta.DeepClone();
VerifyExpectedTiffFrameMetaDataIsPresent(cloneSameAsSampleMetaData);
var clone = (TiffFrameMetadata)meta.DeepClone();
clone.BitsPerPixel = TiffBitsPerPixel.Bit8;
clone.Compression = TiffCompression.None;
clone.PhotometricInterpretation = TiffPhotometricInterpretation.CieLab;
clone.Predictor = TiffPredictor.Horizontal;
Assert.False(meta.BitsPerPixel == clone.BitsPerPixel);
Assert.False(meta.Compression == clone.Compression);
Assert.False(meta.PhotometricInterpretation == clone.PhotometricInterpretation);
Assert.False(meta.Predictor == clone.Predictor);
}
}
private static void VerifyExpectedTiffFrameMetaDataIsPresent(TiffFrameMetadata frameMetaData)
{
Assert.NotNull(frameMetaData);
Assert.NotNull(frameMetaData.BitsPerPixel);
Assert.Equal(TiffBitsPerSample.Bit4, (TiffBitsPerSample)frameMetaData.BitsPerPixel);
Assert.Equal(TiffCompression.Lzw, frameMetaData.Compression);
Assert.Equal(TiffPhotometricInterpretation.PaletteColor, frameMetaData.PhotometricInterpretation);
Assert.Equal(TiffPredictor.None, frameMetaData.Predictor);
}
[Theory] [Theory]
[InlineData(Calliphora_BiColorUncompressed, 1)] [InlineData(Calliphora_BiColorUncompressed, 1)]
[InlineData(GrayscaleUncompressed, 8)] [InlineData(GrayscaleUncompressed, 8)]
@ -99,7 +134,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
Assert.NotNull(rootFrameMetaData.XmpProfile); Assert.NotNull(rootFrameMetaData.XmpProfile);
Assert.NotNull(rootFrameMetaData.ExifProfile); Assert.NotNull(rootFrameMetaData.ExifProfile);
Assert.Equal(2599, rootFrameMetaData.XmpProfile.Length); Assert.Equal(2599, rootFrameMetaData.XmpProfile.Length);
Assert.Equal(30, rootFrameMetaData.ExifProfile.Values.Count); Assert.Equal(27, rootFrameMetaData.ExifProfile.Values.Count);
} }
} }
} }
@ -132,9 +167,13 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
Assert.Equal(2599, rootFrame.Metadata.XmpProfile.Length); Assert.Equal(2599, rootFrame.Metadata.XmpProfile.Length);
ExifProfile exifProfile = rootFrame.Metadata.ExifProfile; ExifProfile exifProfile = rootFrame.Metadata.ExifProfile;
TiffFrameMetadata tiffFrameMetadata = rootFrame.Metadata.GetTiffMetadata();
Assert.NotNull(exifProfile); Assert.NotNull(exifProfile);
Assert.Equal(30, exifProfile.Values.Count);
Assert.Equal(TiffCompression.Lzw, (TiffCompression)exifProfile.GetValue(ExifTag.Compression).Value); // The original exifProfile has 30 values, but 3 of those values will be stored in the TiffFrameMetaData
// and removed from the profile on decode.
Assert.Equal(27, exifProfile.Values.Count);
Assert.Equal(TiffCompression.Lzw, tiffFrameMetadata.Compression);
Assert.Equal("This is Название", exifProfile.GetValue(ExifTag.ImageDescription).Value); Assert.Equal("This is Название", exifProfile.GetValue(ExifTag.ImageDescription).Value);
Assert.Equal("This is Изготовитель камеры", exifProfile.GetValue(ExifTag.Make).Value); Assert.Equal("This is Изготовитель камеры", exifProfile.GetValue(ExifTag.Make).Value);
Assert.Equal("This is Модель камеры", exifProfile.GetValue(ExifTag.Model).Value); Assert.Equal("This is Модель камеры", exifProfile.GetValue(ExifTag.Model).Value);
@ -153,7 +192,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
Assert.Null(exifProfile.GetValue(ExifTag.ExtraSamples)?.Value); Assert.Null(exifProfile.GetValue(ExifTag.ExtraSamples)?.Value);
Assert.Equal(32u, exifProfile.GetValue(ExifTag.RowsPerStrip).Value); Assert.Equal(32u, exifProfile.GetValue(ExifTag.RowsPerStrip).Value);
Assert.Null(exifProfile.GetValue(ExifTag.SampleFormat)); Assert.Null(exifProfile.GetValue(ExifTag.SampleFormat));
Assert.Equal(TiffPredictor.None, (TiffPredictor?)exifProfile.GetValue(ExifTag.Predictor)?.Value); Assert.Equal(TiffPredictor.None, tiffFrameMetadata.Predictor);
Assert.Equal(PixelResolutionUnit.PixelsPerInch, UnitConverter.ExifProfileToResolutionUnit(exifProfile)); Assert.Equal(PixelResolutionUnit.PixelsPerInch, UnitConverter.ExifProfileToResolutionUnit(exifProfile));
ushort[] colorMap = exifProfile.GetValue(ExifTag.ColorMap)?.Value; ushort[] colorMap = exifProfile.GetValue(ExifTag.ColorMap)?.Value;
Assert.NotNull(colorMap); Assert.NotNull(colorMap);
@ -162,7 +201,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
Assert.Equal(14392, colorMap[1]); Assert.Equal(14392, colorMap[1]);
Assert.Equal(58596, colorMap[46]); Assert.Equal(58596, colorMap[46]);
Assert.Equal(3855, colorMap[47]); Assert.Equal(3855, colorMap[47]);
Assert.Equal(TiffPhotometricInterpretation.PaletteColor, (TiffPhotometricInterpretation)exifProfile.GetValue(ExifTag.PhotometricInterpretation).Value); Assert.Equal(TiffPhotometricInterpretation.PaletteColor, tiffFrameMetadata.PhotometricInterpretation);
Assert.Equal(1u, exifProfile.GetValue(ExifTag.SamplesPerPixel).Value); Assert.Equal(1u, exifProfile.GetValue(ExifTag.SamplesPerPixel).Value);
ImageMetadata imageMetaData = image.Metadata; ImageMetadata imageMetaData = image.Metadata;
@ -213,12 +252,12 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
using Image<TPixel> image = provider.GetImage(new TiffDecoder() { IgnoreMetadata = false }); using Image<TPixel> image = provider.GetImage(new TiffDecoder() { IgnoreMetadata = false });
ImageMetadata inputMetaData = image.Metadata; ImageMetadata inputMetaData = image.Metadata;
var frameMetaInput = TiffFrameMetadata.Parse(image.Frames.RootFrame.Metadata.ExifProfile);
ImageFrame<TPixel> rootFrameInput = image.Frames.RootFrame; ImageFrame<TPixel> rootFrameInput = image.Frames.RootFrame;
TiffFrameMetadata frameMetaInput = rootFrameInput.Metadata.GetTiffMetadata();
byte[] xmpProfileInput = rootFrameInput.Metadata.XmpProfile; byte[] xmpProfileInput = rootFrameInput.Metadata.XmpProfile;
ExifProfile exifProfileInput = rootFrameInput.Metadata.ExifProfile; ExifProfile exifProfileInput = rootFrameInput.Metadata.ExifProfile;
Assert.Equal(TiffCompression.Lzw, (TiffCompression)exifProfileInput.GetValue(ExifTag.Compression).Value); Assert.Equal(TiffCompression.Lzw, frameMetaInput.Compression);
Assert.Equal(TiffBitsPerPixel.Bit4, frameMetaInput.BitsPerPixel); Assert.Equal(TiffBitsPerPixel.Bit4, frameMetaInput.BitsPerPixel);
// Save to Tiff // Save to Tiff
@ -232,12 +271,12 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
ImageMetadata encodedImageMetaData = encodedImage.Metadata; ImageMetadata encodedImageMetaData = encodedImage.Metadata;
ImageFrame<Rgba32> rootFrameEncodedImage = encodedImage.Frames.RootFrame; ImageFrame<Rgba32> rootFrameEncodedImage = encodedImage.Frames.RootFrame;
var tiffMetaDataEncodedRootFrame = TiffFrameMetadata.Parse(rootFrameEncodedImage.Metadata.ExifProfile); TiffFrameMetadata tiffMetaDataEncodedRootFrame = rootFrameEncodedImage.Metadata.GetTiffMetadata();
ExifProfile encodedImageExifProfile = rootFrameEncodedImage.Metadata.ExifProfile; ExifProfile encodedImageExifProfile = rootFrameEncodedImage.Metadata.ExifProfile;
byte[] encodedImageXmpProfile = rootFrameEncodedImage.Metadata.XmpProfile; byte[] encodedImageXmpProfile = rootFrameEncodedImage.Metadata.XmpProfile;
Assert.Equal(TiffBitsPerPixel.Bit4, tiffMetaDataEncodedRootFrame.BitsPerPixel); Assert.Equal(TiffBitsPerPixel.Bit4, tiffMetaDataEncodedRootFrame.BitsPerPixel);
Assert.Equal(TiffCompression.Lzw, (TiffCompression)encodedImageExifProfile.GetValue(ExifTag.Compression).Value); Assert.Equal(TiffCompression.Lzw, tiffMetaDataEncodedRootFrame.Compression);
Assert.Equal(inputMetaData.HorizontalResolution, encodedImageMetaData.HorizontalResolution); Assert.Equal(inputMetaData.HorizontalResolution, encodedImageMetaData.HorizontalResolution);
Assert.Equal(inputMetaData.VerticalResolution, encodedImageMetaData.VerticalResolution); Assert.Equal(inputMetaData.VerticalResolution, encodedImageMetaData.VerticalResolution);

Write Preview
Loading…
Cancel
Save