a

Metadata/Models/B_Metadata.cs

@@ -2,13 +2,11 @@ using MetadataExtractor;
 using MetadataExtractor.Formats.Avi;
 using MetadataExtractor.Formats.Exif;
 using MetadataExtractor.Formats.QuickTime;
-using System.Diagnostics;
+using System.Collections.ObjectModel;
 using System.Text.Json;
-using View_by_Distance.Metadata.Models.Stateless;
 using View_by_Distance.Shared.Models;
 using View_by_Distance.Shared.Models.Methods;
 using View_by_Distance.Shared.Models.Properties;
-using View_by_Distance.Shared.Models.Stateless;
 
 namespace View_by_Distance.Metadata.Models;
 
@@ -51,54 +49,10 @@ public class B_Metadata : IMetadata<MetadataExtractor.Directory>
         return result;
     }
 
-    private Dictionary<string, List<KeyValuePair<string, string>>> GetMetadataCollection(string subFile)
+    public ReadOnlyDictionary<string, MetadataExtractorDirectory> GetMetadataCollection(List<Tuple<string, DateTime>> subFileTuples, List<string> parseExceptions, string[] changesFrom, MappingFromItem mappingFromItem)
     {
-        Dictionary<string, List<KeyValuePair<string, string>>> results = new();
-        if (_Log is null)
-            throw new NullReferenceException(nameof(_Log));
-        try
-        {
-            object? @object;
-            string? tagDescription;
-            List<string> tagNames = new();
-            int type = (int)IExif.Tags.Orientation;
-            string key = nameof(IExif.Tags.Orientation);
-            IReadOnlyList<MetadataExtractor.Directory> directories = ImageMetadataReader.ReadMetadata(subFile);
-            foreach (MetadataExtractor.Directory directory in directories)
-            {
-                if (!results.ContainsKey(directory.Name))
-                    results.Add(directory.Name, new());
-                foreach (Tag tag in directory.Tags)
-                {
-                    tagNames.Add(tag.Name);
-                    if (string.IsNullOrEmpty(tag.Description))
-                        continue;
-                    results[directory.Name].Add(new KeyValuePair<string, string>(string.Concat(tag.Type, '\t', tag.Name), tag.Description));
-                }
-                if (tagNames.Contains(key) && !results.ContainsKey(key))
-                {
-                    @object = directory.GetObject(type);
-                    if (@object is null)
-                        continue;
-                    tagDescription = @object.ToString();
-                    if (string.IsNullOrEmpty(tagDescription))
-                        continue;
-                    results.Add(key, new() { new(string.Concat(type, '\t', key), tagDescription) });
-                }
-            }
-        }
-        catch (Exception)
-        {
-            _Log.Info(string.Concat(new StackFrame().GetMethod()?.Name, " <", subFile, ">"));
-        }
-        return results;
-    }
-
-    public (int, List<KeyValuePair<string, string>>) GetMetadataCollection(List<Tuple<string, DateTime>> subFileTuples, List<string> parseExceptions, string[] changesFrom, MappingFromItem mappingFromItem)
-    {
-        List<KeyValuePair<string, string>> results = new();
+        Dictionary<string, MetadataExtractorDirectory>? results = null;
         string json = string.Empty;
-        Dictionary<string, List<KeyValuePair<string, string>>>? dictionary;
         List<DateTime> dateTimes = (from l in subFileTuples where changesFrom.Contains(l.Item1) select l.Item2).ToList();
         (_, int directoryIndex) = Shared.Models.Stateless.Methods.IPath.GetDirectoryNameAndIndex(_PropertyConfiguration.ResultAllInOneSubdirectoryLength, mappingFromItem.ImageFileHolder.Name);
         FileInfo fileInfo = new(Path.Combine(_FileGroups[_PropertyConfiguration.ResultSingleton][directoryIndex], $"{mappingFromItem.ImageFileHolder.NameWithoutExtension}{mappingFromItem.ImageFileHolder.ExtensionLowered}.json"));
@@ -113,33 +67,34 @@ public class B_Metadata : IMetadata<MetadataExtractor.Directory>
             fileInfo.Refresh();
         }
         if (_PropertiesChangedForMetadata)
-            dictionary = new();
+            results = null;
         else if (!fileInfo.Exists)
-            dictionary = new();
+            results = null;
         else if (!fileInfo.FullName.EndsWith(".json") && !fileInfo.FullName.EndsWith(".old"))
             throw new ArgumentException("must be a *.json file");
         else if (dateTimes.Any() && dateTimes.Max() > fileInfo.LastWriteTime)
