MapFaceFileLogic

Author:

Map/.vscode/format-report.json

@@ -0,0 +1 @@
+[]

Map/.vscode/tasks.json

@@ -0,0 +1,42 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "Format",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "format",
+                "--report",
+                ".vscode",
+                "--verbosity",
+                "detailed",
+                "--severity",
+                "warn"
+            ],
+            "problemMatcher": "$msCompile"
+        },
+        {
+            "label": "Format-Whitespaces",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "format",
+                "whitespace"
+            ],
+            "problemMatcher": "$msCompile"
+        },
+        {
+            "label": "build",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "build",
+                "${workspaceFolder}/Map.csproj",
+                "/property:GenerateFullPaths=true",
+                "/consoleloggerparameters:NoSummary"
+            ],
+            "problemMatcher": "$msCompile"
+        }
+    ]
+}

Map/Models/MapLogic.cs

@@ -460,6 +460,31 @@ public partial class MapLogic : Shared.Models.Methods.IMapLogic
         return result;
     }
 
+    private (long?, string?) GetDirectory(Configuration configuration, string by, string segmentB)
+    {
+        long? ticks = null;
+        const int zero = 0;
+        string? directory = null;
+        string personKeyFormatted;
+        PersonBirthday personBirthday;
+        PersonContainer personContainer;
+        for (int i = _NotMappedPersonContainers.Count - 1; i > 0; i--)
+        {
+            if (configuration.SaveIndividually)
+                break;
+            personContainer = _NotMappedPersonContainers[i];
+            if (personContainer.Key is null || personContainer.Birthdays is null || personContainer.Birthdays.Length == 0)
+                continue;
+            personBirthday = personContainer.Birthdays[zero];
+            ticks = personBirthday.Value.Ticks;
+            personKeyFormatted = IPersonBirthday.GetFormatted(configuration.PersonBirthdayFormat, personBirthday);
+            directory = Path.Combine(_EDistanceContentTicksDirectory, by, personKeyFormatted, segmentB);
+            _NotMappedPersonContainers.RemoveAt(i);
+            break;
+        }
+        return (ticks, directory);
+    }
+
     private (long?, string?) GetDirectory(Configuration configuration, bool saveIndividually, int padLeft, string? segmentC, string by, MappingFromItem mappingFromItem)
     {
         long? ticks = null;
@@ -512,7 +537,30 @@ public partial class MapLogic : Shared.Models.Methods.IMapLogic
         return result;
     }
 
-    private Record Get(Configuration configuration, bool saveIndividually, string by, Mapping question, int padLeft)
+    private Record Get(Configuration configuration, string by, long? personKey, string? displayDirectoryName, string segmentB)
+    {
+        long? ticks;
+        string? directory;
+        string? debugDirectory;
+        string? personDirectory;
+        if (personKey is null || string.IsNullOrEmpty(displayDirectoryName))
+        {
+            debugDirectory = null;
+            (ticks, directory) = GetDirectory(configuration, by, segmentB);
+            personDirectory = directory is null ? null : Path.Combine(directory, $"X+{ticks}");
+        }
+        else
+        {
+            ticks = null;
+            string personKeyFormatted = IPersonBirthday.GetFormatted(configuration.PersonBirthdayFormat, personKey.Value);
+            debugDirectory = Path.Combine(_EDistanceContentTicksDirectory, by, personKeyFormatted, displayDirectoryName);
+            directory = Path.Combine(_EDistanceContentTicksDirectory, by, personKeyFormatted, segmentB);
+            personDirectory = Path.Combine(directory, displayDirectoryName, "lnk");
+        }
+        return new(debugDirectory, directory, ticks, personDirectory);
+    }
+
+    private Record Get(Configuration configuration, bool saveIndividually, int padLeft, string by, Mapping question)
     {
         long? ticks;
         string? directory;
@@ -594,7 +642,7 @@ public partial class MapLogic : Shared.Models.Methods.IMapLogic
                 if (!PreAndPostContinue(_Configuration, mapping, question))
                     continue;
             }
-            record = Get(_Configuration, saveIndividually, by, mapping, padLeft);
+            record = Get(_Configuration, saveIndividually, padLeft, by, mapping);
             if (string.IsNullOrEmpty(record.Directory) || string.IsNullOrEmpty(record.PersonDirectory))
                 continue;
             directory = record.Directory;
@@ -673,7 +721,7 @@ public partial class MapLogic : Shared.Models.Methods.IMapLogic
             Stateless.MapLogic.SaveMappingShortcuts(mappingDirectory);
     }
 
-    public List<Sorting> GetSortingCollection(Shared.Models.Methods.IDistanceLimits distanceLimits, int i, Face face, FaceDistance faceDistanceEncoding, List<FaceDistance> faceDistanceLengths)
+    public List<Sorting> GetSortingCollection(int i, Face face, FaceDistance faceDistanceEncoding, List<FaceDistance> faceDistanceLengths)
     {
         if (_Configuration is null)
             throw new NullReferenceException(nameof(_Configuration));
@@ -772,6 +820,94 @@ public partial class MapLogic : Shared.Models.Methods.IMapLogic
         return result;
     }
 
