public void ShouldReturnTheExifTagDescriptionWhenItIsPresent(ushort input, string expected)
{
var exifProfile = new ExifProfile();
exifProfile.SetValue(ExifTag.ResolutionUnit, input);
var value = exifProfile.GetValue(ExifTag.ResolutionUnit);
Assert.Equal(expected, value.ToString());
}
public void ShouldReturnFalseWhenExifTagIsInvalid()
{
var exifProfile = new ExifProfile();
Assert.Throws <NotSupportedException>(() =>
{
exifProfile.SetValue(new ExifTag <int>((ExifTagValue)42), 42);
});
}
public void ShouldAllowEmptyData()
{
using (var image = new MagickImage())
{
var data = new byte[] { };
var profile = new ExifProfile(data);
image.SetProfile(profile);
}
}
public void ShouldRemoveValueAndReturnTrue()
{
using (IMagickImage image = new MagickImage(Files.FujiFilmFinePixS1ProJPG))
{
ExifProfile profile = image.GetExifProfile();
Assert.IsTrue(profile.RemoveValue(ExifTag.FNumber));
}
}
public void ShouldRemoveFalseWhenProfileDoesNotContainTag()
{
using (IMagickImage image = new MagickImage(Files.FujiFilmFinePixS1ProJPG))
{
ExifProfile profile = image.GetExifProfile();
Assert.IsFalse(profile.RemoveValue(ExifTag.Acceleration));
}
}
public void Test_InvalidTag()
{
var exifProfile = new ExifProfile();
ExceptionAssert.Throws <NotSupportedException>(() =>
{
exifProfile.SetValue((ExifTag)42, 42);
});
}
private static ExifValue GetExifValue()
{
Image image = TestFile.Create(TestImages.Jpeg.Floorplan).CreateImage();
ExifProfile profile = image.ExifProfile;
Assert.NotNull(profile);
return(profile.Values.First());
}
private static ExifValue GetExifValue()
{
using (MagickImage image = new MagickImage(Files.FujiFilmFinePixS1ProJPG))
{
ExifProfile profile = image.GetExifProfile();
Assert.IsNotNull(profile);
return(profile.Values.First());
}
}
public void ShouldAllowNullValues()
{
var profile = new ExifProfile();
profile.SetValue(ExifTag.ReferenceBlackWhite, null);
var value = profile.GetValue(ExifTag.ReferenceBlackWhite);
TestValue(value, null);
}
public void ShouldReturnStringWhenValueIsString()
{
var profile = new ExifProfile();
profile.SetValue(ExifTag.Software, "Magick.NET");
var value = profile.GetValue(ExifTag.Software);
TestValue(value, "Magick.NET");
}
public void ParseMetadata(ExifProfile exifProfile)
{
DateTime = TryParseExif(exifProfile, ExifTag.DateTimeOriginal);
Camera = TryParseExif(exifProfile, ExifTag.Make) + " " + TryParseExif(exifProfile, ExifTag.Model);
Lens = TryParseExif(exifProfile, ExifTag.LensModel);
Fstop = TryParseExif(exifProfile, ExifTag.FNumber);
Exposure = TryParseExif(exifProfile, ExifTag.ExposureTime);
FocalLength = TryParseExif(exifProfile, ExifTag.FocalLength);
Iso = TryParseExif(exifProfile, ExifTag.ISOSpeedRatings);
}
public void ShouldReturnFalseWhenValueIsInvalidDataType2()
{
var profile = new ExifProfile();
profile.SetValue(ExifTag.ShutterSpeedValue, new SignedRational(75.55));
IExifValue value = profile.GetValue(ExifTag.ShutterSpeedValue);
Assert.False(value.SetValue(75));
}
internal static ExifProfile GetExifProfile()
{
Image <Rgba32> image = TestFile.Create(TestImages.Jpeg.Baseline.Floorplan).CreateImage();
ExifProfile profile = image.MetaData.ExifProfile;
Assert.NotNull(profile);
return(profile);
}
public void ShouldReturnOriginalDataWhenNotParsed()
{
using (IMagickImage image = new MagickImage(Files.FujiFilmFinePixS1ProJPG))
{
ExifProfile profile = image.GetExifProfile();
var bytes = profile.ToByteArray();
Assert.AreEqual(4706, bytes.Length);
}
}
private static ExifProfile GetExifProfile()
{
Image image = TestFile.Create(TestImages.Jpeg.Baseline.Floorplan).CreateImage();
ExifProfile profile = image.ExifProfile;
Assert.NotNull(profile);
return(profile);
}
private async Task UploadImageAsync(string id, Image <Rgba32> image)
{
var fileName = $"./{id}.gif";
var profile = new ExifProfile();
profile.SetValue(ExifTag.Copyright, _processingOptions.Copyright);
image.MetaData.ExifProfile = profile;
image.Save(fileName, _encoder);
await _imageRepository.UploadImageAsync(id, fileName);
}
public void ShouldReturnFalseWhenValueIsInvalidDataType1()
{
var profile = new ExifProfile();
profile.SetValue(ExifTag.Software, "Magick.NET");
IExifValue value = profile.GetValue(ExifTag.Software);
Assert.False(value.SetValue(10.5));
}
private static void TestMetaDataImpl(
bool useIdentify,
IImageDecoder decoder,
string imagePath,
int expectedPixelSize,
bool exifProfilePresent,
bool iccProfilePresent)
{
var testFile = TestFile.Create(imagePath);
using (var stream = new MemoryStream(testFile.Bytes, false))
{
IImageInfo imageInfo = useIdentify
? ((IImageInfoDetector)decoder).Identify(Configuration.Default, stream)
: decoder.Decode <Rgba32>(Configuration.Default, stream);
Assert.NotNull(imageInfo);
Assert.NotNull(imageInfo.PixelType);
if (useIdentify)
{
Assert.Equal(expectedPixelSize, imageInfo.PixelType.BitsPerPixel);
}
else
{
// When full Image<TPixel> decoding is performed, BitsPerPixel will match TPixel
int bpp32 = Unsafe.SizeOf <Rgba32>() * 8;
Assert.Equal(bpp32, imageInfo.PixelType.BitsPerPixel);
}
ExifProfile exifProfile = imageInfo.MetaData.ExifProfile;
if (exifProfilePresent)
{
Assert.NotNull(exifProfile);
Assert.NotEmpty(exifProfile.Values);
}
else
{
Assert.Null(exifProfile);
}
IccProfile iccProfile = imageInfo.MetaData.IccProfile;
if (iccProfilePresent)
{
Assert.NotNull(iccProfile);
Assert.NotEmpty(iccProfile.Entries);
}
else
{
Assert.Null(iccProfile);
}
}
}
public void ShouldAllowEmptyStream()
{
using (var image = new MagickImage())
{
using (MemoryStream memStream = new MemoryStream())
{
var profile = new ExifProfile(memStream);
image.SetProfile(profile);
}
}
}
private static ExifProfile CreateExifProfile()
{
var profile = new ExifProfile();
foreach (KeyValuePair <ExifTag, object> exifProfileValue in TestProfileValues)
{
profile.SetValue(exifProfileValue.Key, exifProfileValue.Value);
}
return(profile);
}
/// <summary>
/// Gets the height of the image frame.
/// </summary>
/// <param name="exifProfile">The image frame exif profile.</param>
/// <returns>The image height.</returns>
private static int GetImageHeight(ExifProfile exifProfile)
{
IExifValue <Number> height = exifProfile.GetValue(ExifTag.ImageLength);
if (height == null)
{
TiffThrowHelper.ThrowImageFormatException("The TIFF image frame is missing the ImageLength");
}
return((int)height.Value);
}
public void DamagedFiles <TPixel>(TestImageProvider <TPixel> provider)
where TPixel : unmanaged, IPixel <TPixel>
{
Assert.Throws <ImageDifferenceIsOverThresholdException>(() => TestTiffDecoder(provider));
using Image <TPixel> image = provider.GetImage(TiffDecoder);
ExifProfile exif = image.Frames.RootFrame.Metadata.ExifProfile;
// PhotometricInterpretation is required tag: https://www.awaresystems.be/imaging/tiff/tifftags/photometricinterpretation.html
Assert.Null(exif.GetValueInternal(ExifTag.PhotometricInterpretation));
}
/// <summary>
/// Gets the width of the image frame.
/// </summary>
/// <param name="exifProfile">The image frame exif profile.</param>
/// <returns>The image width.</returns>
private static int GetImageWidth(ExifProfile exifProfile)
{
IExifValue <Number> width = exifProfile.GetValue(ExifTag.ImageWidth);
if (width == null)
{
TiffThrowHelper.ThrowImageFormatException("The TIFF image frame is missing the ImageWidth");
}
return((int)width.Value);
}
public void ShouldCorrectlyHandleFraction()
{
var profile = new ExifProfile();
profile.SetValue(ExifTag.ShutterSpeedValue, new SignedRational(75.55));
var value = profile.GetValue(ExifTag.ShutterSpeedValue);
Assert.IsNotNull(value);
Assert.AreEqual("1511/20", value.ToString());
}
public void Values()
{
ExifProfile profile = GetExifProfile();
TestProfile(profile);
using Image <Rgba32> thumbnail = profile.CreateThumbnail <Rgba32>();
Assert.NotNull(thumbnail);
Assert.Equal(256, thumbnail.Width);
Assert.Equal(170, thumbnail.Height);
}
public void Test_Constructor_Empty()
{
using (IMagickImage image = new MagickImage(Files.ImageMagickJPG))
{
using (MemoryStream memStream = new MemoryStream())
{
ExifProfile profile = new ExifProfile(memStream);
image.AddProfile(profile);
}
}
}
private Task <string> ExtracTicketLicenseCodeViaTagsAsync(Stream imageStream)
{
imageStream.Position = 0;
MagickImage magickImage = new MagickImage(imageStream);
ExifProfile exifProfile = magickImage.GetExifProfile();
var target = exifProfile?.Values?.FirstOrDefault(z => z.Tag == ExifTag.ImageUniqueID);
return(Task.FromResult((string)target?.Value));
}
private static ExifProfile GetExifProfile()
{
using (FileStream stream = File.OpenRead(TestImages.Jpeg.Floorplan))
{
Image image = new Image(stream);
ExifProfile profile = image.ExifProfile;
Assert.NotNull(profile);
return(profile);
}
}
public void Values()
{
ExifProfile profile = GetExifProfile();
TestProfile(profile);
var thumbnail = profile.CreateThumbnail <Color, uint>();
Assert.NotNull(thumbnail);
Assert.Equal(256, thumbnail.Width);
Assert.Equal(170, thumbnail.Height);
}
private static void TestMetadataImpl(
bool useIdentify,
IImageDecoder decoder,
string imagePath,
int expectedPixelSize,
bool exifProfilePresent,
bool iccProfilePresent)
{
TestImageInfo(
imagePath,
decoder,
useIdentify,
imageInfo =>
{
Assert.NotNull(imageInfo);
Assert.NotNull(imageInfo.PixelType);
if (useIdentify)
{
Assert.Equal(expectedPixelSize, imageInfo.PixelType.BitsPerPixel);
}
else
{
// When full Image<TPixel> decoding is performed, BitsPerPixel will match TPixel
int bpp32 = Unsafe.SizeOf <Rgba32>() * 8;
Assert.Equal(bpp32, imageInfo.PixelType.BitsPerPixel);
}
ExifProfile exifProfile = imageInfo.Metadata.ExifProfile;
if (exifProfilePresent)
{
Assert.NotNull(exifProfile);
Assert.NotEmpty(exifProfile.Values);
}
else
{
Assert.Null(exifProfile);
}
IccProfile iccProfile = imageInfo.Metadata.IccProfile;
if (iccProfilePresent)
{
Assert.NotNull(iccProfile);
Assert.NotEmpty(iccProfile.Entries);
}
else
{
Assert.Null(iccProfile);
}
});
}
