phares3757/view-by-distance-mklink-console
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Force Single Image => Sorting

Browse Source
This commit is contained in:
Mike Phares
2022-10-01 21:19:43 -07:00
parent 3899cf6b4c
commit 9b8e3bdf55
10 changed files with 376 additions and 283 deletions
Download Patch File Download Diff File Expand all files Collapse all files

326
Map/Models/MapLogic.cs
View File

@ -1,6 +1,7 @@
using Humanizer;
using ShellProgressBar;
using System.Text.Json;
using View_by_Distance.Map.Models.Stateless;
using View_by_Distance.Shared.Models;
using View_by_Distance.Shared.Models.Stateless.Methods;
using WindowsShortcutFactory;
@ -112,9 +113,9 @@ public class MapLogic
int result = 0;
const int zero = 0;
string mappingSegmentB;
int by = IMapLogic.Mapping;
PersonBirthday personBirthday;
PersonContainer[]? collection;
int by = Stateless.IMapLogic.Mapping;
List<PersonContainer> personContainers = new();
Dictionary<int, PersonContainer[]>? keyValuePairs;
foreach (Mapping mapping in mappingCollection)
@ -213,14 +214,193 @@ public class MapLogic
}
}
private SaveContainer? GetMatchSaveContainer(string dFacesContentDirectory, string d2FacePartsContentDirectory, string directory, Mapping mapping)
{
if (_Configuration is null)
throw new NullReferenceException(nameof(_Configuration));
SaveContainer? result;
string shortcutFile = string.Empty;
string? directoryName = Path.GetDirectoryName(mapping.MappingFromItem.RelativePath);
string facesDirectory = Path.Combine($"{dFacesContentDirectory}{directoryName}", mapping.MappingFromItem.ImageFileHolder.NameWithoutExtension);
FileHolder faceFileHolder = new(Path.Combine(facesDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}{_Configuration.FacesFileNameExtension}"));
if (directoryName is null || !faceFileHolder.Exists)
result = null;
else
{
string facePartsDirectory = Path.Combine($"{d2FacePartsContentDirectory}{directoryName}", mapping.MappingFromItem.ImageFileHolder.NameWithoutExtension);
string checkFile = Path.Combine(directory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}");
FileHolder hiddenFaceFileHolder = new(Path.Combine(facesDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}{_Configuration.FacesHiddenFileNameExtension}"));
FileHolder facePartsFileHolder = new(Path.Combine(facePartsDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}{_Configuration.FacePartsFileNameExtension}"));
result = new(checkFile, directory, faceFileHolder, hiddenFaceFileHolder, facePartsFileHolder, mapping.MappingFromItem.ResizedFileHolder, shortcutFile);
}
return result;
}
private static (string, bool, bool) Get(int? useFiltersCounter, string forceSingleImageHumanized, Mapping mapping)
{
string by;
bool isByMapping;
bool isBySorting;
if (mapping.By is null)
{
isByMapping = false;
isBySorting = false;
by = $"{nameof(IMapLogic.Mapping)}Null";
}
else
{
isByMapping = mapping.By == IMapLogic.Mapping;
isBySorting = mapping.By == IMapLogic.Sorting;
if (isBySorting && mapping.MappingFromPerson is null)
by = $"{nameof(IMapLogic.Sorting)} Without Person";
else if (isBySorting && useFiltersCounter.HasValue)
by = $"{nameof(IMapLogic.Sorting)} Modified Filters - {useFiltersCounter.Value}";
else
{
by = mapping.By.Value switch
{
IMapLogic.Mapping => nameof(IMapLogic.Mapping),
IMapLogic.Sorting => nameof(IMapLogic.Sorting),
IMapLogic.ForceSingleImage => forceSingleImageHumanized,
_ => throw new NotImplementedException()
};
}
}
return new(by, isByMapping, isBySorting);
}
private string GetDirectory(string by, MappingFromItem mappingFromItem, SortingContainer sortingContainer)
{
if (_Configuration is null)
throw new NullReferenceException(nameof(_Configuration));
string result;
const int zero = 0;
string mappingSegmentB;
string personKeyFormatted;
PersonBirthday personBirthday;
PersonContainer personContainer;
result = Path.Combine(_EDistanceContentTicksDirectory, by, sortingContainer.Sorting.Id.ToString(), sortingContainer.Sorting.NormalizedPixelPercentage.ToString());
for (int i = 0; i < _NotMappedPersonContainers.Count; i++)
{
personContainer = _NotMappedPersonContainers[i];
if (personContainer.Key is null || personContainer.Birthdays is null || !personContainer.Birthdays.Any())
continue;
personBirthday = personContainer.Birthdays[zero];
mappingSegmentB = Stateless.MapLogic.GetMappingSegmentB(_Ticks, personBirthday, personContainer.ApproximateYears, mappingFromItem);
personKeyFormatted = IPersonBirthday.GetFormatted(_Configuration.PersonBirthdayFormat, personBirthday);
result = Path.Combine(_EDistanceContentTicksDirectory, by, personKeyFormatted, mappingSegmentB);
_NotMappedPersonContainers.RemoveAt(i);
break;
}
return result;
}
private List<SaveContainer> GetSaveContainers(string dFacesContentDirectory, string d2FacePartsContentDirectory, Mapping[] mappingCollection, Dictionary<int, Dictionary<int, Mapping>> idToNormalizedPixelPercentageToMapping, int? useFiltersCounter, bool saveMapped)
{
if (_Configuration is null)
throw new NullReferenceException(nameof(_Configuration));
List<SaveContainer> results = new();
string by;
bool isByMapping;
bool isBySorting;
string checkFile;
string directory;
string shortcutFile;
string facesDirectory;
string? directoryName;
string personDirectory;
FileHolder faceFileHolder;
string facePartsDirectory;
string personKeyFormatted;
SaveContainer? saveContainer;
FileHolder facePartsFileHolder;
FileHolder hiddenFaceFileHolder;
Dictionary<int, Mapping>? normalizedPixelPercentageToMapping;
string forceSingleImageHumanized = nameof(IMapLogic.ForceSingleImage).Humanize(LetterCasing.Title);
foreach (Mapping mapping in mappingCollection)
{
directoryName = Path.GetDirectoryName(mapping.MappingFromItem.RelativePath);
if (directoryName is null)
throw new NotSupportedException();
(by, isByMapping, isBySorting) = Get(useFiltersCounter, forceSingleImageHumanized, mapping);
if (isByMapping && !saveMapped)
continue;
if (mapping.MappingFromPerson is null)
{
if (mapping.SortingContainer is null)
continue;
directory = GetDirectory(by, mapping.MappingFromItem, mapping.SortingContainer);
personDirectory = Path.Combine(directory, _Configuration.MappingDefaultName);
}
else
{
if (string.IsNullOrEmpty(mapping.MappingFromPerson.SegmentB))
throw new NotSupportedException();
if (string.IsNullOrEmpty(mapping.MappingFromPerson.DisplayDirectoryName))
throw new NotSupportedException();
personKeyFormatted = IPersonBirthday.GetFormatted(_Configuration.PersonBirthdayFormat, mapping.MappingFromPerson.PersonBirthday);
directory = Path.Combine(_EDistanceContentTicksDirectory, by, personKeyFormatted, mapping.MappingFromPerson.SegmentB);
if (isByMapping)
personDirectory = Path.Combine(directory, mapping.MappingFromPerson.DisplayDirectoryName);
else if (mapping.By is not null)
personDirectory = Path.Combine(directory, mapping.MappingFromPerson.DisplayDirectoryName, "lnk");
else
personDirectory = Path.Combine(directory, mapping.MappingFromPerson.DisplayDirectoryName[..1], "lnk");
}
saveContainer = new(personDirectory);
results.Add(saveContainer);
facesDirectory = Path.Combine($"{dFacesContentDirectory}{directoryName}", mapping.MappingFromItem.ImageFileHolder.NameWithoutExtension);
faceFileHolder = new(Path.Combine(facesDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}{_Configuration.FacesFileNameExtension}"));
if (!faceFileHolder.Exists)
continue;
if (isByMapping)
{
checkFile = Path.Combine(personDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}");
saveContainer = new(checkFile, directory, faceFileHolder);
}
else
{
facePartsDirectory = Path.Combine($"{d2FacePartsContentDirectory}{directoryName}", mapping.MappingFromItem.ImageFileHolder.NameWithoutExtension);
checkFile = Path.Combine(directory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}");
shortcutFile = Path.Combine(personDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}.lnk");
hiddenFaceFileHolder = new(Path.Combine(facesDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}{_Configuration.FacesHiddenFileNameExtension}"));
facePartsFileHolder = new(Path.Combine(facePartsDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}{_Configuration.FacePartsFileNameExtension}"));
saveContainer = new(checkFile, directory, faceFileHolder, hiddenFaceFileHolder, facePartsFileHolder, mapping.MappingFromItem.ResizedFileHolder, shortcutFile);
}
results.Add(saveContainer);
if (!isBySorting || mapping.SortingContainer is null)
continue;
if (!idToNormalizedPixelPercentageToMapping.TryGetValue(mapping.SortingContainer.Sorting.Id, out normalizedPixelPercentageToMapping))
continue;
if (!normalizedPixelPercentageToMapping.ContainsKey(mapping.SortingContainer.Sorting.NormalizedPixelPercentage))
continue;
if (isBySorting && mapping.MappingFromPerson is null)
{
saveContainer = GetMatchSaveContainer(dFacesContentDirectory, d2FacePartsContentDirectory, directory, normalizedPixelPercentageToMapping[mapping.SortingContainer.Sorting.NormalizedPixelPercentage]);
if (saveContainer is not null)
results.Add(saveContainer);
}
saveContainer = Stateless.MapLogic.GetDebugSaveContainer(directory, mapping.SortingContainer, normalizedPixelPercentageToMapping[mapping.SortingContainer.Sorting.NormalizedPixelPercentage]);
results.Add(saveContainer);
}
return results;
}
public void UpdateFromSortingContainersThenSaveContainers(string dFacesContentDirectory, string d2FacePartsContentDirectory, Mapping[] mappingCollection, Dictionary<int, Dictionary<int, Mapping>> idToNormalizedPixelPercentageToMapping, int? useFiltersCounter, SortingContainer[] sortingContainers, int totalNotMapped)
{
int updated = UpdateFromSortingContainers(sortingContainers);
List<SaveContainer> saveContainers = GetSaveContainers(dFacesContentDirectory, d2FacePartsContentDirectory, mappingCollection, idToNormalizedPixelPercentageToMapping, useFiltersCounter, saveMapped: false);
SaveContainers(totalNotMapped, updated, saveContainers);
}
public void SaveMapped(string dFacesContentDirectory, string d2FacePartsContentDirectory, Mapping[] mappingCollection, Dictionary<int, Dictionary<int, Mapping>> idToNormalizedPixelPercentageToMapping, int totalNotMapped)
{
if (_Configuration is null)
throw new NullReferenceException(nameof(_Configuration));
int? updated = null;
int? useFiltersCounter = null;
string mappingDirectory = Path.Combine(_EDistanceContentTicksDirectory, nameof(Stateless.IMapLogic.Mapping));
List<SaveContainer> saveContainers = Stateless.MapLogic.GetSaveContainers(_Configuration, _EDistanceContentTicksDirectory, dFacesContentDirectory, d2FacePartsContentDirectory, mappingCollection, idToNormalizedPixelPercentageToMapping, useFiltersCounter, saveMapped: true);
string mappingDirectory = Path.Combine(_EDistanceContentTicksDirectory, nameof(IMapLogic.Mapping));
List<SaveContainer> saveContainers = GetSaveContainers(dFacesContentDirectory, d2FacePartsContentDirectory, mappingCollection, idToNormalizedPixelPercentageToMapping, useFiltersCounter, saveMapped: true);
SaveContainers(totalNotMapped, updated, saveContainers);
if (!string.IsNullOrEmpty(_EDistanceContentTicksDirectory) && Directory.Exists(mappingDirectory))
Stateless.MapLogic.SaveMappingShortcuts(mappingDirectory);
@ -293,10 +473,14 @@ public class MapLogic
if (faceDistanceLength.Length == 0)
continue;
if (!_IdThenNormalizedPixelPercentageToPersonContainers.TryGetValue(faceDistanceLength.Id, out normalizedPixelPercentageToPersonContainers))
continue;
if (!normalizedPixelPercentageToPersonContainers.ContainsKey(faceDistanceLength.NormalizedPixelPercentage.Value))
continue;
personKeysRangesCollection = GetPersonKeysRangesCollection(normalizedPixelPercentageToPersonContainers[faceDistanceLength.NormalizedPixelPercentage.Value]);
personKeysRangesCollection = new();
else
{
if (!normalizedPixelPercentageToPersonContainers.ContainsKey(faceDistanceLength.NormalizedPixelPercentage.Value))
personKeysRangesCollection = new();
else
personKeysRangesCollection = GetPersonKeysRangesCollection(normalizedPixelPercentageToPersonContainers[faceDistanceLength.NormalizedPixelPercentage.Value]);
}
sorting = ISorting.Get(_Configuration.FaceDistancePermyriad, _Configuration.FaceDistanceTolerance, faceDistanceEncoding, faceDistanceLength, personKeysRangesCollection);
if (sorting.DistancePermyriad == 0)
continue;
@ -311,7 +495,7 @@ public class MapLogic
return results;
}
private int UpdateFromSortingContainers(SortingContainer[] sortingContainers)
public int UpdateFromSortingContainers(SortingContainer[] sortingContainers)
{
if (_Configuration is null)
throw new NullReferenceException(nameof(_Configuration));
@ -321,11 +505,13 @@ public class MapLogic
string mappingSegmentB;
string personKeyFormatted;
PersonBirthday personBirthday;
const int by = IMapLogic.Sorting;
PersonContainer[] personContainers;
const int by = Stateless.IMapLogic.Sorting;
List<int> normalizedPixelPercentageCollection;
List<int> normalizedPixelPercentageCollectionForA;
List<int> normalizedPixelPercentageCollectionForB;
Dictionary<string, int> checkKeyValuePairs = new();
Dictionary<int, List<int>> idToNormalizedPixelPercentageCollection = new();
Dictionary<int, List<int>> idToNormalizedPixelPercentageCollectionForA = new();
Dictionary<int, List<int>> idToNormalizedPixelPercentageCollectionForB = new();
Dictionary<int, PersonContainer[]>? normalizedPixelPercentageToPersonContainers;
int totalSeconds = (int)Math.Floor(new TimeSpan(DateTime.Now.Ticks - _Ticks).TotalSeconds);
string message = $") {sortingContainers.Length:000} Update From Sorting Container(s) - {totalSeconds} total second(s)";
@ -336,94 +522,58 @@ public class MapLogic
progressBar.Tick();
if (sortingContainer.Mapping is null)
throw new NotSupportedException();
if (!idToNormalizedPixelPercentageCollectionForA.ContainsKey(sortingContainer.Mapping.MappingFromItem.Id))
idToNormalizedPixelPercentageCollectionForA.Add(sortingContainer.Mapping.MappingFromItem.Id, new());
normalizedPixelPercentageCollectionForA = idToNormalizedPixelPercentageCollectionForA[sortingContainer.Mapping.MappingFromItem.Id];
if (!idToNormalizedPixelPercentageCollectionForB.ContainsKey(sortingContainer.Mapping.MappingFromItem.Id))
idToNormalizedPixelPercentageCollectionForB.Add(sortingContainer.Mapping.MappingFromItem.Id, new());
normalizedPixelPercentageCollectionForB = idToNormalizedPixelPercentageCollectionForB[sortingContainer.Mapping.MappingFromItem.Id];
if (!_IdThenNormalizedPixelPercentageToPersonContainers.TryGetValue(sortingContainer.Sorting.Id, out normalizedPixelPercentageToPersonContainers))
throw new NotSupportedException();
if (!normalizedPixelPercentageToPersonContainers.ContainsKey(sortingContainer.Sorting.NormalizedPixelPercentage))
throw new NotSupportedException();
if (!idToNormalizedPixelPercentageCollection.ContainsKey(sortingContainer.Mapping.MappingFromItem.Id))
idToNormalizedPixelPercentageCollection.Add(sortingContainer.Mapping.MappingFromItem.Id, new());
normalizedPixelPercentageCollection = idToNormalizedPixelPercentageCollection[sortingContainer.Mapping.MappingFromItem.Id];
if (normalizedPixelPercentageCollection.Contains(sortingContainer.Mapping.MappingFromLocation.NormalizedPixelPercentage))
continue;
personContainers = normalizedPixelPercentageToPersonContainers[sortingContainer.Sorting.NormalizedPixelPercentage];
foreach (PersonContainer personContainer in personContainers)
{
if (personContainer.Key is null || personContainer.Birthdays is null || !personContainer.Birthdays.Any())
personContainers = Array.Empty<PersonContainer>();
if (normalizedPixelPercentageCollectionForA.Contains(sortingContainer.Mapping.MappingFromLocation.NormalizedPixelPercentage))
continue;
personBirthday = personContainer.Birthdays[zero];
personKeyFormatted = IPersonBirthday.GetFormatted(_Configuration.PersonBirthdayFormat, personBirthday);
mappingSegmentB = Stateless.MapLogic.GetMappingSegmentB(_Ticks, personBirthday, personContainer.ApproximateYears, sortingContainer.Mapping.MappingFromItem);
key = string.Concat(personKeyFormatted, '\t', mappingSegmentB);
key = string.Concat(sortingContainer.Mapping.MappingFromItem.Id, '\t', sortingContainer.Mapping.MappingFromLocation.NormalizedPixelPercentage);
if (!checkKeyValuePairs.ContainsKey(key))
checkKeyValuePairs.Add(key, new());
checkKeyValuePairs[key]++;
if (checkKeyValuePairs[key] > _Configuration.SortingMaximumPerKey)
continue;
normalizedPixelPercentageCollection.Add(sortingContainer.Mapping.MappingFromLocation.NormalizedPixelPercentage);
sortingContainer.Mapping.UpdateMappingFromPerson(personContainer.ApproximateYears, by, personContainer.DisplayDirectoryName, personBirthday, mappingSegmentB);
sortingContainer.Mapping.SetSortingContainer(sortingContainer);
sortingContainer.Mapping.UpdateMappingFromUnknownPerson(by, sortingContainer);
normalizedPixelPercentageCollectionForA.Add(sortingContainer.Mapping.MappingFromLocation.NormalizedPixelPercentage);
result += 1;
break;
}
else
{
if (normalizedPixelPercentageCollectionForB.Contains(sortingContainer.Mapping.MappingFromLocation.NormalizedPixelPercentage))
continue;
if (!normalizedPixelPercentageToPersonContainers.ContainsKey(sortingContainer.Sorting.NormalizedPixelPercentage))
personContainers = Array.Empty<PersonContainer>();
else
personContainers = normalizedPixelPercentageToPersonContainers[sortingContainer.Sorting.NormalizedPixelPercentage];
foreach (PersonContainer personContainer in personContainers)
{
if (personContainer.Key is null || personContainer.Birthdays is null || !personContainer.Birthdays.Any())
continue;
personBirthday = personContainer.Birthdays[zero];
personKeyFormatted = IPersonBirthday.GetFormatted(_Configuration.PersonBirthdayFormat, personBirthday);
mappingSegmentB = Stateless.MapLogic.GetMappingSegmentB(_Ticks, personBirthday, personContainer.ApproximateYears, sortingContainer.Mapping.MappingFromItem);
key = string.Concat(personKeyFormatted, '\t', mappingSegmentB);
if (!checkKeyValuePairs.ContainsKey(key))
checkKeyValuePairs.Add(key, new());
checkKeyValuePairs[key]++;
if (checkKeyValuePairs[key] > _Configuration.SortingMaximumPerKey)
continue;
sortingContainer.Mapping.UpdateMappingFromPerson(personContainer.ApproximateYears, by, personContainer.DisplayDirectoryName, personBirthday, mappingSegmentB, sortingContainer);
normalizedPixelPercentageCollectionForB.Add(sortingContainer.Mapping.MappingFromLocation.NormalizedPixelPercentage);
result += 1;
break;
}
}
}
return result;
}
internal void ForceSingleImage(Mapping[] mappingCollection)
{
if (_Configuration is null)
throw new NullReferenceException(nameof(_Configuration));
const int zero = 0;
string mappingSegmentB;
PersonBirthday personBirthday;
List<int>? normalizedPixelPercentages;
int by = Stateless.IMapLogic.ForceSingleImage;
string displayDirectoryName = _Configuration.MappingDefaultName;
Mapping[] mappingCollectionOrderedConfidence = (from l in mappingCollection orderby l.MappingFromLocation.Confidence descending select l).ToArray();
foreach (Mapping mapping in mappingCollectionOrderedConfidence)
{
if (mapping.MappingFromPerson.PersonBirthday is not null)
continue;
if (_SkipCollection.TryGetValue(mapping.MappingFromItem.Id, out normalizedPixelPercentages))
{
if (normalizedPixelPercentages.Contains(mapping.MappingFromLocation.NormalizedPixelPercentage))
continue;
}
foreach (PersonContainer personContainer in _NotMappedPersonContainers)
{
if (personContainer.Key is null || personContainer.Birthdays is null || !personContainer.Birthdays.Any())
continue;
personBirthday = personContainer.Birthdays[zero];
mappingSegmentB = Stateless.MapLogic.GetMappingSegmentB(_Ticks, personBirthday, personContainer.ApproximateYears, mapping.MappingFromItem);
mapping.UpdateMappingFromPerson(personContainer.ApproximateYears, by, personContainer.DisplayDirectoryName, personBirthday, mappingSegmentB);
break;
}
break;
}
}
public void ForceSingleImageThenSaveSorting(string dFacesContentDirectory, string d2FacePartsContentDirectory, Mapping[] mappingCollection, Dictionary<int, Dictionary<int, Mapping>> idToNormalizedPixelPercentageToMapping, SortingContainer[] sortingContainers, int? useFiltersCounter, int totalNotMapped)
{
if (_Configuration is null)
throw new NullReferenceException(nameof(_Configuration));
int updated;
List<SaveContainer> saveContainers;
if (!sortingContainers.Any())
{
updated = 0;
ForceSingleImage(mappingCollection);
saveContainers = Stateless.MapLogic.GetSaveContainers(_Configuration, _EDistanceContentTicksDirectory, dFacesContentDirectory, d2FacePartsContentDirectory, mappingCollection, idToNormalizedPixelPercentageToMapping, useFiltersCounter, saveMapped: false);
}
else
{
updated = UpdateFromSortingContainers(sortingContainers);
if (useFiltersCounter is null && totalNotMapped - updated > 0)
ForceSingleImage(mappingCollection);
saveContainers = Stateless.MapLogic.GetSaveContainers(_Configuration, _EDistanceContentTicksDirectory, dFacesContentDirectory, d2FacePartsContentDirectory, mappingCollection, idToNormalizedPixelPercentageToMapping, useFiltersCounter, saveMapped: false);
}
SaveContainers(totalNotMapped, updated, saveContainers);
}
public void CopyManualFiles(string dFacesContentDirectory, Dictionary<int, Dictionary<int, Mapping>> idToNormalizedPixelPercentageToMapping)
{
if (_Configuration is null)
@ -447,10 +597,10 @@ public class MapLogic
string? personDisplayDirectory;
int? normalizedPixelPercentage;
WindowsShortcut windowsShortcut;
string by = nameof(IMapLogic.ManualCopy);
Dictionary<int, PersonContainer[]>? keyValuePairs;
string by = nameof(Stateless.IMapLogic.ManualCopy);
Dictionary<int, Mapping>? normalizedPixelPercentageToMapping;
string successfull = $"_ {nameof(Stateless.IMapLogic.ManualCopy).Humanize(LetterCasing.Title)} Successfull";
string successfull = $"_ {nameof(IMapLogic.ManualCopy).Humanize(LetterCasing.Title)} Successfull";
foreach (KeyValuePair<long, PersonContainer> keyValuePair in _PersonKeyToPersonContainer)
{
if (keyValuePair.Value.Key is null || keyValuePair.Value.Birthdays is null || !keyValuePair.Value.Birthdays.Any())
@ -529,7 +679,7 @@ public class MapLogic
SaveContainer saveContainer;
PersonBirthday personBirthday;
List<SaveContainer> saveContainers = new();
const string facePopulatedKey = nameof(Stateless.IMapLogic.Sorting);
const string facePopulatedKey = nameof(IMapLogic.Sorting);
foreach (PersonContainer personContainer in _NotMappedPersonContainers)
{
if (personContainer.Key is null || personContainer.Birthdays is null || !personContainer.Birthdays.Any())

97
Map/Models/Stateless/MapLogic.cs
View File

@ -654,111 +654,18 @@ internal abstract class MapLogic
return result;
}
private static SaveContainer GetSaveContainer(string directory, SortingContainer sortingContainer, Mapping mapping)
internal static SaveContainer GetDebugSaveContainer(string directory, SortingContainer sortingContainer, Mapping mapping)
{
SaveContainer result;
string checkFile = string.Empty;
FileHolder? faceFileHolder = null;
FileHolder? facePartsFileHolder = null;
FileHolder? hiddenFaceFileHolder = null;
string shortcutFile = Path.Combine(directory, $"{sortingContainer.Mapping.MappingFromLocation.DeterministicHashCodeKey}{sortingContainer.Mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}.lnk");
string shortcutFile = Path.Combine(directory, $"{sortingContainer.Mapping.MappingFromLocation.DeterministicHashCodeKey}{sortingContainer.Mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}.debug.lnk");
result = new(checkFile, directory, faceFileHolder, hiddenFaceFileHolder, facePartsFileHolder, mapping.MappingFromItem.ResizedFileHolder, shortcutFile);
return result;
}
internal static List<SaveContainer> GetSaveContainers(Configuration configuration, string eDistanceContentTicksDirectory, string dFacesContentDirectory, string d2FacePartsContentDirectory, Mapping[] mappingCollection, Dictionary<int, Dictionary<int, Mapping>> idToNormalizedPixelPercentageToMapping, int? useFiltersCounter, bool saveMapped)
{
List<SaveContainer> results = new();
string by;
string checkFile;
bool isByMapping;
bool isBySorting;
string directory;
string shortcutFile;
string facesDirectory;
string? directoryName;
string personDirectory;
FileHolder faceFileHolder;
string facePartsDirectory;
string personKeyFormatted;
SaveContainer saveContainer;
FileHolder facePartsFileHolder;
FileHolder hiddenFaceFileHolder;
Dictionary<int, Mapping>? normalizedPixelPercentageToMapping;
string forceSingleImageHumanized = nameof(IMapLogic.ForceSingleImage).Humanize(LetterCasing.Title);
foreach (Mapping mapping in mappingCollection)
{
directoryName = Path.GetDirectoryName(mapping.MappingFromItem.RelativePath);
if (directoryName is null)
throw new NotSupportedException();
if (mapping.MappingFromPerson.PersonBirthday is null)
continue;
if (string.IsNullOrEmpty(mapping.MappingFromPerson.SegmentB))
throw new NotSupportedException();
if (mapping.MappingFromPerson.By is null)
{
isByMapping = false;
isBySorting = false;
by = $"{nameof(IMapLogic.Mapping)}Null";
}
else
{
isByMapping = mapping.MappingFromPerson.By == IMapLogic.Mapping;
isBySorting = mapping.MappingFromPerson.By == IMapLogic.Sorting;
if (isByMapping && !saveMapped)
continue;
if (isBySorting && useFiltersCounter.HasValue)
by = $"{nameof(IMapLogic.Sorting)} Modified Filters - {useFiltersCounter.Value}";
else
{
by = mapping.MappingFromPerson.By.Value switch
{
IMapLogic.Mapping => nameof(IMapLogic.Mapping),
IMapLogic.Sorting => nameof(IMapLogic.Sorting),
IMapLogic.ForceSingleImage => forceSingleImageHumanized,
_ => throw new NotImplementedException()
};
}
}
personKeyFormatted = IPersonBirthday.GetFormatted(configuration.PersonBirthdayFormat, mapping.MappingFromPerson.PersonBirthday);
directory = Path.Combine(eDistanceContentTicksDirectory, by, personKeyFormatted, mapping.MappingFromPerson.SegmentB);
if (isByMapping)
personDirectory = Path.Combine(directory, mapping.MappingFromPerson.DisplayDirectoryName);
else if (mapping.MappingFromPerson.By is not null)
personDirectory = Path.Combine(directory, mapping.MappingFromPerson.DisplayDirectoryName, "lnk");
else
personDirectory = Path.Combine(directory, mapping.MappingFromPerson.DisplayDirectoryName[..1], "lnk");
saveContainer = new(personDirectory);
results.Add(saveContainer);
facesDirectory = Path.Combine($"{dFacesContentDirectory}{directoryName}", mapping.MappingFromItem.ImageFileHolder.NameWithoutExtension);
faceFileHolder = new(Path.Combine(facesDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}{configuration.FacesFileNameExtension}"));
if (isByMapping)
{
checkFile = Path.Combine(personDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}");
saveContainer = new(checkFile, directory, faceFileHolder);
}
else
{
facePartsDirectory = Path.Combine($"{d2FacePartsContentDirectory}{directoryName}", mapping.MappingFromItem.ImageFileHolder.NameWithoutExtension);
checkFile = Path.Combine(directory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}");
shortcutFile = Path.Combine(personDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}.lnk");
hiddenFaceFileHolder = new(Path.Combine(facesDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}{configuration.FacesHiddenFileNameExtension}"));
facePartsFileHolder = new(Path.Combine(facePartsDirectory, $"{mapping.MappingFromLocation.DeterministicHashCodeKey}{mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}{configuration.FacePartsFileNameExtension}"));
saveContainer = new(checkFile, directory, faceFileHolder, hiddenFaceFileHolder, facePartsFileHolder, mapping.MappingFromItem.ResizedFileHolder, shortcutFile);
}
results.Add(saveContainer);
if (!isBySorting || mapping.SortingContainer is null)
continue;
if (!idToNormalizedPixelPercentageToMapping.TryGetValue(mapping.SortingContainer.Sorting.Id, out normalizedPixelPercentageToMapping))
continue;
if (!normalizedPixelPercentageToMapping.ContainsKey(mapping.SortingContainer.Sorting.NormalizedPixelPercentage))
continue;
saveContainer = GetSaveContainer(directory, mapping.SortingContainer, normalizedPixelPercentageToMapping[mapping.SortingContainer.Sorting.NormalizedPixelPercentage]);
results.Add(saveContainer);
}
return results;
}
private static IEnumerable<(string, string)> GetCollection(string[] yearDirectories)
{
foreach (string l in yearDirectories)