+    private string? GetDisplayDirectoryName(string? displayDirectoryName, LocationContainer locationContainer)
+    {
+        string? result = displayDirectoryName;
+        ReadOnlyDictionary<int, ReadOnlyCollection<PersonContainer>>? wholePercentagesToPersonContainers = GetWholePercentagesToPersonContainers(locationContainer.Id);
+        if (wholePercentagesToPersonContainers is not null)
+        {
+            foreach (KeyValuePair<int, ReadOnlyCollection<PersonContainer>> keyValuePair in wholePercentagesToPersonContainers)
+            {
+                if (keyValuePair.Key != locationContainer.WholePercentages)
+                    continue;
+                if (keyValuePair.Value.Count != 1)
+                    continue;
+                result = keyValuePair.Value[0].DisplayDirectoryName;
+            }
+        }
+        return result;
+    }
+
+    public List<SaveContainer> GetSaveContainers(string cResultsFullGroupDirectory, string dResultsFullGroupDirectory, string d2ResultsFullGroupDirectory, Shared.Models.Methods.IDistanceLimits distanceLimits, ReadOnlyCollection<LocationContainer> matrix)
+    {
+        if (_Configuration is null)
+            throw new NullReferenceException(nameof(_Configuration));
+        List<SaveContainer> results = [];
+        string by;
+        Record record;
+        string segmentB;
+        bool isBySorting;
+        string checkFile;
+        string? directory;
+        string shortcutFile;
+        string facesDirectory;
+        List<string> added = [];
+        bool isCounterPersonYear;
+        string facePartsDirectory;
+        FileHolder? faceFileHolder;
+        SaveContainer? saveContainer;
+        string? displayDirectoryName;
+        FileHolder? resizedFileHolder;
+        int? useFiltersCounter = null;
+        string resizeContentDirectory;
+        FileHolder? facePartsFileHolder;
+        FileHolder? hiddenFaceFileHolder;
+        bool sortingContainersAny = matrix.Count > 0;
+        string cContentDirectory = Path.Combine(cResultsFullGroupDirectory, _Configuration.PropertyConfiguration.ResultContent);
+        string forceSingleImageHumanized = nameof(Shared.Models.Stateless.IMapLogic.ForceSingleImage).Humanize(LetterCasing.Title);
+        string d2FacePartsContentDirectory = Path.Combine(d2ResultsFullGroupDirectory, _Configuration.PropertyConfiguration.ResultContent);
+        foreach (LocationContainer locationContainer in matrix)
+        {
+            if (_Configuration.SaveIndividually)
+                break;
+            if (locationContainer.LengthPermyriad is null || locationContainer.LengthSource is null)
+                continue;
+            if (added.Contains(locationContainer.LengthSource.Name))
+                continue;
+            segmentB = locationContainer.LengthPermyriad.Value.ToString().PadLeft(2, '0')[..2];
+            isCounterPersonYear = locationContainer.PersonKey is not null && IPersonBirthday.IsCounterPersonYear(locationContainer.PersonKey.Value);
+            displayDirectoryName = isCounterPersonYear ? locationContainer.DisplayDirectoryName : GetDisplayDirectoryName(locationContainer.DisplayDirectoryName, locationContainer);
+            (by, _, isBySorting) = Stateless.MapLogic.Get(useFiltersCounter, _Configuration.SaveIndividually, sortingContainersAny, forceSingleImageHumanized, locationContainer.LengthPermyriad, locationContainer.PersonKey, displayDirectoryName);
+            record = Get(_Configuration, by, locationContainer.PersonKey, displayDirectoryName, segmentB);
+            if (string.IsNullOrEmpty(record.Directory) || string.IsNullOrEmpty(record.PersonDirectory))
+                continue;
+            directory = record.Directory;
+            if (!string.IsNullOrEmpty(record.DebugDirectory))
+                results.Add(new(record.DebugDirectory));
+            if (locationContainer.PersonKey is null)
+            {
+                if (!_Configuration.SaveSortingWithoutPerson)
+                    throw new NotSupportedException();
+                if (record.Ticks is null)
+                    continue;
+            }
+            results.Add(new(record.PersonDirectory));
+            facesDirectory = locationContainer.LengthSource.DirectoryName;
+            faceFileHolder = IFileHolder.Get(locationContainer.LengthSource.FullName);
+            checkFile = Path.Combine(directory, $"{locationContainer.LengthSource.Name}");
+            shortcutFile = Path.Combine(record.PersonDirectory, $"{locationContainer.LengthSource.Name}.lnk");
+            resizeContentDirectory = Stateless.MapLogic.GetResizeContentDirectory(_PropertyConfiguration, cContentDirectory, locationContainer.LengthSource);
+            facePartsDirectory = Stateless.MapLogic.GetFacePartsDirectoryX(_PropertyConfiguration, d2FacePartsContentDirectory, locationContainer.LengthSource);
+            hiddenFaceFileHolder = IFileHolder.Get(Path.Combine(facesDirectory, $"{locationContainer.LengthSource.NameWithoutExtension}{_Configuration.FacesHiddenFileNameExtension}"));
+            facePartsFileHolder = IFileHolder.Get(Path.Combine(facePartsDirectory, $"{locationContainer.LengthSource.NameWithoutExtension}{_Configuration.FacePartsFileNameExtension}"));
+            resizedFileHolder = IFileHolder.Get(Path.Combine(resizeContentDirectory, $"{locationContainer.LengthSource.FileNameFirstSegment}{Path.GetExtension(locationContainer.LengthSource.NameWithoutExtension)}"));
+            saveContainer = new(checkFile, directory, faceFileHolder, hiddenFaceFileHolder, facePartsFileHolder, resizedFileHolder, shortcutFile);
+            results.Add(saveContainer);
+            added.Add(locationContainer.LengthSource.Name);
+        }
+        return results;
+    }
+
     public List<SaveContainer> GetSaveContainers(string dFacesContentDirectory, string d2FacePartsContentDirectory, string d2FacePartsContentCollectionDirectory, ReadOnlyDictionary<int, ReadOnlyDictionary<int, Mapping>> idToWholePercentagesToMapping, Shared.Models.Methods.IDistanceLimits distanceLimits, int? useFiltersCounter, ReadOnlyCollection<SortingContainer> sortingContainers)
     {
         if (_Configuration is null)
@@ -810,7 +946,7 @@ public partial class MapLogic : Shared.Models.Methods.IMapLogic
                 throw new NotSupportedException();
             if (question.MappingFromLocation is null)
                 continue;
-            record = Get(_Configuration, _Configuration.SaveIndividually, by, question, padLeft);
+            record = Get(_Configuration, _Configuration.SaveIndividually, padLeft, by, question);
             if (string.IsNullOrEmpty(record.Directory) || string.IsNullOrEmpty(record.PersonDirectory))
                 continue;
             directory = record.Directory;
@@ -1320,10 +1456,13 @@ public partial class MapLogic : Shared.Models.Methods.IMapLogic
         return result;
     }
 
