private static void TestValue(ExifValue value, Rational[] expected)
{
Assert.IsNotNull(value);
Rational[] values = (Rational[])value.Value;
Assert.IsNotNull(values);
CollectionAssert.AreEqual(expected, values);
}
private static void TestValue(ExifValue value, string expected)
{
Assert.IsNotNull(value);
Assert.AreEqual(expected, value.Value);
}
private static void TestValue(ExifValue value, double[] expected)
{
Assert.NotNull(value);
Assert.Equal(expected, (ICollection)value.Value);
}
private static void TestValue(ExifValue value, double expected)
{
Assert.NotNull(value);
Assert.Equal(expected, value.Value);
}
private static void TestValue(ExifValue value, SignedRational expected)
{
Assert.NotNull(value);
Assert.Equal(expected, value.Value);
}
public void SetValue()
{
Rational[] latitude = new Rational[] { new Rational(12.3), new Rational(4.56), new Rational(789.0) };
Image image = TestFile.Create(TestImages.Jpeg.Baseline.Floorplan).CreateImage();
image.MetaData.ExifProfile.SetValue(ExifTag.Software, "ImageSharp");
ExifValue value = image.MetaData.ExifProfile.GetValue(ExifTag.Software);
TestValue(value, "ImageSharp");
Assert.Throws <ArgumentException>(() => { value.Value = 15; });
image.MetaData.ExifProfile.SetValue(ExifTag.ShutterSpeedValue, new SignedRational(75.55));
value = image.MetaData.ExifProfile.GetValue(ExifTag.ShutterSpeedValue);
TestValue(value, new SignedRational(7555, 100));
Assert.Throws <ArgumentException>(() => { value.Value = 75; });
image.MetaData.ExifProfile.SetValue(ExifTag.XResolution, new Rational(150.0));
// We also need to change this value because this overrides XResolution when the image is written.
image.MetaData.HorizontalResolution = 150.0;
value = image.MetaData.ExifProfile.GetValue(ExifTag.XResolution);
TestValue(value, new Rational(150, 1));
Assert.Throws <ArgumentException>(() => { value.Value = "ImageSharp"; });
image.MetaData.ExifProfile.SetValue(ExifTag.ReferenceBlackWhite, null);
value = image.MetaData.ExifProfile.GetValue(ExifTag.ReferenceBlackWhite);
TestValue(value, (string)null);
image.MetaData.ExifProfile.SetValue(ExifTag.GPSLatitude, latitude);
value = image.MetaData.ExifProfile.GetValue(ExifTag.GPSLatitude);
TestValue(value, latitude);
image = WriteAndRead(image);
Assert.NotNull(image.MetaData.ExifProfile);
Assert.Equal(17, image.MetaData.ExifProfile.Values.Count());
value = image.MetaData.ExifProfile.GetValue(ExifTag.Software);
TestValue(value, "ImageSharp");
value = image.MetaData.ExifProfile.GetValue(ExifTag.ShutterSpeedValue);
TestValue(value, new SignedRational(75.55));
value = image.MetaData.ExifProfile.GetValue(ExifTag.XResolution);
TestValue(value, new Rational(150.0));
value = image.MetaData.ExifProfile.GetValue(ExifTag.ReferenceBlackWhite);
Assert.Null(value);
value = image.MetaData.ExifProfile.GetValue(ExifTag.GPSLatitude);
TestValue(value, latitude);
image.MetaData.ExifProfile.Parts = ExifParts.ExifTags;
image = WriteAndRead(image);
Assert.NotNull(image.MetaData.ExifProfile);
Assert.Equal(8, image.MetaData.ExifProfile.Values.Count());
Assert.NotNull(image.MetaData.ExifProfile.GetValue(ExifTag.ColorSpace));
Assert.True(image.MetaData.ExifProfile.RemoveValue(ExifTag.ColorSpace));
Assert.False(image.MetaData.ExifProfile.RemoveValue(ExifTag.ColorSpace));
Assert.Null(image.MetaData.ExifProfile.GetValue(ExifTag.ColorSpace));
Assert.Equal(7, image.MetaData.ExifProfile.Values.Count());
}
internal ExifValue(ExifValue value)
: base(value)
{
}
public void ShouldReturnTheValueAsString()
{
var value = new ExifValue(ExifTag.ImageWidth, ExifDataType.SignedShort, (short)42, false);
Assert.AreEqual("42", value.ToString());
}
public void Test_SetValue()
{
Rational[] latitude = new Rational[] { new Rational(12.3), new Rational(4.56), new Rational(789.0) };
using (MemoryStream memStream = new MemoryStream())
{
using (MagickImage image = new MagickImage(Files.FujiFilmFinePixS1ProJPG))
{
ExifProfile profile = image.GetExifProfile();
profile.SetValue(ExifTag.Software, "Magick.NET");
ExifValue value = profile.GetValue(ExifTag.Software);
TestValue(value, "Magick.NET");
ExceptionAssert.Throws <ArgumentException>(delegate()
{
value.Value = 15;
});
profile.SetValue(ExifTag.ShutterSpeedValue, new SignedRational(75.55));
value = profile.GetValue(ExifTag.ShutterSpeedValue);
TestRationalValue(value, "1511/20");
ExceptionAssert.Throws <ArgumentException>(delegate()
{
value.Value = 75;
});
profile.SetValue(ExifTag.XResolution, new Rational(150.0));
value = profile.GetValue(ExifTag.XResolution);
TestRationalValue(value, "150");
ExceptionAssert.Throws <ArgumentException>(delegate()
{
value.Value = "Magick.NET";
});
image.Density = new Density(72);
value = profile.GetValue(ExifTag.XResolution);
TestRationalValue(value, "150");
value = profile.GetValue(ExifTag.ReferenceBlackWhite);
Assert.IsNotNull(value);
profile.SetValue(ExifTag.ReferenceBlackWhite, null);
value = profile.GetValue(ExifTag.ReferenceBlackWhite);
TestValue(value, (string)null);
profile.SetValue(ExifTag.GPSLatitude, latitude);
value = profile.GetValue(ExifTag.GPSLatitude);
TestValue(value, latitude);
image.AddProfile(profile);
image.Write(memStream);
}
memStream.Position = 0;
using (MagickImage image = new MagickImage(memStream))
{
ExifProfile profile = image.GetExifProfile();
Assert.IsNotNull(profile);
Assert.AreEqual(43, profile.Values.Count());
ExifValue value = profile.GetValue(ExifTag.Software);
TestValue(value, "Magick.NET");
value = profile.GetValue(ExifTag.ShutterSpeedValue);
TestRationalValue(value, "1511/20");
value = profile.GetValue(ExifTag.XResolution);
TestRationalValue(value, "72");
value = profile.GetValue(ExifTag.ReferenceBlackWhite);
Assert.IsNull(value);
value = profile.GetValue(ExifTag.GPSLatitude);
TestValue(value, latitude);
profile.Parts = ExifParts.ExifTags;
image.AddProfile(profile);
memStream.Position = 0;
image.Write(memStream);
}
memStream.Position = 0;
using (MagickImage image = new MagickImage(memStream))
{
ExifProfile profile = image.GetExifProfile();
Assert.IsNotNull(profile);
Assert.AreEqual(24, profile.Values.Count());
Assert.IsNotNull(profile.GetValue(ExifTag.FNumber));
Assert.IsTrue(profile.RemoveValue(ExifTag.FNumber));
Assert.IsFalse(profile.RemoveValue(ExifTag.FNumber));
Assert.IsNull(profile.GetValue(ExifTag.FNumber));
Assert.AreEqual(23, profile.Values.Count());
}
}
}
private int WriteValue(ExifValue value, byte[] destination, int offset)
{
if (value.IsArray && value.DataType != ExifDataType.Ascii)
return WriteArray(value, destination, offset);
else
return WriteValue(value.DataType, value.Value, destination, offset);
}
private int WriteArray(ExifValue value, byte[] destination, int offset)
{
if (value.DataType == ExifDataType.Ascii)
return WriteValue(ExifDataType.Ascii, value.Value, destination, offset);
int newOffset = offset;
foreach (object obj in (Array)value.Value)
newOffset = WriteValue(value.DataType, obj, destination, newOffset);
return newOffset;
}
private static void TestRationalValue(ExifValue value, string expected)
{
Assert.IsNotNull(value);
Assert.AreEqual(expected, value.ToString());
}
protected override Document OnLoad(Stream input)
{
byte[] bytes = new byte[input.Length];
input.ProperRead(bytes, 0, (int)input.Length);
Surface surface = GetOrientedSurface(bytes, out ExifValueCollection exifMetadata);
bool disposeSurface = true;
Document doc = null;
try
{
doc = new Document(surface.Width, surface.Height);
byte[] colorProfileBytes = WebPFile.GetColorProfileBytes(bytes);
if (colorProfileBytes != null)
{
doc.Metadata.AddExifPropertyItem(ExifSection.Image,
unchecked ((ushort)ExifTagID.IccProfileData),
new ExifValue(ExifValueType.Undefined,
colorProfileBytes));
}
if (exifMetadata != null && exifMetadata.Count > 0)
{
ExifValue xResProperty = exifMetadata.GetAndRemoveValue(ExifPropertyKeys.Image.XResolution.Path);
ExifValue yResProperty = exifMetadata.GetAndRemoveValue(ExifPropertyKeys.Image.YResolution.Path);
ExifValue resUnitProperty = exifMetadata.GetAndRemoveValue(ExifPropertyKeys.Image.ResolutionUnit.Path);
if (xResProperty != null && yResProperty != null && resUnitProperty != null)
{
if (MetadataHelpers.TryDecodeRational(xResProperty, out double xRes) &&
MetadataHelpers.TryDecodeRational(yResProperty, out double yRes) &&
MetadataHelpers.TryDecodeShort(resUnitProperty, out ushort resUnit))
{
if (xRes > 0.0 && yRes > 0.0)
{
switch (resUnit)
{
case TiffConstants.ResolutionUnit.Centimeter:
doc.DpuUnit = MeasurementUnit.Centimeter;
doc.DpuX = xRes;
doc.DpuY = yRes;
break;
case TiffConstants.ResolutionUnit.Inch:
doc.DpuUnit = MeasurementUnit.Inch;
doc.DpuX = xRes;
doc.DpuY = yRes;
break;
}
}
}
}
foreach (KeyValuePair <ExifPropertyPath, ExifValue> item in exifMetadata)
{
ExifPropertyPath path = item.Key;
doc.Metadata.AddExifPropertyItem(path.Section, path.TagID, item.Value);
}
}
byte[] xmpBytes = WebPFile.GetXmpBytes(bytes);
if (xmpBytes != null)
{
XmpPacket xmpPacket = XmpPacket.TryParse(xmpBytes);
if (xmpPacket != null)
{
doc.Metadata.SetXmpPacket(xmpPacket);
}
}
doc.Layers.Add(Layer.CreateBackgroundLayer(surface, takeOwnership: true));
disposeSurface = false;
}
finally
{
if (disposeSurface)
{
surface?.Dispose();
}
}
return(doc);
}
//===========================================================================================
private static void TestValue(ExifValue value, double expected)
{
Assert.IsNotNull(value);
Assert.AreEqual(expected, value.Value);
}
private static void TestRationalValue(ExifValue value, string expected)
{
Assert.IsNotNull(value);
Assert.AreEqual(expected, value.ToString());
}
//===========================================================================================
private static void TestValue(ExifValue value, double[] expected)
{
Assert.IsNotNull(value);
CollectionAssert.AreEqual(expected, (ICollection)value.Value);
}
public MetadataItem(ExifValue exifValue)
{
this.ExifValue = exifValue;
ExtractExifValue();
}
