public static void Equal(TiffIfdEntry expected, TiffIfdEntry actual)
{
Assert.Equal(expected.Tag, actual.Tag);
Assert.Equal(expected.Type, actual.Type);
Assert.Equal(expected.Count, actual.Count);
Assert.Equal(expected.Value, actual.Value);
}
public static TiffIfdEntry_Stream_Tuple GenerateTiffIfdEntry(ushort tag, TiffType type, byte[] data, byte paddingByteCount, ByteOrder byteOrder, int count)
{
// Create a stream with padding bytes as required
var streamBuilder = new StreamBuilder(byteOrder);
byte[] paddingBytes = Enumerable.Repeat((byte)42, paddingByteCount).ToArray();
streamBuilder.WriteBytes(paddingBytes);
// If the data is longer than four bytes, then write this to the stream and set the data to the offset
if (data.Length > 4)
{
streamBuilder.WriteBytes(data);
data = byteOrder == ByteOrder.LittleEndian ? new byte[] { paddingByteCount, 0, 0, 0 } : new byte[] { 0, 0, 0, paddingByteCount };
}
var stream = streamBuilder.ToStream();
// Create the IFD entry and test reading the value
var entry = new TiffIfdEntry {
Tag = tag, Type = type, Count = count, Value = data
};
return(new TiffIfdEntry_Stream_Tuple(entry, stream));
}
public void SizeOfIfdEntry_AlwaysReturnsTwelveBytes()
{
var ifdEntry = new TiffIfdEntry();
var size = TiffReader.SizeOfIfdEntry(ifdEntry);
Assert.Equal(12, size);
}
private void WriteTiffIfdEntryInfo(TiffIfdEntry entry, Dictionary <int, string> tagDictionary)
{
var tagStr = ConvertTagToString(tagDictionary, entry.Tag);
var typeStr = entry.Count == 1 ? $"{entry.Type}" : $"{entry.Type}[{entry.Count}]";
object value = GetTiffIfdEntryValue(entry);
if (value is Array)
{
value = ConvertArrayToString((Array)value);
}
_report.WriteLine($"{tagStr} = {value}");
}
public TiffIfd GenerateIfd(StreamBuilder streamBuilder)
{
streamBuilder.WritePadding(6);
var ifdEntries = _entries.Select(entryInfo =>
{
var entry = new TiffIfdEntry {
Tag = entryInfo.Tag, Type = entryInfo.Type, Count = entryInfo.Count
};
if (entryInfo.Data.Length <= 4)
{
entry.Value = entryInfo.Data;
}
else
{
// If the data is longer than four bytes, then write this to the stream and set the data to the offset
var offset = (uint)streamBuilder.Stream.Position;
streamBuilder.WriteBytes(entryInfo.Data);
entry.Value = BitConverter.GetBytes(offset).WithByteOrder(_byteOrder);
}
return(entry);
});
var preEntries = new[] { new TiffIfdEntry {
Tag = 1
}, new TiffIfdEntry {
Tag = 2
}, new TiffIfdEntry {
Tag = 3
} };
var postEntries = new[] { new TiffIfdEntry {
Tag = 4
}, new TiffIfdEntry {
Tag = 5
}, new TiffIfdEntry {
Tag = 6
} };
var allIfdEntries = preEntries.Concat(ifdEntries).Concat(postEntries).ToArray();
return(new TiffIfd {
Entries = allIfdEntries
});
}
private object GetTiffIfdEntryValue(TiffIfdEntry entry)
{
switch (entry.Tag)
{
// Use named enums if known
case TiffTags.Compression:
return((TiffCompression)_tiffDecoder.ReadUnsignedInteger(ref entry));
case TiffTags.ExtraSamples:
return((TiffExtraSamples)_tiffDecoder.ReadUnsignedInteger(ref entry));
case TiffTags.FillOrder:
return((TiffFillOrder)_tiffDecoder.ReadUnsignedInteger(ref entry));
case TiffTags.NewSubfileType:
return((TiffNewSubfileType)_tiffDecoder.ReadUnsignedInteger(ref entry));
case TiffTags.Orientation:
return((TiffOrientation)_tiffDecoder.ReadUnsignedInteger(ref entry));
case TiffTags.PhotometricInterpretation:
return((TiffPhotometricInterpretation)_tiffDecoder.ReadUnsignedInteger(ref entry));
case TiffTags.PlanarConfiguration:
return((TiffPlanarConfiguration)_tiffDecoder.ReadUnsignedInteger(ref entry));
case TiffTags.ResolutionUnit:
return((TiffResolutionUnit)_tiffDecoder.ReadUnsignedInteger(ref entry));
case TiffTags.SubfileType:
return((TiffSubfileType)_tiffDecoder.ReadUnsignedInteger(ref entry));
case TiffTags.Threshholding:
return((TiffThreshholding)_tiffDecoder.ReadUnsignedInteger(ref entry));
// Other fields
default:
return(GetTiffIfdEntryData(entry));
}
}
public TiffIfdEntry_Stream_Tuple(TiffIfdEntry entry, Stream stream)
{
Entry = entry;
Stream = stream;
}
private string GetTiffIfdEntryData(TiffIfdEntry entry)
{
switch (entry.Type)
{
case TiffType.Byte:
case TiffType.Short:
case TiffType.Long:
if (entry.Count == 1)
{
return(_tiffDecoder.ReadUnsignedInteger(ref entry).ToString());
}
else
{
var array = _tiffDecoder.ReadUnsignedIntegerArray(ref entry);
return(ConvertArrayToString(array));
}
case TiffType.SByte:
case TiffType.SShort:
case TiffType.SLong:
if (entry.Count == 1)
{
return(_tiffDecoder.ReadSignedInteger(ref entry).ToString());
}
else
{
var array = _tiffDecoder.ReadSignedIntegerArray(ref entry);
return(ConvertArrayToString(array));
}
case TiffType.Ascii:
return("\"" + _tiffDecoder.ReadString(ref entry) + "\"");
case TiffType.Rational:
if (entry.Count == 1)
{
return(_tiffDecoder.ReadUnsignedRational(ref entry).ToString());
}
else
{
var array = _tiffDecoder.ReadUnsignedRationalArray(ref entry);
return(ConvertArrayToString(array));
}
case TiffType.SRational:
if (entry.Count == 1)
{
return(_tiffDecoder.ReadSignedRational(ref entry).ToString());
}
else
{
var array = _tiffDecoder.ReadSignedRationalArray(ref entry);
return(ConvertArrayToString(array));
}
case TiffType.Float:
if (entry.Count == 1)
{
return(_tiffDecoder.ReadFloat(ref entry).ToString());
}
else
{
var array = _tiffDecoder.ReadFloatArray(ref entry);
return(ConvertArrayToString(array));
}
case TiffType.Double:
if (entry.Count == 1)
{
return(_tiffDecoder.ReadDouble(ref entry).ToString());
}
else
{
var array = _tiffDecoder.ReadDoubleArray(ref entry);
return(ConvertArrayToString(array));
}
case TiffType.Undefined:
return("Undefined");
default:
return($"Unknown Type ({(int)entry.Type})");
}
}