-    public bool InSkipCollection(int id, MappingFromLocation mappingFromLocation) =>
-        _SkipCollection.TryGetValue(id, out List<int>? wholePercentagesCollection) && wholePercentagesCollection.Contains(mappingFromLocation.WholePercentages);
+    public bool InSkipCollection(int id, int wholePercentages) =>
+        _SkipCollection.TryGetValue(id, out List<int>? wholePercentagesCollection) && wholePercentagesCollection.Contains(wholePercentages);
 
-    public bool? IsFocusPerson(int? skipPersonWithMoreThen, long[] jLinkResolvedPersonKeys, ReadOnlyDictionary<int, ReadOnlyCollection<PersonContainer>>? wholePercentagesToPersonContainers, MappingFromLocation mappingFromLocation)
+    public bool InSkipCollection(int id, MappingFromLocation mappingFromLocation) =>
+        InSkipCollection(id, mappingFromLocation.WholePercentages);
+
+    public bool? IsFocusPerson(int? skipPersonWithMoreThen, long[] jLinkResolvedPersonKeys, ReadOnlyDictionary<int, ReadOnlyCollection<PersonContainer>>? wholePercentagesToPersonContainers, int wholePercentages)
     {
         bool? result;
         ReadOnlyCollection<PersonContainer>? personContainers;
@@ -1331,7 +1470,7 @@ public partial class MapLogic : Shared.Models.Methods.IMapLogic
             result = null;
         else if (wholePercentagesToPersonContainers is null)
             result = null;
-        else if (!wholePercentagesToPersonContainers.TryGetValue(mappingFromLocation.WholePercentages, out personContainers))
+        else if (!wholePercentagesToPersonContainers.TryGetValue(wholePercentages, out personContainers))
             result = null;
         else
         {
@@ -1355,6 +1494,9 @@ public partial class MapLogic : Shared.Models.Methods.IMapLogic
         return result;
     }
 
+    public bool? IsFocusPerson(int? skipPersonWithMoreThen, long[] jLinkResolvedPersonKeys, ReadOnlyDictionary<int, ReadOnlyCollection<PersonContainer>>? wholePercentagesToPersonContainers, MappingFromLocation mappingFromLocation) =>
+        IsFocusPerson(skipPersonWithMoreThen, jLinkResolvedPersonKeys, wholePercentagesToPersonContainers, mappingFromLocation.WholePercentages);
+
     public void LookForAbandoned(IDlibDotNet dlibDotNet, Property.Models.Configuration propertyConfiguration, string bResultsFullGroupDirectory, ReadOnlyCollection<Container> readOnlyContainers, string cResultsFullGroupDirectory, string dResultsFullGroupDirectory, string d2ResultsFullGroupDirectory)
     {
         string[] directories;

Map/Models/Stateless/DistanceLogic.cs

@@ -387,7 +387,7 @@ internal abstract class DistanceLogic
                         }
                         personNameDirectories = Directory.GetDirectories(yearDirectory, "*", SearchOption.TopDirectoryOnly);
                         if (personNameDirectories.Length > 1)
-                            throw new NotSupportedException();
+                            throw new NotSupportedException("Try deleting *.lnk files!");
                         foreach (string personNameDirectory in personNameDirectories)
                         {
                             directoryNumber++;

Map/Models/Stateless/FaceFileLogic.cs

@@ -0,0 +1,212 @@
+using ShellProgressBar;
+using System.Collections.ObjectModel;
+using System.Drawing;
+using System.Text.Json;
+using View_by_Distance.Shared.Models;
+using View_by_Distance.Shared.Models.Stateless.Methods;
+using static View_by_Distance.Map.Models.Stateless.MapLogic;
+
+namespace View_by_Distance.Map.Models.Stateless;
+
+internal abstract class FaceFileLogic
+{
+
+    private static void MappedParallelFor(Shared.Models.Properties.IPropertyConfiguration propertyConfiguration, Configuration configuration, ReadOnlyDictionary<int, List<(string, int)>> skipCollection, List<LocationContainer> locationContainers, MappedFile mappedFile)
+    {
+        int? id;
+        string checkFile;
+        DateOnly dateOnly;
+        FilePath filePath;
+        string[] fileMatches;
+        FileHolder fileHolder;
+        int? wholePercentages;
+        const string lnk = ".lnk";
+        ExifDirectory? exifDirectory;
+        string personDisplayDirectoryName;
+        const bool fromDistanceContent = true;
+        List<(string File, int WholePercentages)>? wholePercentagesCollection;
+        if (!mappedFile.FilePath.Name.EndsWith(lnk))
+        {
+            if (mappedFile.FilePath.Id is null)
+                return;
+            id = mappedFile.FilePath.Id;
+            wholePercentages = IMapping.GetWholePercentages(configuration.FacesFileNameExtension, mappedFile.FilePath);
+        }
+        else
+        {
+            fileHolder = IFileHolder.Get(mappedFile.FilePath.FullName[..^4]);
+            filePath = FilePath.Get(propertyConfiguration, fileHolder, index: null);
+            if (filePath.Id is null)
+                return;
+            id = filePath.Id;
+            wholePercentages = IMapping.GetWholePercentages(configuration.FacesFileNameExtension, filePath);
+        }
+        if (wholePercentages is null)
+            return;
+        if (configuration.LinkedAlpha is null && string.IsNullOrEmpty(configuration.LocationContainerDebugDirectory) && skipCollection.TryGetValue(id.Value, out wholePercentagesCollection))
+        {
+            fileMatches = (from l in wholePercentagesCollection where l.WholePercentages == wholePercentages select l.File).ToArray();
+            foreach (string fileMatch in fileMatches)
+            {
+                if (string.IsNullOrEmpty(fileMatch) || !File.Exists(fileMatch))
+                    continue;
+                checkFile = $"{fileMatch}.dup";
+                if (File.Exists(checkFile))
+                    continue;
+                File.Move(fileMatch, checkFile);
+                continue;
+            }
+        }
+        dateOnly = DateOnly.FromDateTime(new DateTime(mappedFile.FilePath.CreationTicks));
+        if (mappedFile.FilePath.Name.EndsWith(lnk) || !File.Exists(mappedFile.FilePath.FullName))
+            exifDirectory = null;
+        else
+            exifDirectory = Metadata.Models.Stateless.Methods.IMetadata.GetExifDirectory(mappedFile.FilePath);
+        RectangleF? rectangle = ILocation.GetPercentagesRectangle(configuration.LocationDigits, wholePercentages.Value);
+        personDisplayDirectoryName = mappedFile.PersonDisplayDirectoryName is null ? configuration.MappingDefaultName : mappedFile.PersonDisplayDirectoryName;
+        lock (locationContainers)
+            locationContainers.Add(new(dateOnly,
+                                       exifDirectory,
+                                       mappedFile.DirectoryNumber,
+                                       personDisplayDirectoryName,
+                                       null,
+                                       null,
+                                       mappedFile.FilePath,
+                                       fromDistanceContent,
+                                       id.Value,
+                                       null,
+                                       null,
+                                       mappedFile.PersonKey,
+                                       rectangle,
+                                       wholePercentages.Value));
+    }
+
+    private static ReadOnlyDictionary<int, ReadOnlyDictionary<int, LocationContainer>> GetReadOnly(Dictionary<int, Dictionary<int, LocationContainer>> keyValuePairs)
+    {
+        Dictionary<int, ReadOnlyDictionary<int, LocationContainer>> results = [];
+        foreach (KeyValuePair<int, Dictionary<int, LocationContainer>> keyValuePair in keyValuePairs)
+            results.Add(keyValuePair.Key, new(keyValuePair.Value));
+        return new(results);
+    }
+
+    internal static ReadOnlyDictionary<int, ReadOnlyDictionary<int, LocationContainer>> GetMapped(int maxDegreeOfParallelism, Property.Models.Configuration propertyConfiguration, Configuration configuration, long ticks, ReadOnlyCollection<PersonContainer> personContainers, string a2PeopleSingletonDirectory, string eDistanceContentDirectory)
+    {
+        Dictionary<int, Dictionary<int, LocationContainer>> results = [];
+        List<LocationContainer> locationContainers = [];
+        Dictionary<int, LocationContainer>? keyValuePairs;
+        Dictionary<int, List<(string, int)>> skipCollection = [];
+        Dictionary<int, List<(string, int)>> skipNotSkipCollection = [];
+        ReadOnlyCollection<string> readOnlyPersonKeyFormattedCollection;
+        ReadOnlyDictionary<string, string> readOnlyPersonKeyFormattedToNewestPersonKeyFormatted;
+        SetSkipCollections(configuration, personContainers, a2PeopleSingletonDirectory, skipCollection, skipNotSkipCollection);
+        {
+            List<string> personKeyFormattedCollection = [];
+            Dictionary<string, string> personKeyFormattedToNewestPersonKeyFormatted = [];
+            SetPersonCollections(configuration, personContainers, personKeyFormattedToNewestPersonKeyFormatted, personKeyFormattedCollection);
+            readOnlyPersonKeyFormattedCollection = new(personKeyFormattedCollection);
+            readOnlyPersonKeyFormattedToNewestPersonKeyFormatted = new(personKeyFormattedToNewestPersonKeyFormatted);
+        }
+        List<Record> records = DistanceLogic.DeleteEmptyDirectoriesAndGetCollection(propertyConfiguration, configuration, ticks, eDistanceContentDirectory, readOnlyPersonKeyFormattedToNewestPersonKeyFormatted, readOnlyPersonKeyFormattedCollection);
+        List<MappedFile> mappedFiles = GetMappedFiles(propertyConfiguration, configuration, personContainers, records);
+        if (mappedFiles.Count > 0)
+        {
+            int totalSeconds = (int)Math.Floor(new TimeSpan(DateTime.Now.Ticks - ticks).TotalSeconds);
+            string message = $") Building Mapped Face Files Collection - {totalSeconds} total second(s)";
+            ParallelOptions parallelOptions = new() { MaxDegreeOfParallelism = maxDegreeOfParallelism };
+            ReadOnlyDictionary<int, List<(string, int)>> readOnlySkipNotSkipCollection = new(skipCollection);
+            ProgressBarOptions options = new() { ProgressCharacter = '─', ProgressBarOnBottom = true, DisableBottomPercentage = true };
+            using ProgressBar progressBar = new(mappedFiles.Count, message, options);
+            _ = Parallel.For(0, mappedFiles.Count, parallelOptions, (i, state) =>
+            {
+                progressBar.Tick();
+                MappedParallelFor(propertyConfiguration, configuration, readOnlySkipNotSkipCollection, locationContainers, mappedFiles[i]);
+            });
+        }
+        foreach (LocationContainer locationContainer in locationContainers)
+        {
+            if (!results.TryGetValue(locationContainer.Id, out keyValuePairs))
+            {
+                results.Add(locationContainer.Id, []);
+                if (!results.TryGetValue(locationContainer.Id, out keyValuePairs))
+                    throw new Exception();
+            }
+            if (keyValuePairs.ContainsKey(locationContainer.WholePercentages))
+                continue;
+            keyValuePairs.Add(locationContainer.WholePercentages, locationContainer);
+        }
+        return GetReadOnly(results);
+    }
+
+    private static void MoveUnableToMatch(FilePath filePath)
+    {
+        string checkFile = $"{filePath.FullName}.unk";
+        if (File.Exists(filePath.FullName) && !File.Exists(checkFile))
+            File.Move(filePath.FullName, checkFile);
+    }
+
+    private static void AvailableParallelFor(Shared.Models.Properties.IPropertyConfiguration propertyConfiguration, Configuration configuration, IFaceD dFace, List<LocationContainer> locationContainers, FilePath filePath)
+    {
+        string? json;
+        const bool fromDistanceContent = false;
+        if (filePath.Id is null)
+            return;
+        DateOnly dateOnly = DateOnly.FromDateTime(new DateTime(filePath.CreationTicks));
+        int? wholePercentages = IMapping.GetWholePercentages(dFace.FileNameExtension, filePath);
+        if (wholePercentages is null)
+        {
+            if (configuration.DistanceMoveUnableToMatch)
+                MoveUnableToMatch(filePath);
+            return;
+        }
+        ExifDirectory exifDirectory = Metadata.Models.Stateless.Methods.IMetadata.GetExifDirectory(filePath);
+        json = Metadata.Models.Stateless.Methods.IMetadata.GetOutputResolution(exifDirectory);
+        if (json is null || !json.Contains(nameof(DateTime)))
+        {
+            if (configuration.DistanceMoveUnableToMatch)
+                MoveUnableToMatch(filePath);
+            return;
+        }
+        FaceFile? faceFile = JsonSerializer.Deserialize(json, FaceFileGenerationContext.Default.FaceFile);
+        if (faceFile is null || faceFile.Location is null)
+        {
+            if (configuration.DistanceMoveUnableToMatch)
+                MoveUnableToMatch(filePath);
+            return;
+        }
+        RectangleF? rectangle = ILocation.GetPercentagesRectangle(configuration.LocationDigits, wholePercentages.Value);
+        if (rectangle is null)
+            return;
+        lock (locationContainers)
+            locationContainers.Add(new(dateOnly,
+                                       exifDirectory,
+                                       null,
+                                       null,
+                                       null,
+                                       faceFile,
+                                       filePath,
+                                       fromDistanceContent,
+                                       filePath.Id.Value,
+                                       null,
+                                       null,
+                                       null,
+                                       rectangle,
+                                       wholePercentages.Value));
+    }
+
+    internal static List<LocationContainer> GetAvailable(int maxDegreeOfParallelism, Property.Models.Configuration propertyConfiguration, Configuration configuration, IFaceD dFace, long ticks, string dFacesContentDirectory, ReadOnlyCollection<FilePath> filePaths)
+    {
+        List<LocationContainer> results = [];
+        int totalSeconds = (int)Math.Floor(new TimeSpan(DateTime.Now.Ticks - ticks).TotalSeconds);
+        ParallelOptions parallelOptions = new() { MaxDegreeOfParallelism = maxDegreeOfParallelism };
+        string message = $") Building Available Face Files Collection - {totalSeconds} total second(s)";
+        ProgressBarOptions options = new() { ProgressCharacter = '─', ProgressBarOnBottom = true, DisableBottomPercentage = true };
+        using ProgressBar progressBar = new(filePaths.Count, message, options);
+        _ = Parallel.For(0, filePaths.Count, parallelOptions, (i, state) =>
+        {
+            progressBar.Tick();
+            AvailableParallelFor(propertyConfiguration, configuration, dFace, results, filePaths[i]);
+        });
+        return results;
+    }
+
+}

Map/Models/Stateless/MapLogic.cs

@@ -438,7 +438,7 @@ internal abstract class MapLogic
         return result;
     }
 
-    private static List<MappedFile> GetMappedFiles(Shared.Models.Properties.IPropertyConfiguration propertyConfiguration, Configuration configuration, ReadOnlyCollection<PersonContainer> personContainers, List<Record> records)
+    internal static List<MappedFile> GetMappedFiles(Shared.Models.Properties.IPropertyConfiguration propertyConfiguration, Configuration configuration, ReadOnlyCollection<PersonContainer> personContainers, List<Record> records)
     {
         List<MappedFile> results = [];
         long personKey;
@@ -540,10 +540,13 @@ internal abstract class MapLogic
                                        exifDirectory,
                                        mappedFile.DirectoryNumber,
                                        personDisplayDirectoryName,
+                                       null,
+                                       null,
                                        mappedFile.FilePath,
                                        fromDistanceContent,
                                        id.Value,
                                        null,
+                                       null,
                                        mappedFile.PersonKey,
                                        rectangle,
                                        wholePercentages.Value));