-            dictionary = new();
+            results = null;
         else
         {
             json = File.ReadAllText(fileInfo.FullName);
             try
             {
-                dictionary = JsonSerializer.Deserialize<Dictionary<string, List<KeyValuePair<string, string>>>>(json);
-                if (dictionary is null)
+                results = Stateless.Methods.Metadata.Deserialize(json);
+                if (results is null)
                     throw new Exception();
                 subFileTuples.Add(new Tuple<string, DateTime>(nameof(B_Metadata), fileInfo.LastWriteTime));
             }
             catch (Exception)
             {
-                dictionary = new();
+                results = null;
                 parseExceptions.Add(nameof(B_Metadata));
             }
         }
-        if (dictionary is null || !dictionary.Any())
+        if (results is null || results.Count == 0)
         {
-            dictionary = GetMetadataCollection(mappingFromItem.ImageFileHolder.FullName);
-            json = JsonSerializer.Serialize(dictionary, _WriteIndentedJsonSerializerOptions);
+            IReadOnlyList<MetadataExtractor.Directory> directories = ImageMetadataReader.ReadMetadata(mappingFromItem.ImageFileHolder.FullName);
+            results = Stateless.Methods.Metadata.Covert(directories);
+            json = JsonSerializer.Serialize(results, DictionaryStringMetadataExtractorDirectorySourceGenerationContext.Default.DictionaryStringMetadataExtractorDirectory);
             bool updateDateWhenMatches = dateTimes.Any() && fileInfo.Exists && dateTimes.Max() > fileInfo.LastWriteTime;
             DateTime? dateTime = !updateDateWhenMatches ? null : dateTimes.Max();
             if (Shared.Models.Stateless.Methods.IPath.WriteAllText(fileInfo.FullName, json, updateDateWhenMatches, compareBeforeWrite: true, updateToWhenMatches: dateTime))
@@ -154,12 +109,7 @@ public class B_Metadata : IMetadata<MetadataExtractor.Directory>
                 }
             }
         }
-        foreach (KeyValuePair<string, List<KeyValuePair<string, string>>> keyValuePair in dictionary)
-        {
-            foreach (KeyValuePair<string, string> keyValue in keyValuePair.Value)
-                results.Add(new(string.Concat(keyValuePair.Key, '\t', keyValue.Key), keyValue.Value));
-        }
-        return new(dictionary.Count, results);
+        return new(results);
     }
 
     (DateTime?, DateTime?[]) IMetadata<MetadataExtractor.Directory>.GetDateTimes(FileHolder fileHolder, IReadOnlyList<MetadataExtractor.Directory> directories)

Metadata/Models/MetadataExtractorDirectory.cs

@@ -0,0 +1,43 @@
+using System.Collections.ObjectModel;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace View_by_Distance.Metadata.Models;
+
+public record MetadataExtractorDirectory(string Name,
+                                         bool HasError,
+                                         ReadOnlyCollection<string> Errors,
+                                         ReadOnlyDictionary<int, MetadataExtractorTag> Tags)
+{
+
+    public override string ToString()
+    {
+        string result = JsonSerializer.Serialize(this, MetadataExtractorDirectorySourceGenerationContext.Default.MetadataExtractorDirectory);
+        return result;
+    }
+
+}
+
+[JsonSourceGenerationOptions(WriteIndented = true)]
+[JsonSerializable(typeof(MetadataExtractorDirectory))]
+public partial class MetadataExtractorDirectorySourceGenerationContext : JsonSerializerContext
+{
+}
+
+[JsonSourceGenerationOptions(WriteIndented = true)]
+[JsonSerializable(typeof(List<MetadataExtractorDirectory>))]
+public partial class MetadataExtractorDirectoryCollectionSourceGenerationContext : JsonSerializerContext
+{
+}
+
+[JsonSourceGenerationOptions(WriteIndented = true)]
+[JsonSerializable(typeof(Dictionary<string, MetadataExtractorDirectory>))]
+public partial class DictionaryStringMetadataExtractorDirectorySourceGenerationContext : JsonSerializerContext
+{
+}
+
+[JsonSourceGenerationOptions(WriteIndented = true)]
+[JsonSerializable(typeof(ReadOnlyDictionary<string, MetadataExtractorDirectory>))]
+public partial class ReadOnlyDictionaryStringMetadataExtractorDirectorySourceGenerationContext : JsonSerializerContext
+{
+}

Metadata/Models/MetadataExtractorTag.cs

