public async Task ReadSubIfdReferencesAsync_ReadsCorrectly(ByteOrder byteOrder, TiffType type)
{
var stream = new StreamBuilder(byteOrder)
.WritePadding(20)
.WriteUInt32(10)
.WriteUInt32(42)
.WriteUInt32(30)
.ToStream();
var tiffIfd = new TiffIfd
{
Entries = new[]
{
new TiffIfdEntry {
Tag = 10, Type = TiffType.Ascii, Count = 10
},
new TiffIfdEntry {
Tag = TiffTags.SubIFDs, Type = type, Count = 3, Value = ByteArrayHelper.ToBytes(20u, byteOrder)
},
new TiffIfdEntry {
Tag = 20, Type = TiffType.Ascii, Count = 10
}
}
};
var subIfdReferences = await TiffReader.ReadSubIfdReferencesAsync(tiffIfd, stream, byteOrder);
Assert.Equal(new[] { new TiffIfdReference(10), new TiffIfdReference(42), new TiffIfdReference(30) }, subIfdReferences);
}
public async Task ReadNextIfdAsync_ReadsCorrectly(ByteOrder byteOrder)
{
var stream = new StreamBuilder(byteOrder)
.WritePadding(20)
.WriteInt16(3)
.WriteTiffIfdEntry(2, TiffType.Ascii, 20, new byte[] { 1, 2, 3, 4 })
.WriteTiffIfdEntry(4, TiffType.Short, 40, new byte[] { 2, 3, 4, 5 })
.WriteTiffIfdEntry(6, TiffType.Double, 60, new byte[] { 3, 4, 5, 6 })
.WriteUInt32(123456)
.ToStream();
var previousIfd = new TiffIfd {
NextIfdReference = new TiffIfdReference(20)
};
var ifd = (await TiffReader.ReadNextIfdAsync(previousIfd, stream, byteOrder)).Value;
Assert.Equal(3, ifd.Entries.Length);
AssertTiff.Equal(new TiffIfdEntry {
Tag = 2, Type = TiffType.Ascii, Count = 20, Value = new byte[] { 1, 2, 3, 4 }
}, ifd.Entries[0]);
AssertTiff.Equal(new TiffIfdEntry {
Tag = 4, Type = TiffType.Short, Count = 40, Value = new byte[] { 2, 3, 4, 5 }
}, ifd.Entries[1]);
AssertTiff.Equal(new TiffIfdEntry {
Tag = 6, Type = TiffType.Double, Count = 60, Value = new byte[] { 3, 4, 5, 6 }
}, ifd.Entries[2]);
Assert.Equal(new TiffIfdReference(123456), ifd.NextIfdReference);
}
private void WriteTiffIfdEntries(TiffIfd ifd, Dictionary <int, string> tagDictionary)
{
foreach (TiffIfdEntry entry in ifd.Entries)
{
WriteTiffIfdEntryInfo(entry, tagDictionary);
}
}
// Helper Methods
public async Task AssertReadsImageData(TiffIfd ifd, Stream stream, byte[] imageData, Color[][] expectedResult)
{
int width = expectedResult[0].Length;
int height = expectedResult.Length;
var decoder = await TiffImageReader.GetImageDecoderAsync(ifd, stream, ByteOrder.LittleEndian);
Image <Rgb888> imageRgb = new Image <Rgb888>(width, height);
using (var pixels = imageRgb.Lock())
{
decoder(imageData, pixels, new Rectangle(0, 0, width, height));
}
Image <Color> image = imageRgb.To <Color>();
using (var pixels = image.Lock())
{
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
Assert.Equal(expectedResult[y][x], pixels[x, y]);
}
}
}
}
public void SizeOfIfd_ReturnsCorrectSize(int entryCount, int expectedSize)
{
var ifd = new TiffIfd {
Entries = new TiffIfdEntry[entryCount]
};
var size = TiffReader.SizeOfIfd(ifd);
Assert.Equal(expectedSize, size);
}
public static TiffIfdReference?GetExifIfdReference(TiffIfd ifd, ByteOrder byteOrder)
{
var exifEntry = TiffReader.GetTiffIfdEntry(ifd, TiffTags.ExifIFD);
if (exifEntry == null)
{
return(null);
}
else
{
return(exifEntry.Value.GetIfdReference(byteOrder));
}
}
public async Task ReadNextIfdAsync_ReturnsNullIfLastIfd(ByteOrder byteOrder)
{
var stream = new StreamBuilder(byteOrder)
.WriteInt16(3)
.WriteTiffIfdEntry(2, TiffType.Ascii, 20, new byte[] { 1, 2, 3, 4 })
.WriteTiffIfdEntry(4, TiffType.Short, 40, new byte[] { 2, 3, 4, 5 })
.WriteTiffIfdEntry(6, TiffType.Double, 60, new byte[] { 3, 4, 5, 6 })
.WriteUInt32(123456)
.ToStream();
var previousIfd = new TiffIfd {
NextIfdReference = null
};
var ifd = await TiffReader.ReadNextIfdAsync(previousIfd, stream, byteOrder);
Assert.Null(ifd);
}
public void GetExifIfdReference_ReturnsCorrectReference(TiffType type, ByteOrder byteOrder)
{
var tiffIfd = new TiffIfd
{
Entries = new[]
{
new TiffIfdEntry {
Tag = 10, Type = TiffType.Ascii, Count = 10
},
TiffHelper.GenerateTiffIfdEntry(TiffTags.ExifIFD, type, 20u, byteOrder),
new TiffIfdEntry {
Tag = 20, Type = TiffType.Ascii, Count = 10
}
}
};
var exifIfdReference = ExifReader.GetExifIfdReference(tiffIfd, byteOrder);
Assert.Equal(new TiffIfdReference(20), exifIfdReference);
}
private void DecodeImage(TiffIfd ifd, string imageName)
{
try
{
var image = _tiffDecoder.DecodeImage <Rgba32>(ifd);
var filename = Path.Combine(_outputDirectory.FullName, imageName + ".png");
using (FileStream outputStream = File.OpenWrite(filename))
{
image.Save(outputStream);
}
_report.WriteImage(new FileInfo(filename));
}
catch (Exception e)
{
_report.WriteError(e.Message);
}
}
private void WriteTiffIfdInfo(uint offset, string ifdPrefix, int?ifdId, Dictionary <int, string> tagDictionary)
{
TiffIfd ifd = _tiffDecoder.ReadIfd(offset);
_report.WriteSubheader($"{ifdPrefix}{ifdId} (Offset = {offset})");
// Write the IFD dump
WriteTiffIfdEntries(ifd, tagDictionary);
// Decode the image
DecodeImage(ifd, $"{ifdPrefix}{ifdId}");
// Write the EXIF IFD
// var exifIfdReference = ExifReader.GetExifIfdReference(ifd, byteOrder);
// if (exifIfdReference != null)
// {
// var exifIfd = await TiffReader.ReadIfdAsync(exifIfdReference.Value, _stream, byteOrder);
// await WriteTiffIfdInfoAsync(exifIfd, byteOrder, $"{ifdPrefix}{ifdId} (EXIF)", null, _exifTagDictionary);
// }
// Write the sub-IFDs
// var subIfdReferences = await TiffReader.ReadSubIfdReferencesAsync(ifd, _stream, byteOrder);
// for (int i = 0; i < subIfdReferences.Length; i++)
// {
// TiffIfd subIfd = await TiffReader.ReadIfdAsync(subIfdReferences[i], _stream, byteOrder);
// await WriteTiffIfdInfoAsync(subIfd, byteOrder, $"{ifdPrefix}{ifdId}-", i, _tagDictionary);
// }
// Write the next IFD
if (ifd.NextIfdOffset != 0)
{
WriteTiffIfdInfo(ifd.NextIfdOffset, ifdPrefix, ifdId + 1, _tagDictionary);
}
}
public void ReadExifIfdReference_ReturnsNullIfNoExifIfdExists(ByteOrder byteOrder)
{
var tiffIfd = new TiffIfd
{
Entries = new[]
{
new TiffIfdEntry {
Tag = 10, Type = TiffType.Ascii, Count = 10
},
new TiffIfdEntry {
Tag = 15, Type = TiffType.Ascii, Count = 10
},
new TiffIfdEntry {
Tag = 20, Type = TiffType.Ascii, Count = 10
}
}
};
var exifIfdReference = ExifReader.GetExifIfdReference(tiffIfd, byteOrder);
Assert.Null(exifIfdReference);
}
public void GetIfdEntry_ReturnsNullIfTagIsNotPresent()
{
var ifd = new TiffIfd
{
Entries = new[]
{
new TiffIfdEntry {
Tag = 10, Type = TiffType.Long, Count = 5
},
new TiffIfdEntry {
Tag = 15, Type = TiffType.Ascii, Count = 10
},
new TiffIfdEntry {
Tag = 20, Type = TiffType.Byte, Count = 15
}
}
};
var entry = TiffReader.GetTiffIfdEntry(ifd, 18);
Assert.Null(entry);
}
public void GetIfdEntry_ReturnsEntryByTag()
{
var ifd = new TiffIfd
{
Entries = new[]
{
new TiffIfdEntry {
Tag = 10, Type = TiffType.Long, Count = 5
},
new TiffIfdEntry {
Tag = 15, Type = TiffType.Ascii, Count = 10
},
new TiffIfdEntry {
Tag = 20, Type = TiffType.Byte, Count = 15
}
}
};
var entry = TiffReader.GetTiffIfdEntry(ifd, 15).Value;
Assert.Equal(15, entry.Tag);
Assert.Equal(TiffType.Ascii, entry.Type);
Assert.Equal(10, entry.Count);
}
public async Task ReadSubIfdReferencesAsync_ReadsCorrectlyWithNoSubIfds(ByteOrder byteOrder)
{
var stream = new StreamBuilder(byteOrder).ToStream();
var tiffIfd = new TiffIfd
{
Entries = new[]
{
new TiffIfdEntry {
Tag = 10, Type = TiffType.Ascii, Count = 10
},
new TiffIfdEntry {
Tag = 15, Type = TiffType.Ascii, Count = 10
},
new TiffIfdEntry {
Tag = 20, Type = TiffType.Ascii, Count = 10
}
}
};
var subIfdReferences = await TiffReader.ReadSubIfdReferencesAsync(tiffIfd, stream, byteOrder);
Assert.Equal(new TiffIfdReference[] { }, subIfdReferences);
}
public TiffIfd_Stream_Tuple(TiffIfd ifd, Stream stream)
{
Ifd = ifd;
Stream = stream;
}