@@ -561,6 +564,8 @@ internal abstract class MapLogic
         Dictionary<string, (FilePath, int)> distinct = [];
         foreach (LocationContainer locationContainer in locationContainers)
         {
+            if (locationContainer.PersonKey is null)
+                continue;
             key = string.Concat(locationContainer.PersonKey, locationContainer.Id);
             if (distinct.TryGetValue(key, out item))
             {
@@ -576,7 +581,7 @@ internal abstract class MapLogic
                 }
                 delete.Add(item.FilePath);
                 delete.Add(locationContainer.FilePath);
-                duplicates.Add(new(locationContainer.PersonKey, locationContainer.Id, locationContainer.FilePath, percent));
+                duplicates.Add(new(locationContainer.PersonKey.Value, locationContainer.Id, locationContainer.FilePath, percent));
                 continue;
             }
             distinct.Add(key, new(locationContainer.FilePath, locationContainer.WholePercentages));
@@ -990,6 +995,22 @@ internal abstract class MapLogic
         return result;
     }
 
+    internal static string GetFacePartsDirectoryX(Shared.Models.Properties.IPropertyConfiguration propertyConfiguration, string d2FacePartsContentDirectory, FilePath filePath)
+    {
+        string result;
+        (string directoryName, _) = IPath.GetDirectoryNameAndIndex(propertyConfiguration, filePath);
+        result = Path.Combine(d2FacePartsContentDirectory, directoryName, filePath.NameWithoutExtension);
+        return result;
+    }
+
+    internal static string GetResizeContentDirectory(Shared.Models.Properties.IPropertyConfiguration propertyConfiguration, string cContentDirectory, FilePath filePath)
+    {
+        string result;
+        (string directoryName, _) = IPath.GetDirectoryNameAndIndex(propertyConfiguration, filePath);
+        result = Path.Combine(cContentDirectory, directoryName);
+        return result;
+    }
+
     internal static SaveContainer GetDebugSaveContainer(SortingContainer sortingContainer, string directory, Mapping keyMapping)
     {
         SaveContainer result;
@@ -1171,29 +1192,29 @@ internal abstract class MapLogic
         return results;
     }
 