@@ -0,0 +1,43 @@
+using System.Collections.ObjectModel;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace View_by_Distance.Metadata.Models;
+
+public record MetadataExtractorTag(int Type,
+                                   string? Description,
+                                   bool HasName,
+                                   string Name)
+{
+
+    public override string ToString()
+    {
+        string result = JsonSerializer.Serialize(this, MetadataExtractorTagSourceGenerationContext.Default.MetadataExtractorTag);
+        return result;
+    }
+
+}
+
+[JsonSourceGenerationOptions(WriteIndented = true)]
+[JsonSerializable(typeof(MetadataExtractorTag))]
+public partial class MetadataExtractorTagSourceGenerationContext : JsonSerializerContext
+{
+}
+
+[JsonSourceGenerationOptions(WriteIndented = true)]
+[JsonSerializable(typeof(List<MetadataExtractorTag>))]
+public partial class MetadataExtractorTagCollectionSourceGenerationContext : JsonSerializerContext
+{
+}
+
+[JsonSourceGenerationOptions(WriteIndented = true)]
+[JsonSerializable(typeof(Dictionary<string, MetadataExtractorTag>))]
+public partial class DictionaryStringMetadataExtractorTagSourceGenerationContext : JsonSerializerContext
+{
+}
+
+[JsonSourceGenerationOptions(WriteIndented = true)]
+[JsonSerializable(typeof(ReadOnlyDictionary<string, MetadataExtractorTag>))]
+public partial class ReadOnlyDictionaryStringMetadataExtractorTagSourceGenerationContext : JsonSerializerContext
+{
+}

Metadata/Models/Record.cs

@@ -0,0 +1,24 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace View_by_Distance.Metadata.Models.Stateless.Methods;
+
+internal record Record(string Name,
+                       bool HasError,
+                       List<string> Errors,
+                       Dictionary<int, MetadataExtractorTag> Tags)
+{
+
+    public override string ToString()
+    {
+        string result = JsonSerializer.Serialize(this, RecordSourceGenerationContext.Default.Record);
+        return result;
+    }
+
+}
+
+[JsonSourceGenerationOptions(WriteIndented = true)]
+[JsonSerializable(typeof(Record))]
+internal partial class RecordSourceGenerationContext : JsonSerializerContext
+{
+}

Metadata/Models/Stateless/Methods/IMetadata.cs

@@ -1,8 +1,24 @@
+using MetadataExtractor;
+using System.Collections.ObjectModel;
+
 namespace View_by_Distance.Metadata.Models.Stateless.Methods;
 
 public interface IMetadata
 {
 
+    enum DistanceUnit
+    {
+        Miles,
+        NauticalMiles,
+        Kilometers,
+        Meters
+    }
+
+    ReadOnlyDictionary<string, MetadataExtractorDirectory> TestStatic_Covert(IReadOnlyList<MetadataExtractor.Directory> directories) =>
+        Covert(directories);
+    static ReadOnlyDictionary<string, MetadataExtractorDirectory> Covert(IReadOnlyList<MetadataExtractor.Directory> directories) =>
+        new(Metadata.Covert(directories));
+
     string? TestStatic_GetModel(IReadOnlyList<MetadataExtractor.Directory> directories) =>
         GetModel(directories);
     static string? GetModel(IReadOnlyList<MetadataExtractor.Directory> directories) =>
@@ -18,9 +34,19 @@ public interface IMetadata
     static string? GetOutputResolution(IReadOnlyList<MetadataExtractor.Directory> directories) =>
         Metadata.GetOutputResolution(directories);
 
-    int TestStatic_GetOrientation(List<KeyValuePair<string, string>> metadataCollection) =>
-        GetOrientation(metadataCollection);
-    static int GetOrientation(List<KeyValuePair<string, string>> metadataCollection) =>
-        Metadata.GetOrientation(metadataCollection);
+    GeoLocation? TestStatic_GeoLocation(IReadOnlyList<MetadataExtractor.Directory> directories) =>
+        GeoLocation(directories);
+    static GeoLocation? GeoLocation(IReadOnlyList<MetadataExtractor.Directory> directories) =>
+        Metadata.GeoLocation(directories);
+
+    GeoLocation? TestStatic_GeoLocation(ReadOnlyDictionary<string, MetadataExtractorDirectory> metadataExtractorDirectories) =>
+        GeoLocation(metadataExtractorDirectories);
+    static GeoLocation? GeoLocation(ReadOnlyDictionary<string, MetadataExtractorDirectory> metadataExtractorDirectories) =>
+        Metadata.GeoLocation(metadataExtractorDirectories);
+
+    double? TestStatic_GetDistance(double originLatitude, double originLongitude, double destinationLatitude, double destinationLongitude, int decimalPlaces = 1, DistanceUnit distanceUnit = DistanceUnit.Miles) =>
+        GetDistance(originLatitude, originLongitude, destinationLatitude, destinationLongitude, decimalPlaces, distanceUnit);
+    static double? GetDistance(double originLatitude, double originLongitude, double destinationLatitude, double destinationLongitude, int decimalPlaces = 1, DistanceUnit distanceUnit = DistanceUnit.Miles) =>
+        Metadata.GetDistance(originLatitude, originLongitude, destinationLatitude, destinationLongitude, decimalPlaces, distanceUnit);
 
 }

