private static T GetExifDataFromTag <T>(ExifProfile profile, ExifTag tag)
{
var outValue = default(T);
if (profile == null)
{
return(outValue);
}
try
{
outValue = (T)profile.GetValue(tag).Value;
}
catch (InvalidCastException)
{
if (tag == ExifTag.DateTimeOriginal || tag == ExifTag.DateTime || tag == ExifTag.DateTimeDigitized)
{
var formats = new[] { "yyyy:MM:dd HH:mm:ss", "M-d-yyyy", "dd-MM-yyyy", "MM-dd-yyyy", "M.d.yyyy", "dd.MM.yyyy", "MM.dd.yyyy" };
object value = DateTime.ParseExact(profile.GetValue(tag).Value.ToString(), formats, CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal);
return((T)value);
}
}
catch
{// Wert ist nicht vorhanden / konnte nicht konvertiert werden
}
return(outValue);
}
public void Test_Infinity()
{
using (MagickImage image = new MagickImage(Files.FujiFilmFinePixS1ProJPG))
{
ExifProfile profile = image.GetExifProfile();
profile.SetValue(ExifTag.ExposureBiasValue, double.PositiveInfinity);
image.AddProfile(profile);
profile = image.GetExifProfile();
ExifValue value = profile.GetValue(ExifTag.ExposureBiasValue);
Assert.IsNotNull(value);
Assert.IsTrue(double.PositiveInfinity.Equals(value.Value));
profile.SetValue(ExifTag.ExposureBiasValue, double.NegativeInfinity);
image.AddProfile(profile);
profile = image.GetExifProfile();
value = profile.GetValue(ExifTag.ExposureBiasValue);
Assert.IsNotNull(value);
Assert.IsTrue(double.NegativeInfinity.Equals(value.Value));
profile.SetValue(ExifTag.FlashEnergy, double.NegativeInfinity);
image.AddProfile(profile);
profile = image.GetExifProfile();
value = profile.GetValue(ExifTag.FlashEnergy);
Assert.IsNotNull(value);
Assert.IsTrue(double.PositiveInfinity.Equals(value.Value));
}
}
public void TestExifTag()
{
var exifProfile = new ExifProfile();
exifProfile.SetValue(ExifTag.ResolutionUnit, (ushort)1);
IExifValue value = exifProfile.GetValue(ExifTag.ResolutionUnit);
Assert.Equal("None", value.ToString());
exifProfile.SetValue(ExifTag.ResolutionUnit, (ushort)2);
value = exifProfile.GetValue(ExifTag.ResolutionUnit);
Assert.Equal("Inches", value.ToString());
exifProfile.SetValue(ExifTag.ResolutionUnit, (ushort)3);
value = exifProfile.GetValue(ExifTag.ResolutionUnit);
Assert.Equal("Centimeter", value.ToString());
exifProfile.SetValue(ExifTag.ResolutionUnit, (ushort)4);
value = exifProfile.GetValue(ExifTag.ResolutionUnit);
Assert.Equal("4", value.ToString());
exifProfile.SetValue(ExifTag.ImageWidth, 123U);
value = exifProfile.GetValue(ExifTag.ImageWidth);
Assert.Equal("123", value.ToString());
}
public void Identify_ReadsLegacyExifData(string imagePath)
{
var testFile = TestFile.Create(imagePath);
using (var stream = new MemoryStream(testFile.Bytes, false))
{
IImageInfo imageInfo = Image.Identify(stream);
Assert.NotNull(imageInfo);
Assert.NotNull(imageInfo.Metadata.ExifProfile);
PngMetadata meta = imageInfo.Metadata.GetFormatMetadata(PngFormat.Instance);
Assert.DoesNotContain(meta.TextData, t => t.Keyword.Equals("Raw profile type exif", StringComparison.OrdinalIgnoreCase));
ExifProfile exif = imageInfo.Metadata.ExifProfile;
Assert.Equal(0, exif.InvalidTags.Count);
Assert.Equal(3, exif.Values.Count);
Assert.Equal(
"A colorful tiling of blue, red, yellow, and green 4x4 pixel blocks.",
exif.GetValue(ExifTag.ImageDescription).Value);
Assert.Equal(
"Duplicated from basn3p02.png, then image metadata modified with exiv2",
exif.GetValue(ExifTag.ImageHistory).Value);
Assert.Equal(42, (int)exif.GetValue(ExifTag.ImageNumber).Value);
}
}
/// <summary>
/// Decodes the image data from a specified IFD.
/// </summary>
/// <typeparam name="TPixel">The pixel format.</typeparam>
/// <param name="tags">The IFD tags.</param>
/// <param name="cancellationToken">The token to monitor cancellation.</param>
/// <returns> The tiff frame. </returns>
private ImageFrame <TPixel> DecodeFrame <TPixel>(ExifProfile tags, CancellationToken cancellationToken)
where TPixel : unmanaged, IPixel <TPixel>
{
ImageFrameMetadata imageFrameMetaData = this.ignoreMetadata ?
new ImageFrameMetadata() :
new ImageFrameMetadata {
ExifProfile = tags, XmpProfile = tags.GetValue(ExifTag.XMP)?.Value
};
TiffFrameMetadata tiffFrameMetaData = imageFrameMetaData.GetTiffMetadata();
TiffFrameMetadata.Parse(tiffFrameMetaData, tags);
this.VerifyAndParse(tags, tiffFrameMetaData);
int width = GetImageWidth(tags);
int height = GetImageHeight(tags);
var frame = new ImageFrame <TPixel>(this.Configuration, width, height, imageFrameMetaData);
int rowsPerStrip = tags.GetValue(ExifTag.RowsPerStrip) != null ? (int)tags.GetValue(ExifTag.RowsPerStrip).Value : TiffConstants.RowsPerStripInfinity;
Number[] stripOffsets = tags.GetValue(ExifTag.StripOffsets)?.Value;
Number[] stripByteCounts = tags.GetValue(ExifTag.StripByteCounts)?.Value;
if (this.PlanarConfiguration == TiffPlanarConfiguration.Planar)
{
this.DecodeStripsPlanar(frame, rowsPerStrip, stripOffsets, stripByteCounts, cancellationToken);
}
else
{
this.DecodeStripsChunky(frame, rowsPerStrip, stripOffsets, stripByteCounts, cancellationToken);
}
return(frame);
}
public void Test_Infinity()
{
using (IMagickImage image = new MagickImage(Files.FujiFilmFinePixS1ProJPG))
{
ExifProfile profile = image.GetExifProfile();
profile.SetValue(ExifTag.ExposureBiasValue, new SignedRational(double.PositiveInfinity));
image.AddProfile(profile);
profile = image.GetExifProfile();
ExifValue value = profile.GetValue(ExifTag.ExposureBiasValue);
Assert.IsNotNull(value);
Assert.AreEqual(double.PositiveInfinity, ((SignedRational)value.Value).ToDouble());
profile.SetValue(ExifTag.ExposureBiasValue, new SignedRational(double.NegativeInfinity));
image.AddProfile(profile);
profile = image.GetExifProfile();
value = profile.GetValue(ExifTag.ExposureBiasValue);
Assert.IsNotNull(value);
Assert.AreEqual(double.NegativeInfinity, ((SignedRational)value.Value).ToDouble());
profile.SetValue(ExifTag.FlashEnergy, new Rational(double.NegativeInfinity));
image.AddProfile(profile);
profile = image.GetExifProfile();
value = profile.GetValue(ExifTag.FlashEnergy);
Assert.IsNotNull(value);
Assert.AreEqual(double.PositiveInfinity, ((Rational)value.Value).ToDouble());
}
}
private static void TestProfile(ExifProfile profile)
{
Assert.NotNull(profile);
// todo: duplicate tags
Assert.Equal(2, profile.Values.Count(v => (ushort)v.Tag == 59932));
Assert.Equal(16, profile.Values.Count);
foreach (IExifValue value in profile.Values)
{
Assert.NotNull(value.GetValue());
}
IExifValue <string> software = profile.GetValue(ExifTag.Software);
Assert.Equal("Windows Photo Editor 10.0.10011.16384", software.Value);
IExifValue <Rational> xResolution = profile.GetValue(ExifTag.XResolution);
Assert.Equal(new Rational(300.0), xResolution.Value);
IExifValue <Number> xDimension = profile.GetValue(ExifTag.PixelXDimension);
Assert.Equal(2338U, xDimension.Value);
}
private async Task <GeoLocation?> GetGeoLocationDataAsync(
ExifProfile exifProfile,
CancellationToken cancellationToken)
{
IExifValue <Rational[]> lat = exifProfile.GetValue(ExifTag.GPSLatitude);
IExifValue <Rational[]> lon = exifProfile.GetValue(ExifTag.GPSLongitude);
IExifValue <string> latRef = exifProfile.GetValue(ExifTag.GPSLatitudeRef);
IExifValue <string> lonRef = exifProfile.GetValue(ExifTag.GPSLongitudeRef);
IExifValue <Rational> alt = exifProfile.GetValue(ExifTag.GPSAltitude);
if (lat != null)
{
var gps = new GeoLocation()
{
Type = "gps",
Point = new GeoPoint()
};
var latValue = ConvertToLocation(lat.Value);
var lonValue = ConvertToLocation(lon.Value);
if (latRef.Value.ToString() == "S")
{
latValue = latValue * -1;
}
if (lonRef.Value.ToString() == "W")
{
lonValue = lonValue * -1;
}
gps.Point = GeoPoint.Create(latValue, lonValue);
if (alt != null)
{
var dominator = (int)alt.Value.Denominator;
if (dominator == 0)
{
dominator = 1;
}
gps.Altitude = (int)alt.Value.Numerator / dominator;
}
gps.GeoHash = GeoHash.Encode(gps.Point.Coordinates[1], gps.Point.Coordinates[0]);
gps.Address = await _geoDecoderService.DecodeAsync(
gps.Point.Coordinates[1],
gps.Point.Coordinates[0],
cancellationToken);
return(gps);
}
return(null);
}
/// <summary>
/// Decodes the image data from a specified IFD.
/// </summary>
/// <typeparam name="TPixel">The pixel format.</typeparam>
/// <param name="tags">The IFD tags.</param>
/// <param name="cancellationToken">The token to monitor cancellation.</param>
/// <returns> The tiff frame. </returns>
private ImageFrame <TPixel> DecodeFrame <TPixel>(ExifProfile tags, CancellationToken cancellationToken)
where TPixel : unmanaged, IPixel <TPixel>
{
var imageFrameMetaData = new ImageFrameMetadata();
if (!this.ignoreMetadata)
{
imageFrameMetaData.ExifProfile = tags;
}
TiffFrameMetadata tiffFrameMetaData = imageFrameMetaData.GetTiffMetadata();
TiffFrameMetadata.Parse(tiffFrameMetaData, tags);
this.VerifyAndParse(tags, tiffFrameMetaData);
int width = GetImageWidth(tags);
int height = GetImageHeight(tags);
var frame = new ImageFrame <TPixel>(this.Configuration, width, height, imageFrameMetaData);
int rowsPerStrip = tags.GetValue(ExifTag.RowsPerStrip) != null ? (int)tags.GetValue(ExifTag.RowsPerStrip).Value : TiffConstants.RowsPerStripInfinity;
var stripOffsetsArray = (Array)tags.GetValueInternal(ExifTag.StripOffsets).GetValue();
var stripByteCountsArray = (Array)tags.GetValueInternal(ExifTag.StripByteCounts).GetValue();
IMemoryOwner <ulong> stripOffsetsMemory = this.ConvertNumbers(stripOffsetsArray, out Span <ulong> stripOffsets);
IMemoryOwner <ulong> stripByteCountsMemory = this.ConvertNumbers(stripByteCountsArray, out Span <ulong> stripByteCounts);
if (this.PlanarConfiguration == TiffPlanarConfiguration.Planar)
{
this.DecodeStripsPlanar(
frame,
rowsPerStrip,
stripOffsets,
stripByteCounts,
cancellationToken);
}
else
{
this.DecodeStripsChunky(
frame,
rowsPerStrip,
stripOffsets,
stripByteCounts,
cancellationToken);
}
stripOffsetsMemory?.Dispose();
stripByteCountsMemory?.Dispose();
return(frame);
}
public void ShouldReadTheExifChunk()
{
using (var input = new MagickImage(MagickColors.YellowGreen, 1, 1))
{
IExifProfile exifProfile = new ExifProfile();
exifProfile.SetValue(ExifTag.ImageUniqueID, "Have a nice day");
input.SetProfile(exifProfile);
using (var memoryStream = new MemoryStream())
{
input.Write(memoryStream, MagickFormat.Png);
memoryStream.Position = 0;
using (var output = new MagickImage(memoryStream))
{
exifProfile = output.GetExifProfile();
Assert.NotNull(exifProfile);
var value = exifProfile.GetValue(ExifTag.ImageUniqueID);
Assert.Equal("Have a nice day", value.ToString());
}
}
}
}
public static PixelResolutionUnit ExifProfileToResolutionUnit(ExifProfile?profile)
{
var resolution = profile?.GetValue(ExifTag.ResolutionUnit);
// EXIF is 1, 2, 3 so we minus "1" off the result.
return(resolution is null ? default : (PixelResolutionUnit)(byte)(resolution.Value - 1));
}
private CameraData?GetCameraData(ExifProfile exifProfile)
{
IExifValue <string> model = exifProfile.GetValue(ExifTag.Model);
IExifValue <string> make = exifProfile.GetValue(ExifTag.Make);
if (model?.GetValue() != null)
{
return(new CameraData
{
Model = model.ToString(),
Make = make.ToString()
});
}
return(null);
}
internal static void ClearValue(this ExifProfile profile, ExifTag tag)
{
if (profile.GetValue(tag) != null)
{
profile.RemoveValue(tag);
}
}
private static void RemoveTag <T>(ExifTag <T> exifTag, ExifProfile exifProfile)
{
if (exifProfile.GetValue <T>(exifTag) != null)
{
exifProfile.RemoveValue(exifTag);
}
}
public string getImageComment(string jpegFileInputPath)
{
string result = null;
if (!File.Exists(jpegFileInputPath))
{
log.Error(String.Format("File does not exist. File : {0}.", jpegFileInputPath));
}
else
{
try
{
using (MagickImage image = new MagickImage(jpegFileInputPath))
{
ExifProfile profile = image.GetExifProfile();
ExifValue value = profile.GetValue(ExifTag.ImageDescription);
result = value.ToString();
}
}
catch (Exception ex)
{
log.Error(String.Format("Problem reading comments from file \"{0}\". Exception : {1}.", jpegFileInputPath, ex));
}
}
return(result);
}
public void ReadWriteLargeProfileJpg(ExifTag exifValueToChange)
{
// arrange
var junk = new StringBuilder();
for (int i = 0; i < 65600; i++)
{
junk.Append("a");
}
var image = new Image <Rgba32>(100, 100);
ExifProfile expectedProfile = CreateExifProfile();
var expectedProfileTags = expectedProfile.Values.Select(x => x.Tag).ToList();
expectedProfile.SetValue(exifValueToChange, junk.ToString());
image.MetaData.ExifProfile = expectedProfile;
// act
Image <Rgba32> reloadedImage = WriteAndRead(image, TestImageWriteFormat.Jpeg);
// assert
ExifProfile actualProfile = reloadedImage.MetaData.ExifProfile;
Assert.NotNull(actualProfile);
foreach (ExifTag expectedProfileTag in expectedProfileTags)
{
ExifValue actualProfileValue = actualProfile.GetValue(expectedProfileTag);
ExifValue expectedProfileValue = expectedProfile.GetValue(expectedProfileTag);
Assert.Equal(expectedProfileValue.Value, actualProfileValue.Value);
}
}
public static PixelResolutionUnit ExifProfileToResolutionUnit(ExifProfile profile)
{
IExifValue <ushort> resolution = profile.GetValue(ExifTag.ResolutionUnit);
// EXIF is 1, 2, 3 so we minus "1" off the result.
return(resolution is null ? DefaultResolutionUnit : (PixelResolutionUnit)(byte)(resolution.Value - 1));
}
private DateTime GetPictureDate(MagickImage image)
{
//Set Date
DateTime?pictureDate = null;
//Get Date Taken
ExifProfile profile = image.GetExifProfile();
if (!(profile is null))
{
ExifValue dateTakeExif = profile.GetValue(ExifTag.DateTimeDigitized);
if (!(dateTakeExif is null))
{
pictureDate = DateTime.ParseExact(dateTakeExif.Value.ToString().TrimEnd('\0'), "yyyy:MM:dd HH:mm:ss", null);
}
}
//Get File Creation Date
if (pictureDate is null)
{
pictureDate = File.GetCreationTime(image.FileName);
}
//Default to Today
if (pictureDate is null)
{
pictureDate = DateTime.Now;
}
return(pictureDate.Value);
}
public void TiffDecoder_SubIfd8 <TPixel>(TestImageProvider <TPixel> provider)
where TPixel : unmanaged, IPixel <TPixel>
{
using Image <TPixel> image = provider.GetImage(TiffDecoder);
ExifProfile meta = image.Frames.RootFrame.Metadata.ExifProfile;
Assert.Equal(0, meta.InvalidTags.Count);
Assert.Equal(6, meta.Values.Count);
Assert.Equal(64, (int)meta.GetValue(ExifTag.ImageWidth).Value);
Assert.Equal(64, (int)meta.GetValue(ExifTag.ImageLength).Value);
Assert.Equal(64, (int)meta.GetValue(ExifTag.RowsPerStrip).Value);
Assert.Equal(1, meta.Values.Count(v => (ushort)v.Tag == (ushort)ExifTagValue.ImageWidth));
Assert.Equal(1, meta.Values.Count(v => (ushort)v.Tag == (ushort)ExifTagValue.StripOffsets));
Assert.Equal(1, meta.Values.Count(v => (ushort)v.Tag == (ushort)ExifTagValue.StripByteCounts));
}
private static void VerifyExifDataIsPresent(ExifProfile exif)
{
Assert.Equal(1, exif.Values.Count);
IExifValue <string> software = exif.GetValue(ExifTag.Software);
Assert.NotNull(software);
Assert.Equal("ImageSharp", software.Value);
}
private static void VerifyRequiredFieldsArePresent(ExifProfile exifProfile, TiffFrameMetadata frameMetadata)
{
if (exifProfile.GetValue(ExifTag.StripOffsets) == null)
{
TiffThrowHelper.ThrowImageFormatException("StripOffsets are missing and are required for decoding the TIFF image!");
}
if (exifProfile.GetValue(ExifTag.StripByteCounts) == null)
{
TiffThrowHelper.ThrowImageFormatException("StripByteCounts are missing and are required for decoding the TIFF image!");
}
if (frameMetadata.BitsPerPixel == null)
{
TiffThrowHelper.ThrowNotSupported("The TIFF BitsPerSample entry is missing which is required to decode the image!");
}
}
public void ShouldCorrectlyHandleArray()
{
Rational[] latitude = new Rational[] { new Rational(12.3), new Rational(4.56), new Rational(789.0) };
var profile = new ExifProfile();
profile.SetValue(ExifTag.GPSLatitude, latitude);
var value = profile.GetValue(ExifTag.GPSLatitude);
value = profile.GetValue(ExifTag.GPSLatitude);
Assert.IsNotNull(value);
Rational[] values = (Rational[])value.Value;
Assert.IsNotNull(values);
CollectionAssert.AreEqual(latitude, values);
}
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 WriteFraction()
{
using (MemoryStream memStream = new MemoryStream())
{
double exposureTime = 1.0 / 1600;
ExifProfile profile = GetExifProfile();
profile.SetValue(ExifTag.ExposureTime, new Rational(exposureTime));
Image image = new Image(1, 1);
image.ExifProfile = profile;
image.SaveAsJpeg(memStream);
memStream.Position = 0;
image = new Image(memStream);
profile = image.ExifProfile;
Assert.NotNull(profile);
ExifValue value = profile.GetValue(ExifTag.ExposureTime);
Assert.NotNull(value);
Assert.NotEqual(exposureTime, ((Rational)value.Value).ToDouble());
memStream.Position = 0;
profile = GetExifProfile();
profile.SetValue(ExifTag.ExposureTime, new Rational(exposureTime, true));
image.ExifProfile = profile;
image.SaveAsJpeg(memStream);
memStream.Position = 0;
image = new Image(memStream);
profile = image.ExifProfile;
Assert.NotNull(profile);
value = profile.GetValue(ExifTag.ExposureTime);
Assert.Equal(exposureTime, ((Rational)value.Value).ToDouble());
}
}
private void lsbResimlistesi_SelectedIndexChanged(object sender, EventArgs e)
{
try
{
for (int i = 0; i < lsbislem.Items.Count; i++)
{
int sonuc = lsbislem.Items[i].ToString().IndexOf(lsbResimlistesi.SelectedItem.ToString());
if (sonuc > 0)
{
lsbislem.SelectedItem = lsbislem.Items[i];
}
}
txtAciklama.Text = "";
txtBaslik.Text = "";
txtEtiketler.Text = "";
txtKonu.Text = "";
secilen = lsbislem.SelectedItem.ToString();
using (MagickImage image = new MagickImage(secilen))
{
try
{
ExifProfile profile2 = image.GetExifProfile();
ExifValue Baslik = profile2.GetValue(ImageMagick.ExifTag.XPTitle);
ExifValue Aciklama = profile2.GetValue(ImageMagick.ExifTag.XPComment);
ExifValue Etiketler = profile2.GetValue(ImageMagick.ExifTag.XPKeywords);
ExifValue Konu = profile2.GetValue(ImageMagick.ExifTag.XPSubject);
txtBaslik.Text = Encoding.Unicode.GetString((byte[])Baslik.Value);
txtAciklama.Text = Encoding.Unicode.GetString((byte[])Aciklama.Value);
txtEtiketler.Text = Encoding.Unicode.GetString((byte[])Etiketler.Value);
txtKonu.Text = Encoding.Unicode.GetString((byte[])Konu.Value);
}
catch (Exception)
{
}
}
}
catch (Exception)
{
}
}
public void ShouldAllowNullValues()
{
var profile = new ExifProfile();
profile.SetValue(ExifTag.ReferenceBlackWhite, null);
var value = profile.GetValue(ExifTag.ReferenceBlackWhite);
TestValue(value, null);
}
private GeoLocation ExtractGeoLocation(ExifProfile exifProfile)
{
if (exifProfile?.GetValue(ExifTag.GPSLatitude) == null)
{
// no GPS exifProfile found.
return(null);
}
GeoLocation geo = new GeoLocation()
{
Latitude = ParseCoordinate(exifProfile.GetValue(ExifTag.GPSLatitudeRef)?.Value,
exifProfile.GetValue(ExifTag.GPSLongitude)?.Value),
Longtitude = ParseCoordinate(exifProfile.GetValue(ExifTag.GPSLongitudeRef)?.Value,
exifProfile.GetValue(ExifTag.GPSLongitude)?.Value)
};
return(geo);
}
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));
}
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));
}
public void ShouldReturnStringWhenValueIsString()
{
var profile = new ExifProfile();
profile.SetValue(ExifTag.Software, "Magick.NET");
var value = profile.GetValue(ExifTag.Software);
TestValue(value, "Magick.NET");
}