-    internal static (string, bool, bool) Get(int? useFiltersCounter, bool saveIndividually, bool sortingContainersAny, string forceSingleImageHumanized, int? distancePermyriad, Mapping mapping)
+    internal static (string, bool, bool) Get(int? useFiltersCounter, bool saveIndividually, bool sortingContainersAny, string forceSingleImageHumanized, int? distancePermyriad, int? by, string? displayDirectoryName)
     {
-        string by;
+        string byValue;
         bool isByMapping;
         bool isBySorting;
-        if (mapping.By is null)
+        if (by is null)
         {
             isByMapping = false;
             isBySorting = !sortingContainersAny;
-            by = $"{nameof(Shared.Models.Stateless.IMapLogic.Mapping)}Null";
+            byValue = $"{nameof(Shared.Models.Stateless.IMapLogic.Mapping)}Null";
         }
         else
         {
-            isByMapping = mapping.By == Shared.Models.Stateless.IMapLogic.Mapping;
-            isBySorting = mapping.By == Shared.Models.Stateless.IMapLogic.Sorting;
-            bool isDefaultName = mapping.MappingFromPerson is not null && IPerson.IsDefaultName(mapping.MappingFromPerson.DisplayDirectoryName);
-            if (isBySorting && mapping.MappingFromPerson is null)
-                by = saveIndividually ? nameof(Shared.Models.Stateless.IMapLogic.Individually) : $"{nameof(Shared.Models.Stateless.IMapLogic.Sorting)} Without Person{(distancePermyriad < 2000 ? "-A" : "-Z")}";
+            isByMapping = by == Shared.Models.Stateless.IMapLogic.Mapping;
+            isBySorting = by == Shared.Models.Stateless.IMapLogic.Sorting;
+            bool isDefaultName = displayDirectoryName is not null && IPerson.IsDefaultName(displayDirectoryName);
+            if (isBySorting && displayDirectoryName is null)
+                byValue = saveIndividually ? nameof(Shared.Models.Stateless.IMapLogic.Individually) : $"{nameof(Shared.Models.Stateless.IMapLogic.Sorting)} Without Person{(distancePermyriad < 2000 ? "-A" : "-Z")}";
             else if (isBySorting && useFiltersCounter.HasValue)
-                by = $"{nameof(Shared.Models.Stateless.IMapLogic.Sorting)}{(!isDefaultName ? "-A" : "-Z")} Modified Filters - {useFiltersCounter.Value}";
+                byValue = $"{nameof(Shared.Models.Stateless.IMapLogic.Sorting)}{(!isDefaultName ? "-A" : "-Z")} Modified Filters - {useFiltersCounter.Value}";
             else
             {
-                by = $"{mapping.By.Value switch
+                byValue = $"{by.Value switch
                 {
                     Shared.Models.Stateless.IMapLogic.Mapping => nameof(Shared.Models.Stateless.IMapLogic.Mapping),
                     Shared.Models.Stateless.IMapLogic.Sorting => saveIndividually ? nameof(Shared.Models.Stateless.IMapLogic.Individually) : nameof(Shared.Models.Stateless.IMapLogic.Sorting),
@@ -1202,9 +1223,15 @@ internal abstract class MapLogic
                 }}{(!isDefaultName ? "-A" : "-Z")}";
             }
         }