Metadata/Models/Stateless/Methods/Metadata.cs

@@ -1,12 +1,55 @@
 using MetadataExtractor;
 using MetadataExtractor.Formats.Exif;
-using View_by_Distance.Shared.Models.Stateless;
+using System.Collections.ObjectModel;
+using System.Text.Json;
+using static View_by_Distance.Metadata.Models.Stateless.Methods.IMetadata;
 
 namespace View_by_Distance.Metadata.Models.Stateless.Methods;
 
-internal class Metadata
+internal partial class Metadata
 {
 
+    internal static Dictionary<string, MetadataExtractorDirectory> Covert(IReadOnlyList<MetadataExtractor.Directory> directories)
+    {
+        Dictionary<string, MetadataExtractorDirectory> results = new();
+        MetadataExtractorTag metadataExtractorTag;
+        MetadataExtractorDirectory? metadataExtractorDirectory;
+        Dictionary<int, MetadataExtractorTag> metadataExtractorTags;
+        foreach (MetadataExtractor.Directory directory in directories)
+        {
+            metadataExtractorTags = new();
+            if (results.TryGetValue(directory.Name, out metadataExtractorDirectory))
+                continue;
+            foreach (Tag tag in directory.Tags)
+            {
+                metadataExtractorTag = new(tag.Type, tag.Description, tag.HasName, tag.Name);
+                metadataExtractorTags.Add(tag.Type, metadataExtractorTag);
+            }
+            metadataExtractorDirectory = new(directory.Name, directory.HasError, new(directory.Errors.ToArray()), new(metadataExtractorTags));
+            results.Add(directory.Name, metadataExtractorDirectory);
+        }
+        return results;
+    }
+
+    internal static Dictionary<string, MetadataExtractorDirectory> Deserialize(string json)
+    {
+        Dictionary<string, MetadataExtractorDirectory> results = new();
+        Record? record;
+        MetadataExtractorDirectory metadataExtractorDirectory;
+        Dictionary<string, JsonElement>? keyValuePairs = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(json);
+        if (keyValuePairs is null)
+            throw new NullReferenceException(nameof(keyValuePairs));
+        foreach (KeyValuePair<string, JsonElement> keyValuePair in keyValuePairs)
+        {
+            record = JsonSerializer.Deserialize(keyValuePair.Value.ToString(), RecordSourceGenerationContext.Default.Record);
+            if (record is null)
+                throw new NullReferenceException(nameof(record));
+            metadataExtractorDirectory = new(record.Name, record.HasError, new(record.Errors), new(record.Tags));
+            results.Add(record.Name, metadataExtractorDirectory);
+        }
+        return results;
+    }
+
     internal static string? GetFaceEncoding(IReadOnlyList<MetadataExtractor.Directory> directories)
     {
         string? result;
@@ -62,15 +105,124 @@ internal class Metadata
         return result;
     }
 
-    internal static int GetOrientation(List<KeyValuePair<string, string>> metadataCollection)
+    internal static GeoLocation? GeoLocation(IReadOnlyList<MetadataExtractor.Directory> directories)
     {
-        int result;
-        const string orientation = nameof(IExif.Tags.Orientation);
-        List<string> orientations = (from l in metadataCollection where l.Key.Contains(orientation) select l.Value).ToList();
-        if (!orientations.Any())
-            result = 0;
-        else if (!int.TryParse(orientations[0], out result))
-            result = 0;
+        GeoLocation? result;
+        GpsDirectory? gpsDirectory = directories.OfType<GpsDirectory>().FirstOrDefault();
+        if (gpsDirectory is null)
+            result = null;
+        else
+            result = gpsDirectory.GetGeoLocation();
+        return result;
+    }
+
+    private static bool CoordinateValidatorValidate(double latitude, double longitude)
+    {
+        if (latitude is < (-90) or > 90)
+            return false;
+        if (longitude is < (-180) or > 180)
+            return false;
+
+        return true;
+    }
+
+    private static double GetRadius(DistanceUnit distanceUnit)
+    {
+        return distanceUnit switch
+        {
+            DistanceUnit.Kilometers => 6371.0, // EarthRadiusInKilometers;
+            DistanceUnit.Meters => 6371000.0, // EarthRadiusInMeters;
+            DistanceUnit.NauticalMiles => 3440.0, // EarthRadiusInNauticalMiles;
+            DistanceUnit.Miles => 3959.0, // EarthRadiusInMiles;
+            _ => throw new NotSupportedException()
+        };
+    }
+
+    private static double ToRadian(double d) =>
+        d * (Math.PI / 180);
+
+    private static double DiffRadian(double val1, double val2) =>
+        ToRadian(val2) - ToRadian(val1);
+
+    internal static double GetDistance(double originLatitude, double originLongitude, double destinationLatitude, double destinationLongitude, int decimalPlaces = 1, DistanceUnit distanceUnit = DistanceUnit.Miles)
+    {
+        if (!CoordinateValidatorValidate(originLatitude, originLongitude))
+            throw new ArgumentException("Invalid origin coordinates supplied.");
+        if (!CoordinateValidatorValidate(destinationLatitude, destinationLongitude))
+            throw new ArgumentException("Invalid destination coordinates supplied.");
+        double radius = GetRadius(distanceUnit);
+        return Math.Round(
+                radius * 2 *
+                Math.Asin(Math.Min(1,
+                                   Math.Sqrt(
+                                       Math.Pow(Math.Sin(DiffRadian(originLatitude, destinationLatitude) / 2.0), 2.0) +
+                                        Math.Cos(ToRadian(originLatitude)) * Math.Cos(ToRadian(destinationLatitude)) *
+                                        Math.Pow(Math.Sin(DiffRadian(originLongitude, destinationLongitude) / 2.0),
+                                                 2.0)))), decimalPlaces);
+    }
+
+    private static double ParseValueFromDmsString(string value)
+    {
+        double result;
+        if (string.IsNullOrEmpty(value))
+            return double.MinValue;
+
+        double secondsValue;
+        string[] degrees = value.Split('°');
+        if (degrees.Length != 2)
+            return double.MinValue;
+        if (!double.TryParse(degrees[0], out double degreesValue))
+            return double.MinValue;
+
+        string[] minutes = degrees[1].Split('\'');
+        if (minutes.Length != 2)
+            return double.MinValue;
+        if (!double.TryParse(minutes[0], out double minutesValue))
+            return double.MinValue;
+
+        string[] seconds = minutes[1].Split('"');
+        if (seconds.Length != 2)
+            secondsValue = 0;
+        else
+        {
+            if (!double.TryParse(seconds[0], out secondsValue))
+                return double.MinValue;
+        }
+        result = Math.Abs(degreesValue) + (minutesValue / 60) + (secondsValue / 3600);
+
+        if (degreesValue < 0)
+            result *= -1;
+
+        return result;
+    }
+
+    internal static GeoLocation? GeoLocation(ReadOnlyDictionary<string, MetadataExtractorDirectory> metadataExtractorDirectories)
+    {
+        GeoLocation? result;
+        if (!metadataExtractorDirectories.TryGetValue("GPS", out MetadataExtractorDirectory? metadataExtractorDirectory))
+            result = null;
+        else
+        {
+            MetadataExtractorTag? metadataExtractorTag;
+            if (!metadataExtractorDirectory.Tags.TryGetValue((int)Shared.Models.Stateless.IExif.Tags.GPSLatitude, out metadataExtractorTag) || string.IsNullOrEmpty(metadataExtractorTag.Description))
+                result = null;
+            else
+            {
+                string latitudeDMS = metadataExtractorTag.Description;
+                double latitude = ParseValueFromDmsString(latitudeDMS);
+                if (!metadataExtractorDirectory.Tags.TryGetValue((int)Shared.Models.Stateless.IExif.Tags.GPSLongitude, out metadataExtractorTag) || string.IsNullOrEmpty(metadataExtractorTag.Description))
+                    result = null;
+                else
+                {
+                    string longitudeDMS = metadataExtractorTag.Description;
+                    double longitude = ParseValueFromDmsString(longitudeDMS);
+                    result = new(latitude, longitude);
+                    string dms = result.ToDmsString();
+                    if ($"{latitudeDMS}, {longitudeDMS}" != dms)
+                        result = null;
+                }
+            }
+        }
         return result;
     }