-        return new(by, isByMapping, isBySorting);
+        return new(byValue, isByMapping, isBySorting);
     }
 
+    internal static (string, bool, bool) Get(int? useFiltersCounter, bool saveIndividually, bool sortingContainersAny, string forceSingleImageHumanized, int? distancePermyriad, long? personKey, string? displayDirectoryName) =>
+        Get(useFiltersCounter, saveIndividually, sortingContainersAny, forceSingleImageHumanized, distancePermyriad, personKey is null ? null : Shared.Models.Stateless.IMapLogic.Mapping, displayDirectoryName);
+
+    internal static (string, bool, bool) Get(int? useFiltersCounter, bool saveIndividually, bool sortingContainersAny, string forceSingleImageHumanized, int? distancePermyriad, Mapping mapping) =>
+        Get(useFiltersCounter, saveIndividually, sortingContainersAny, forceSingleImageHumanized, distancePermyriad, mapping.By, mapping.MappingFromPerson?.DisplayDirectoryName);
+
     internal static void CheckCollection(Shared.Models.Properties.IPropertyConfiguration propertyConfiguration, string? rootDirectoryParent)
     {
         string json;
@@ -1272,7 +1299,7 @@ internal abstract class MapLogic
         return new(results);
     }
 
-    internal static bool? CanReMap(long[] jLinkResolvedPersonKeys, ReadOnlyDictionary<int, ReadOnlyCollection<PersonContainer>>? wholePercentagesToPersonContainers, MappingFromLocation mappingFromLocation)
+    internal static bool? CanReMap(long[] jLinkResolvedPersonKeys, ReadOnlyDictionary<int, ReadOnlyCollection<PersonContainer>>? wholePercentagesToPersonContainers, int wholePercentages)
     {
         bool? result;
         ReadOnlyCollection<PersonContainer>? personContainers;
@@ -1280,7 +1307,7 @@ internal abstract class MapLogic
             result = null;
         else
         {
-            if (!wholePercentagesToPersonContainers.TryGetValue(mappingFromLocation.WholePercentages, out personContainers))
+            if (!wholePercentagesToPersonContainers.TryGetValue(wholePercentages, out personContainers))
                 result = null;
             else
             {

Map/Models/Stateless/Methods/IMapLogic.cs

@@ -1,5 +1,6 @@
 using System.Collections.ObjectModel;
 using View_by_Distance.Shared.Models;
+using View_by_Distance.Shared.Models.Stateless.Methods;
 
 namespace View_by_Distance.Map.Models.Stateless.Methods;
 
@@ -49,11 +50,26 @@ public interface IMapLogic
     bool? TestStatic_CanReMap(long[] jLinkResolvedPersonKeys, ReadOnlyDictionary<int, ReadOnlyCollection<PersonContainer>>? wholePercentagesToPersonContainers, MappingFromLocation mappingFromLocation) =>
         CanReMap(jLinkResolvedPersonKeys, wholePercentagesToPersonContainers, mappingFromLocation);
     static bool? CanReMap(long[] jLinkResolvedPersonKeys, ReadOnlyDictionary<int, ReadOnlyCollection<PersonContainer>>? wholePercentagesToPersonContainers, MappingFromLocation mappingFromLocation) =>
-        MapLogic.CanReMap(jLinkResolvedPersonKeys, wholePercentagesToPersonContainers, mappingFromLocation);
+        MapLogic.CanReMap(jLinkResolvedPersonKeys, wholePercentagesToPersonContainers, mappingFromLocation.WholePercentages);
+
+    bool? TestStatic_CanReMap(long[] jLinkResolvedPersonKeys, ReadOnlyDictionary<int, ReadOnlyCollection<PersonContainer>>? wholePercentagesToPersonContainers, int wholePercentages) =>
+        CanReMap(jLinkResolvedPersonKeys, wholePercentagesToPersonContainers, wholePercentages);
+    static bool? CanReMap(long[] jLinkResolvedPersonKeys, ReadOnlyDictionary<int, ReadOnlyCollection<PersonContainer>>? wholePercentagesToPersonContainers, int wholePercentages) =>
+        MapLogic.CanReMap(jLinkResolvedPersonKeys, wholePercentagesToPersonContainers, wholePercentages);
 
     string TestStatic_GetDecade(MappingFromItem mappingFromItem) =>
         GetDecade(mappingFromItem);
     static string GetDecade(MappingFromItem mappingFromItem) =>
         DecadeLogic.GetDecade(mappingFromItem, null);
 
+    ReadOnlyDictionary<int, ReadOnlyDictionary<int, LocationContainer>> TestStatic_GetMappedFiles(int maxDegreeOfParallelism, Property.Models.Configuration propertyConfiguration, Configuration configuration, long ticks, ReadOnlyCollection<PersonContainer> personContainers, string a2PeopleSingletonDirectory, string eDistanceContentDirectory) =>
+        GetMapped(maxDegreeOfParallelism, propertyConfiguration, configuration, ticks, personContainers, a2PeopleSingletonDirectory, eDistanceContentDirectory);
+    static ReadOnlyDictionary<int, ReadOnlyDictionary<int, LocationContainer>> GetMapped(int maxDegreeOfParallelism, Property.Models.Configuration propertyConfiguration, Configuration configuration, long ticks, ReadOnlyCollection<PersonContainer> personContainers, string a2PeopleSingletonDirectory, string eDistanceContentDirectory) =>
+        FaceFileLogic.GetMapped(maxDegreeOfParallelism, propertyConfiguration, configuration, ticks, personContainers, a2PeopleSingletonDirectory, eDistanceContentDirectory);
+
+    List<LocationContainer> TestStatic_GetAvailable(int maxDegreeOfParallelism, Property.Models.Configuration propertyConfiguration, Configuration configuration, IFaceD dFace, long ticks, string dFacesContentDirectory, ReadOnlyCollection<FilePath> filePaths) =>
+        GetAvailable(maxDegreeOfParallelism, propertyConfiguration, configuration, dFace, ticks, dFacesContentDirectory, filePaths);
+    static List<LocationContainer> GetAvailable(int maxDegreeOfParallelism, Property.Models.Configuration propertyConfiguration, Configuration configuration, IFaceD dFace, long ticks, string dFacesContentDirectory, ReadOnlyCollection<FilePath> filePaths) =>
+        FaceFileLogic.GetAvailable(maxDegreeOfParallelism, propertyConfiguration, configuration, dFace, ticks, dFacesContentDirectory, filePaths);
+
 }

Map/Models/Stateless/RelationLogic.cs

@@ -17,14 +17,16 @@ internal abstract class RelationLogic
         Dictionary<long, Dictionary<int, List<LocationContainer>>> personKeyTo = [];
         foreach (LocationContainer locationContainer in locationContainers)
         {
+            if (locationContainer.PersonKey is null)
+                continue;
             if (!locationContainer.FromDistanceContent)
                 continue;
             if (!locationContainer.FilePath.FullName.Contains(configuration.LocationContainerDirectoryPattern))
                 continue;
-            if (!personKeyTo.TryGetValue(locationContainer.PersonKey, out yearTo))
+            if (!personKeyTo.TryGetValue(locationContainer.PersonKey.Value, out yearTo))
             {
-                personKeyTo.Add(locationContainer.PersonKey, []);
-                if (!personKeyTo.TryGetValue(locationContainer.PersonKey, out yearTo))
+                personKeyTo.Add(locationContainer.PersonKey.Value, []);
+                if (!personKeyTo.TryGetValue(locationContainer.PersonKey.Value, out yearTo))
                     throw new Exception();
             }
             if (!yearTo.TryGetValue(locationContainer.CreationDateOnly.Year, out collection))
@@ -45,6 +47,7 @@ internal abstract class RelationLogic
         int lastIndex;
         List<int> years = [];
         List<int> indices = [];
+        LocationContainer locationContainer;
         List<(int Index, int Year)> sort = [];
         List<LocationContainer> collection = [];
         KeyValuePair<int, List<LocationContainer>> keyValue;
@@ -76,7 +79,10 @@ internal abstract class RelationLogic
                     key = $"{years.Min()}-{keyValue.Key}";
                 if (collection.Count == 0)
                     continue;
-                results.Add(new(key, collection[0].PersonKey, new(collection)));
+                locationContainer = collection[0];
+                if (locationContainer.PersonKey is null)
+                    continue;
+                results.Add(new(key, locationContainer.PersonKey.Value, new(collection)));
                 collection = [];
                 years.Clear();
             }