788 lines
43 KiB
C#
788 lines
43 KiB
C#
using Humanizer;
|
|
using ShellProgressBar;
|
|
using System.Text.Json;
|
|
using View_by_Distance.Shared.Models;
|
|
using View_by_Distance.Shared.Models.Stateless.Methods;
|
|
using WindowsShortcutFactory;
|
|
|
|
namespace View_by_Distance.Map.Models;
|
|
|
|
public class MapLogic
|
|
{
|
|
|
|
protected readonly Dictionary<int, List<int>> _SkipCollection;
|
|
protected readonly List<PersonContainer> _NotMappedPersonContainers;
|
|
protected readonly Dictionary<long, PersonContainer> _PersonKeyToPersonContainer;
|
|
protected readonly Dictionary<long, (long LCL, long Minimum, long Maximum, long UCL)> _PersonKeyToRanges;
|
|
protected readonly Dictionary<int, Dictionary<int, PersonContainer[]>> _IdThenNormalizedPixelPercentageToPersonContainers;
|
|
|
|
public Dictionary<int, int[]> KeyValuePairs => throw new NotImplementedException();
|
|
public Dictionary<int, int[]> IndicesFromNew => throw new NotImplementedException();
|
|
|
|
private readonly long _Ticks;
|
|
private readonly Serilog.ILogger? _Log;
|
|
private readonly int _MaxDegreeOfParallelism;
|
|
private readonly Configuration? _Configuration;
|
|
private readonly string _FacesFileNameExtension;
|
|
private readonly string _FacePartsFileNameExtension;
|
|
private readonly string _FacesHiddenFileNameExtension;
|
|
private readonly string _EDistanceContentTicksDirectory;
|
|
|
|
public MapLogic(int maxDegreeOfParallelism, Shared.Models.Properties.IPropertyConfiguration propertyConfiguration, Configuration? configuration, string facesFileNameExtension, string facesHiddenFileNameExtension, string facePartsFileNameExtension, long ticks, PersonContainer[] personContainers, string a2PeopleSingletonDirectory, string eDistanceContentDirectory, List<Face> distinctFilteredFaces, Shared.Models.Methods.IFaceDistance? faceDistance)
|
|
{
|
|
_Ticks = ticks;
|
|
_Configuration = configuration;
|
|
_Log = Serilog.Log.ForContext<MapLogic>();
|
|
_FacesFileNameExtension = facesFileNameExtension;
|
|
_MaxDegreeOfParallelism = maxDegreeOfParallelism;
|
|
_FacePartsFileNameExtension = facePartsFileNameExtension;
|
|
_FacesHiddenFileNameExtension = facesHiddenFileNameExtension;
|
|
if (_Log is null)
|
|
{ }
|
|
if (propertyConfiguration.VerifyToSeason is null || !propertyConfiguration.VerifyToSeason.Any())
|
|
throw new Exception();
|
|
if (_MaxDegreeOfParallelism == 0)
|
|
{ }
|
|
string json;
|
|
string fullPath;
|
|
List<KeyValuePair<int, int[]>>? collection;
|
|
Dictionary<int, List<int>> skipCollection = new();
|
|
List<PersonContainer> notMappedPersonContainers = new();
|
|
Dictionary<long, PersonContainer> personKeyToPersonContainer = new();
|
|
string? rootDirectoryParent = Path.GetDirectoryName(propertyConfiguration.RootDirectory);
|
|
Dictionary<long, (long LCL, long Minimum, long Maximum, long UCL)> personKeyToRanges = new();
|
|
string eDistanceContentTicksDirectory = Path.Combine(eDistanceContentDirectory, $"({ticks})");
|
|
Dictionary<int, Dictionary<int, PersonContainer[]>> idThenNormalizedPixelPercentageToPersonContainers = new();
|
|
for (int i = 1; i < 5; i++)
|
|
_ = IPath.DeleteEmptyDirectories(eDistanceContentDirectory);
|
|
_ = IPath.DeleteEmptyDirectories(eDistanceContentDirectory);
|
|
if (string.IsNullOrEmpty(rootDirectoryParent))
|
|
throw new NullReferenceException(nameof(rootDirectoryParent));
|
|
if (!Directory.Exists(eDistanceContentDirectory))
|
|
_ = Directory.CreateDirectory(eDistanceContentDirectory);
|
|
if (!Directory.Exists(eDistanceContentTicksDirectory))
|
|
_ = Directory.CreateDirectory(eDistanceContentTicksDirectory);
|
|
if (configuration is not null && faceDistance is not null)
|
|
{
|
|
List<PersonContainer> personContainerCollection = new(personContainers);
|
|
Stateless.MapLogic.Set(propertyConfiguration,
|
|
configuration,
|
|
facesFileNameExtension,
|
|
ticks,
|
|
personContainerCollection,
|
|
a2PeopleSingletonDirectory,
|
|
eDistanceContentDirectory,
|
|
distinctFilteredFaces,
|
|
faceDistance,
|
|
personKeyToPersonContainer,
|
|
personKeyToRanges,
|
|
notMappedPersonContainers,
|
|
skipCollection,
|
|
idThenNormalizedPixelPercentageToPersonContainers);
|
|
if (personContainerCollection.Count == personContainers.Length)
|
|
throw new NotSupportedException();
|
|
}
|
|
foreach (string propertyContentCollectionFile in propertyConfiguration.PropertyContentCollectionFiles)
|
|
{
|
|
fullPath = Path.GetFullPath(string.Concat(rootDirectoryParent, propertyContentCollectionFile));
|
|
if (fullPath.Contains(propertyConfiguration.RootDirectory))
|
|
continue;
|
|
if (!File.Exists(fullPath))
|
|
continue;
|
|
json = File.ReadAllText(fullPath);
|
|
collection = JsonSerializer.Deserialize<List<KeyValuePair<int, int[]>>>(json);
|
|
if (collection is null)
|
|
throw new NullReferenceException(nameof(collection));
|
|
}
|
|
_SkipCollection = skipCollection;
|
|
_PersonKeyToRanges = personKeyToRanges;
|
|
_NotMappedPersonContainers = notMappedPersonContainers;
|
|
_PersonKeyToPersonContainer = personKeyToPersonContainer;
|
|
_EDistanceContentTicksDirectory = eDistanceContentTicksDirectory;
|
|
_IdThenNormalizedPixelPercentageToPersonContainers = idThenNormalizedPixelPercentageToPersonContainers;
|
|
}
|
|
|
|
public MapLogic(int maxDegreeOfParallelism, Shared.Models.Properties.IPropertyConfiguration propertyConfiguration, Configuration? configuration, string outputExtension, long ticks, PersonContainer[] personContainers, string a2PeopleSingletonDirectory, string eDistanceContentDirectory) :
|
|
this(maxDegreeOfParallelism, propertyConfiguration, configuration, outputExtension, outputExtension, outputExtension, ticks, personContainers, a2PeopleSingletonDirectory, eDistanceContentDirectory, new(), null)
|
|
{ }
|
|
|
|
public override string ToString()
|
|
{
|
|
string result = JsonSerializer.Serialize(this, new JsonSerializerOptions() { WriteIndented = true });
|
|
return result;
|
|
}
|
|
|
|
private List<(long, long, long, long)> GetPersonKeysRangesCollection(PersonContainer[] personContainers)
|
|
{
|
|
List<(long, long, long, long)> results = new();
|
|
(long, long, long, long) singleton;
|
|
foreach (PersonContainer personContainer in personContainers)
|
|
{
|
|
if (personContainer.Key is null)
|
|
continue;
|
|
if (!_PersonKeyToRanges.TryGetValue(personContainer.Key.Value, out singleton))
|
|
continue;
|
|
results.Add(singleton);
|
|
}
|
|
return results;
|
|
}
|
|
|
|
public List<Sorting> GetSortingCollection(int i, FaceDistance faceDistanceEncoding, List<FaceDistance> faceDistanceLengths, bool anyLowerThanTolerance)
|
|
{
|
|
if (_Configuration is null)
|
|
throw new NullReferenceException(nameof(_Configuration));
|
|
List<Sorting> results = new();
|
|
Sorting sorting;
|
|
FaceDistance faceDistanceLength;
|
|
List<int>? normalizedPixelPercentages;
|
|
Dictionary<int, PersonContainer[]>? keyValuePairs;
|
|
List<(long lcl, long minimum, long maximum, long ucl)> personKeysRangesCollection;
|
|
for (int j = 0; j < faceDistanceLengths.Count; j++)
|
|
{
|
|
if (j == i)
|
|
continue;
|
|
faceDistanceLength = faceDistanceLengths[j];
|
|
if (faceDistanceEncoding.NormalizedPixelPercentage is null || faceDistanceLength.NormalizedPixelPercentage is null || faceDistanceLength.Length is null)
|
|
throw new NotSupportedException();
|
|
if (faceDistanceLength.Length == 0)
|
|
continue;
|
|
if (_SkipCollection.TryGetValue(faceDistanceEncoding.Id, out normalizedPixelPercentages))
|
|
{
|
|
if (normalizedPixelPercentages.Contains(faceDistanceEncoding.NormalizedPixelPercentage.Value))
|
|
continue;
|
|
}
|
|
if (_IdThenNormalizedPixelPercentageToPersonContainers.TryGetValue(faceDistanceEncoding.Id, out keyValuePairs))
|
|
{
|
|
if (keyValuePairs.ContainsKey(faceDistanceEncoding.NormalizedPixelPercentage.Value))
|
|
continue;
|
|
}
|
|
if (!_IdThenNormalizedPixelPercentageToPersonContainers.TryGetValue(faceDistanceLength.Id, out keyValuePairs))
|
|
continue;
|
|
if (!keyValuePairs.ContainsKey(faceDistanceLength.NormalizedPixelPercentage.Value))
|
|
continue;
|
|
personKeysRangesCollection = GetPersonKeysRangesCollection(keyValuePairs[faceDistanceLength.NormalizedPixelPercentage.Value]);
|
|
sorting = ISorting.Get(_Configuration.FaceDistancePermyriad, _Configuration.FaceDistanceTolerance, faceDistanceEncoding, faceDistanceLength, anyLowerThanTolerance, personKeysRangesCollection);
|
|
if (sorting.DistancePermyriad == 0)
|
|
continue;
|
|
if (sorting.Id == faceDistanceEncoding.Id)
|
|
{
|
|
if (sorting.NormalizedPixelPercentage == faceDistanceEncoding.NormalizedPixelPercentage.Value)
|
|
throw new NotSupportedException();
|
|
continue;
|
|
}
|
|
results.Add(sorting);
|
|
}
|
|
return results;
|
|
}
|
|
|
|
public void SaveShortcuts(string[] juliePhares, List<Face> distinctFilteredFaces)
|
|
{
|
|
if (_Configuration is null)
|
|
throw new NullReferenceException(nameof(_Configuration));
|
|
string fileName;
|
|
string fullName;
|
|
string personKeyFormatted;
|
|
PersonBirthday personBirthday;
|
|
WindowsShortcut windowsShortcut;
|
|
PersonContainer? personContainer;
|
|
List<(Face, long?, (string, string, string, string))> collection = GetCollection(distinctFilteredFaces);
|
|
foreach ((Face face, long? personKey, (string directory, string copyDirectory, string copyFileName, string shortcutFileName)) in collection)
|
|
{
|
|
if (personKey is null)
|
|
continue;
|
|
if (face.Mapping is null)
|
|
throw new NotSupportedException();
|
|
personBirthday = IPersonBirthday.GetPersonBirthday(personKey.Value);
|
|
personKeyFormatted = IPersonBirthday.GetFormatted(_Configuration.PersonBirthdayFormat, personBirthday);
|
|
if (juliePhares.Contains(personKeyFormatted) && !string.IsNullOrEmpty(copyDirectory))
|
|
{
|
|
if (!Directory.Exists(copyDirectory))
|
|
_ = Directory.CreateDirectory(copyDirectory);
|
|
fileName = Path.Combine(copyDirectory, $"{face.Mapping.MappingFromItem.Id}{face.Mapping.MappingFromItem.ResizedFileHolder.ExtensionLowered}");
|
|
if (!File.Exists(fileName))
|
|
File.Copy(face.Mapping.MappingFromItem.ResizedFileHolder.FullName, fileName);
|
|
}
|
|
if (!Directory.Exists(directory))
|
|
{
|
|
_ = Directory.CreateDirectory(directory);
|
|
if (personKey is not null && _PersonKeyToPersonContainer.TryGetValue(personKey.Value, out personContainer))
|
|
{
|
|
fullName = string.Concat(personContainer.DisplayDirectoryName, ".txt");
|
|
File.WriteAllText(Path.Combine(directory, fullName), string.Empty);
|
|
}
|
|
}
|
|
fileName = Path.Combine(directory, $"{face.Mapping.MappingFromItem.Id}.lnk");
|
|
if (File.Exists(fileName))
|
|
continue;
|
|
windowsShortcut = new() { Path = face.Mapping.MappingFromItem.ResizedFileHolder.FullName };
|
|
windowsShortcut.Save(fileName);
|
|
windowsShortcut.Dispose();
|
|
if (!File.Exists(fileName))
|
|
continue;
|
|
File.SetLastWriteTime(fileName, face.Mapping.MappingFromItem.MinimumDateTime);
|
|
}
|
|
}
|
|
|
|
private static string GetMappingSegmentB(long ticks, PersonBirthday personBirthday, int? approximateYears, long minimumDateTimeTicks, bool? isWrongYear)
|
|
{
|
|
int years;
|
|
string result;
|
|
TimeSpan? timeSpan = IPersonBirthday.GetTimeSpan(minimumDateTimeTicks, isWrongYear, personBirthday);
|
|
if (timeSpan.HasValue && timeSpan.Value.Ticks < 0)
|
|
result = "!---";
|
|
else if (timeSpan.HasValue)
|
|
{
|
|
(years, _) = IPersonBirthday.GetAge(minimumDateTimeTicks, personBirthday);
|
|
result = $"^{years:000}";
|
|
}
|
|
else if (approximateYears.HasValue)
|
|
{
|
|
DateTime dateTime = new(ticks);
|
|
(years, _) = IAge.GetAge(minimumDateTimeTicks, dateTime.AddYears(-approximateYears.Value));
|
|
result = $"~{years:000}";
|
|
}
|
|
else
|
|
{
|
|
string isWrongYearFlag = IItem.GetWrongYearFlag(isWrongYear);
|
|
result = $"{isWrongYearFlag}{new DateTime(minimumDateTimeTicks):yyyy}";
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private static string GetMappingSegmentB(long ticks, PersonBirthday personBirthday, int? approximateYears, DateTime minimumDateTime, bool? isWrongYear)
|
|
{
|
|
string result = GetMappingSegmentB(ticks, personBirthday, approximateYears, minimumDateTime.Ticks, isWrongYear);
|
|
return result;
|
|
}
|
|
|
|
private static string GetMappingSegmentB(long ticks, PersonBirthday personBirthday, int? approximateYears, MappingFromItem mappingFromItem)
|
|
{
|
|
string result = GetMappingSegmentB(ticks, personBirthday, approximateYears, mappingFromItem.MinimumDateTime, mappingFromItem.IsWrongYear);
|
|
return result;
|
|
}
|
|
|
|
public int AddToMapping(List<Face> distinctFilteredFaces)
|
|
{
|
|
if (_Configuration is null)
|
|
throw new NullReferenceException(nameof(_Configuration));
|
|
int result = 0;
|
|
const int zero = 0;
|
|
string mappingSegmentB;
|
|
PersonBirthday personBirthday;
|
|
PersonContainer[]? collection;
|
|
int by = Stateless.IMapLogic.Mapping;
|
|
List<PersonContainer> personContainers = new();
|
|
Dictionary<int, PersonContainer[]>? keyValuePairs;
|
|
foreach (Face face in distinctFilteredFaces)
|
|
{
|
|
personContainers.Clear();
|
|
if (face.Mapping is null)
|
|
throw new NotSupportedException();
|
|
if (!_IdThenNormalizedPixelPercentageToPersonContainers.TryGetValue(face.Mapping.MappingFromItem.Id, out keyValuePairs))
|
|
result += 1;
|
|
else
|
|
{
|
|
if (!keyValuePairs.TryGetValue(face.Mapping.MappingFromLocation.NormalizedPixelPercentage, out collection))
|
|
result += 1;
|
|
else
|
|
personContainers.AddRange(collection);
|
|
}
|
|
foreach (PersonContainer personContainer in personContainers)
|
|
{
|
|
if (personContainer.Key is null || personContainer.Birthdays is null || !personContainer.Birthdays.Any())
|
|
continue;
|
|
personBirthday = personContainer.Birthdays[zero];
|
|
mappingSegmentB = GetMappingSegmentB(_Ticks, personBirthday, personContainer.ApproximateYears, face.Mapping.MappingFromItem);
|
|
face.Mapping.UpdateMappingFromPerson(personContainer.ApproximateYears, by, personContainer.DisplayDirectoryName, personBirthday, mappingSegmentB);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private void SaveContainers(List<SaveContainer> saveContainers)
|
|
{
|
|
string checkFile;
|
|
string sourceFile;
|
|
WindowsShortcut windowsShortcut;
|
|
string[] directories = (from l in saveContainers select l.Directory).Distinct().ToArray();
|
|
int totalSeconds = (int)Math.Floor(new TimeSpan(DateTime.Now.Ticks - _Ticks).TotalSeconds);
|
|
string message = $") {saveContainers.Count:000} save(s) - {totalSeconds} total second(s)";
|
|
ProgressBarOptions options = new() { ProgressCharacter = '─', ProgressBarOnBottom = true, DisableBottomPercentage = true };
|
|
foreach (string directory in directories)
|
|
{
|
|
if (string.IsNullOrEmpty(directory))
|
|
continue;
|
|
if (!Directory.Exists(directory))
|
|
_ = Directory.CreateDirectory(directory);
|
|
}
|
|
using ProgressBar progressBar = new(saveContainers.Count, message, options);
|
|
foreach (SaveContainer saveContainer in saveContainers)
|
|
{
|
|
progressBar.Tick();
|
|
if (string.IsNullOrEmpty(saveContainer.Directory) || string.IsNullOrEmpty(saveContainer.CheckFile) || saveContainer.ResizedFileHolder is null || saveContainer.FaceFileHolder is null || !string.IsNullOrEmpty(saveContainer.Json))
|
|
continue;
|
|
if (!saveContainer.FaceFileHolder.Exists && saveContainer.ResizedFileHolder.Exists)
|
|
{
|
|
checkFile = saveContainer.CheckFile;
|
|
sourceFile = saveContainer.ResizedFileHolder.FullName;
|
|
}
|
|
else if (saveContainer.FaceFileHolder.Exists)
|
|
{
|
|
sourceFile = saveContainer.FaceFileHolder.FullName;
|
|
checkFile = $"{saveContainer.CheckFile}{_FacesFileNameExtension}";
|
|
}
|
|
else
|
|
continue;
|
|
if (File.Exists(checkFile))
|
|
continue;
|
|
File.Copy(sourceFile, checkFile);
|
|
if (saveContainer.HiddenFaceFileHolder is not null && saveContainer.HiddenFaceFileHolder.Exists)
|
|
{
|
|
sourceFile = saveContainer.HiddenFaceFileHolder.FullName;
|
|
checkFile = $"{saveContainer.CheckFile}{_FacesHiddenFileNameExtension}";
|
|
}
|
|
else if (saveContainer.FacePartsFileHolder is not null && saveContainer.FacePartsFileHolder.Exists)
|
|
{
|
|
sourceFile = saveContainer.FacePartsFileHolder.FullName;
|
|
checkFile = $"{saveContainer.CheckFile}{_FacePartsFileNameExtension}";
|
|
}
|
|
if (File.Exists(checkFile))
|
|
continue;
|
|
File.Copy(sourceFile, checkFile);
|
|
}
|
|
foreach (SaveContainer saveContainer in saveContainers)
|
|
{
|
|
if (string.IsNullOrEmpty(saveContainer.Directory) || string.IsNullOrEmpty(saveContainer.CheckFile) || saveContainer.ResizedFileHolder is not null || saveContainer.FaceFileHolder is not null || string.IsNullOrEmpty(saveContainer.Json))
|
|
continue;
|
|
if (File.Exists(saveContainer.CheckFile))
|
|
continue;
|
|
_ = IPath.WriteAllText(saveContainer.CheckFile, saveContainer.Json, updateDateWhenMatches: false, compareBeforeWrite: true, updateToWhenMatches: null);
|
|
}
|
|
foreach (SaveContainer saveContainer in saveContainers)
|
|
{
|
|
if (string.IsNullOrEmpty(saveContainer.Directory) || string.IsNullOrEmpty(saveContainer.CheckFile) || saveContainer.ResizedFileHolder is null)
|
|
continue;
|
|
if (string.IsNullOrEmpty(saveContainer.ShortcutFile) || !saveContainer.ResizedFileHolder.Exists)
|
|
continue;
|
|
try
|
|
{
|
|
windowsShortcut = new() { Path = saveContainer.ResizedFileHolder.FullName };
|
|
windowsShortcut.Save(saveContainer.ShortcutFile);
|
|
windowsShortcut.Dispose();
|
|
}
|
|
catch (Exception)
|
|
{ }
|
|
}
|
|
}
|
|
|
|
public void SaveNotMappedTicks()
|
|
{
|
|
if (_Configuration is null)
|
|
throw new NullReferenceException(nameof(_Configuration));
|
|
string directory;
|
|
const int zero = 0;
|
|
string personKeyFormatted;
|
|
SaveContainer saveContainer;
|
|
PersonBirthday personBirthday;
|
|
List<SaveContainer> saveContainers = new();
|
|
const string facePopulatedKey = nameof(Stateless.IMapLogic.Sorting);
|
|
foreach (PersonContainer personContainer in _NotMappedPersonContainers)
|
|
{
|
|
if (personContainer.Key is null || personContainer.Birthdays is null || !personContainer.Birthdays.Any())
|
|
continue;
|
|
personBirthday = personContainer.Birthdays[zero];
|
|
personKeyFormatted = IPersonBirthday.GetFormatted(_Configuration.PersonBirthdayFormat, personBirthday);
|
|
directory = Path.Combine(_EDistanceContentTicksDirectory, $"{facePopulatedKey}NotMapped", personKeyFormatted, _Configuration.MappingDefaultName);
|
|
saveContainer = new(directory);
|
|
saveContainers.Add(saveContainer);
|
|
}
|
|
SaveContainers(saveContainers);
|
|
}
|
|
|
|
public List<(Face, long?, (string, string, string, string))> GetCollection(List<Face> distinctFilteredFaces)
|
|
{
|
|
if (_Configuration is null)
|
|
throw new NullReferenceException(nameof(_Configuration));
|
|
List<(Face, long?, (string, string, string, string))> results = new();
|
|
int years;
|
|
long? personKey;
|
|
string directory;
|
|
const int zero = 0;
|
|
TimeSpan? timeSpan;
|
|
string copyFileName;
|
|
string copyDirectory;
|
|
string? relativePath;
|
|
string isWrongYearFlag;
|
|
string shortcutFileName;
|
|
string subDirectoryName;
|
|
string personKeyFormatted;
|
|
PersonBirthday personBirthday;
|
|
DateTime dateTime = DateTime.Now;
|
|
PersonContainer[] personContainers;
|
|
Dictionary<int, PersonContainer[]>? keyValuePairs;
|
|
foreach (Face face in distinctFilteredFaces)
|
|
{
|
|
if (face.Mapping is null)
|
|
throw new NotSupportedException();
|
|
copyFileName = string.Empty;
|
|
copyDirectory = string.Empty;
|
|
relativePath = Path.GetDirectoryName($"C:{face.RelativePath}");
|
|
if (string.IsNullOrEmpty(relativePath) || relativePath.Length < 3)
|
|
continue;
|
|
if (!_IdThenNormalizedPixelPercentageToPersonContainers.TryGetValue(face.Mapping.MappingFromItem.Id, out keyValuePairs))
|
|
{
|
|
personKey = null;
|
|
directory = Path.Combine(_EDistanceContentTicksDirectory, $"Unnamed{relativePath[2..]}");
|
|
}
|
|
else
|
|
{
|
|
if (!keyValuePairs.ContainsKey(face.Mapping.MappingFromLocation.NormalizedPixelPercentage))
|
|
continue;
|
|
personKey = null;
|
|
isWrongYearFlag = IItem.GetWrongYearFlag(face.Mapping.MappingFromItem.IsWrongYear);
|
|
subDirectoryName = $"{isWrongYearFlag}{face.Mapping.MappingFromItem.MinimumDateTime:yyyy}";
|
|
personContainers = keyValuePairs[face.Mapping.MappingFromLocation.NormalizedPixelPercentage];
|
|
directory = Path.Combine(_EDistanceContentTicksDirectory, $"Not Supported{relativePath[2..]}", subDirectoryName);
|
|
foreach (PersonContainer personContainer in personContainers)
|
|
{
|
|
if (personContainers.Length != 1)
|
|
break;
|
|
if (personContainer.Key is null || personContainer.Birthdays is null || !personContainer.Birthdays.Any())
|
|
continue;
|
|
personKey = personContainer.Key.Value;
|
|
personBirthday = personContainer.Birthdays[zero];
|
|
timeSpan = IPersonBirthday.GetTimeSpan(face.Mapping.MappingFromItem.MinimumDateTime, face.Mapping.MappingFromItem.IsWrongYear, personBirthday);
|
|
if (timeSpan.HasValue)
|
|
{
|
|
if (timeSpan.Value.Ticks < 0)
|
|
subDirectoryName = "!---";
|
|
else
|
|
{
|
|
(years, _) = IPersonBirthday.GetAge(dateTime, personBirthday);
|
|
subDirectoryName = $"^{years:000}";
|
|
}
|
|
}
|
|
personKeyFormatted = IPersonBirthday.GetFormatted(_Configuration.PersonBirthdayFormat, personBirthday);
|
|
directory = Path.Combine(_EDistanceContentTicksDirectory, "Shortcuts", personKeyFormatted, subDirectoryName);
|
|
if (face.FaceEncoding is not null && face.Location?.NormalizedPixelPercentage is not null)
|
|
copyDirectory = Path.Combine(_EDistanceContentTicksDirectory, "Images", personKeyFormatted, subDirectoryName);
|
|
else
|
|
copyDirectory = Path.Combine(_EDistanceContentTicksDirectory, "ImagesBut", personKeyFormatted, subDirectoryName);
|
|
copyFileName = Path.Combine(copyDirectory, $"{face.Mapping.MappingFromItem.Id}{face.Mapping.MappingFromItem.ResizedFileHolder.ExtensionLowered}");
|
|
}
|
|
}
|
|
shortcutFileName = Path.Combine(directory, $"{face.Mapping.MappingFromItem.Id}.lnk");
|
|
if (personKey is null)
|
|
results.Add(new(face, null, (directory, copyDirectory, copyFileName, shortcutFileName)));
|
|
else
|
|
results.Add(new(face, personKey, (directory, copyDirectory, copyFileName, shortcutFileName)));
|
|
}
|
|
return results;
|
|
}
|
|
|
|
private int UpdateFromSortingContainers(SortingContainer[] sortingContainers)
|
|
{
|
|
if (_Configuration is null)
|
|
throw new NullReferenceException(nameof(_Configuration));
|
|
int result = 0;
|
|
Dictionary<int, HashSet<int>> results = new();
|
|
string key;
|
|
const int zero = 0;
|
|
HashSet<int> hashSet;
|
|
string mappingSegmentB;
|
|
string personKeyFormatted;
|
|
List<Mapping> checkCollection;
|
|
PersonBirthday personBirthday;
|
|
PersonContainer[] personContainers;
|
|
const int by = Stateless.IMapLogic.Sorting;
|
|
Dictionary<int, PersonContainer[]>? keyValuePairs;
|
|
Dictionary<string, List<Mapping>> checkKeyValuePairs = new();
|
|
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)";
|
|
ProgressBarOptions options = new() { ProgressCharacter = '─', ProgressBarOnBottom = true, DisableBottomPercentage = true };
|
|
foreach (KeyValuePair<int, Dictionary<int, PersonContainer[]>> keyValuePair in _IdThenNormalizedPixelPercentageToPersonContainers)
|
|
results.Add(keyValuePair.Key, (from l in keyValuePair.Value select l.Key).ToHashSet());
|
|
using ProgressBar progressBar = new(sortingContainers.Length, message, options);
|
|
foreach (SortingContainer sortingContainer in sortingContainers)
|
|
{
|
|
progressBar.Tick();
|
|
if (sortingContainer.Face.Mapping is null)
|
|
throw new NotSupportedException();
|
|
if (!_IdThenNormalizedPixelPercentageToPersonContainers.TryGetValue(sortingContainer.Sorting.Id, out keyValuePairs))
|
|
throw new NotSupportedException();
|
|
if (!results.ContainsKey(sortingContainer.Face.Mapping.MappingFromItem.Id))
|
|
results.Add(sortingContainer.Face.Mapping.MappingFromItem.Id, new());
|
|
hashSet = results[sortingContainer.Face.Mapping.MappingFromItem.Id];
|
|
if (hashSet.Contains(sortingContainer.Face.Mapping.MappingFromLocation.NormalizedPixelPercentage))
|
|
continue;
|
|
if (!keyValuePairs.ContainsKey(sortingContainer.Sorting.NormalizedPixelPercentage))
|
|
throw new NotSupportedException();
|
|
personContainers = keyValuePairs[sortingContainer.Sorting.NormalizedPixelPercentage];
|
|
if (sortingContainer.Face.Mapping.MappingFromLocation.Confidence < _Configuration.FaceDistanceMinimumConfidence || sortingContainer.Sorting.DistancePermyriad > _Configuration.FaceDistancePermyriad || sortingContainer.Sorting.DaysDelta > _Configuration.SortingDaysDeltaTolerance)
|
|
continue;
|
|
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 = GetMappingSegmentB(_Ticks, personBirthday, personContainer.ApproximateYears, sortingContainer.Face.Mapping.MappingFromItem);
|
|
key = string.Concat(personKeyFormatted, '\t', mappingSegmentB);
|
|
if (!checkKeyValuePairs.ContainsKey(key))
|
|
checkKeyValuePairs.Add(key, new());
|
|
checkCollection = checkKeyValuePairs[key];
|
|
if (checkCollection.Count > _Configuration.SortingMaximumPerKey)
|
|
continue;
|
|
_ = hashSet.Add(sortingContainer.Sorting.NormalizedPixelPercentage);
|
|
sortingContainer.Face.Mapping.UpdateMappingFromPerson(personContainer.ApproximateYears, by, personContainer.DisplayDirectoryName, personBirthday, mappingSegmentB);
|
|
checkCollection.Add(sortingContainer.Face.Mapping);
|
|
result += 1;
|
|
break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
internal void ForceSingleImage(IEnumerable<Face> distinctFilteredFaces)
|
|
{
|
|
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;
|
|
Face[] orderedDistinctFilteredFaces = (from l in distinctFilteredFaces orderby l.Mapping is not null, l.Mapping?.MappingFromLocation.Confidence descending select l).ToArray();
|
|
foreach (Face face in orderedDistinctFilteredFaces)
|
|
{
|
|
if (face.Mapping is null)
|
|
throw new NotSupportedException();
|
|
if (face.Mapping.MappingFromPerson.PersonBirthday is not null)
|
|
continue;
|
|
if (_SkipCollection.TryGetValue(face.Mapping.MappingFromItem.Id, out normalizedPixelPercentages))
|
|
{
|
|
if (normalizedPixelPercentages.Contains(face.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 = GetMappingSegmentB(_Ticks, personBirthday, personContainer.ApproximateYears, face.Mapping.MappingFromItem);
|
|
face.Mapping.UpdateMappingFromPerson(personContainer.ApproximateYears, by, personContainer.DisplayDirectoryName, personBirthday, mappingSegmentB);
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
private List<SaveContainer> GetMappingSaveContainers(string dResultsFullGroupDirectory, string d2ResultsFullGroupDirectory, List<Face> filteredFaces)
|
|
{
|
|
if (_Configuration is null)
|
|
throw new NullReferenceException(nameof(_Configuration));
|
|
List<SaveContainer> results = new();
|
|
string by;
|
|
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<string, int> keyValuePairs = new();
|
|
string dFacesContentDirectory = Path.Combine(dResultsFullGroupDirectory, "()");
|
|
string d2FacePartsContentDirectory = Path.Combine(d2ResultsFullGroupDirectory, "()");
|
|
string forceSingleImageHumanized = nameof(Stateless.IMapLogic.ForceSingleImage).Humanize(LetterCasing.Title);
|
|
foreach (Face face in filteredFaces)
|
|
{
|
|
if (face.Mapping is null)
|
|
throw new NotSupportedException();
|
|
directoryName = Path.GetDirectoryName(face.RelativePath);
|
|
if (directoryName is null)
|
|
throw new NotSupportedException();
|
|
if (face.Mapping.MappingFromPerson.PersonBirthday is null)
|
|
continue;
|
|
if (string.IsNullOrEmpty(face.Mapping.MappingFromPerson.SegmentB))
|
|
throw new NotSupportedException();
|
|
personKeyFormatted = IPersonBirthday.GetFormatted(_Configuration.PersonBirthdayFormat, face.Mapping.MappingFromPerson.PersonBirthday);
|
|
if (face.Mapping.MappingFromPerson.By is null)
|
|
by = $"{nameof(Stateless.IMapLogic.Mapping)}Null";
|
|
else
|
|
{
|
|
if (face.Mapping.MappingFromPerson.By == Stateless.IMapLogic.Mapping && !_Configuration.MappingSaveMapped)
|
|
continue;
|
|
by = face.Mapping.MappingFromPerson.By.Value switch
|
|
{
|
|
Stateless.IMapLogic.Mapping => nameof(Stateless.IMapLogic.Mapping),
|
|
Stateless.IMapLogic.Sorting => nameof(Stateless.IMapLogic.Sorting),
|
|
Stateless.IMapLogic.ForceSingleImage => forceSingleImageHumanized,
|
|
_ => throw new NotImplementedException()
|
|
};
|
|
}
|
|
directory = Path.Combine(_EDistanceContentTicksDirectory, by, personKeyFormatted, face.Mapping.MappingFromPerson.SegmentB);
|
|
if (!keyValuePairs.ContainsKey(directory))
|
|
keyValuePairs.Add(directory, 0);
|
|
keyValuePairs[directory]++;
|
|
if (face.Mapping.MappingFromPerson.By is not null)
|
|
personDirectory = Path.Combine(directory, face.Mapping.MappingFromPerson.DisplayDirectoryName, "lnk");
|
|
else
|
|
personDirectory = Path.Combine(directory, face.Mapping.MappingFromPerson.DisplayDirectoryName[..1], "lnk");
|
|
saveContainer = new(personDirectory);
|
|
results.Add(saveContainer);
|
|
facesDirectory = Path.Combine($"{dFacesContentDirectory}{directoryName}", face.Mapping.MappingFromItem.ImageFileHolder.NameWithoutExtension);
|
|
facePartsDirectory = Path.Combine($"{d2FacePartsContentDirectory}{directoryName}", face.Mapping.MappingFromItem.ImageFileHolder.NameWithoutExtension);
|
|
checkFile = Path.Combine(directory, $"{face.Mapping.MappingFromLocation.DeterministicHashCodeKey}{face.Mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}");
|
|
faceFileHolder = new(Path.Combine(facesDirectory, $"{face.Mapping.MappingFromLocation.DeterministicHashCodeKey}{face.Mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}{_FacesFileNameExtension}"));
|
|
hiddenFaceFileHolder = new(Path.Combine(facesDirectory, $"{face.Mapping.MappingFromLocation.DeterministicHashCodeKey}{face.Mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}{_FacesHiddenFileNameExtension}"));
|
|
facePartsFileHolder = new(Path.Combine(facePartsDirectory, $"{face.Mapping.MappingFromLocation.DeterministicHashCodeKey}{face.Mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}{_FacePartsFileNameExtension}"));
|
|
if (string.IsNullOrEmpty(personDirectory) || face.Mapping.MappingFromPerson.By == Stateless.IMapLogic.Mapping)
|
|
shortcutFile = string.Empty;
|
|
else
|
|
shortcutFile = Path.Combine(personDirectory, $"{face.Mapping.MappingFromLocation.DeterministicHashCodeKey}{face.Mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}.lnk");
|
|
saveContainer = new(checkFile, directory, faceFileHolder, hiddenFaceFileHolder, string.Empty, facePartsFileHolder, face.Mapping.MappingFromItem.ResizedFileHolder, shortcutFile);
|
|
results.Add(saveContainer);
|
|
}
|
|
return results;
|
|
}
|
|
|
|
public void ForceSingleImageThenSaveMapping(string dResultsFullGroupDirectory, string d2ResultsFullGroupDirectory, List<Face> distinctFilteredFaces, SortingContainer[] sortingContainers, int totalNotMapped)
|
|
{
|
|
List<SaveContainer> saveContainers;
|
|
if (!sortingContainers.Any())
|
|
{
|
|
ForceSingleImage(distinctFilteredFaces);
|
|
saveContainers = GetMappingSaveContainers(dResultsFullGroupDirectory, d2ResultsFullGroupDirectory, distinctFilteredFaces);
|
|
}
|
|
else
|
|
{
|
|
int updated = UpdateFromSortingContainers(sortingContainers);
|
|
if (totalNotMapped - updated > 0)
|
|
ForceSingleImage(distinctFilteredFaces);
|
|
saveContainers = GetMappingSaveContainers(dResultsFullGroupDirectory, d2ResultsFullGroupDirectory, distinctFilteredFaces);
|
|
}
|
|
SaveContainers(saveContainers);
|
|
}
|
|
|
|
private static Dictionary<int, Dictionary<int, Face>> GetKeyValuePairs(List<Face> distinctFilteredFaces)
|
|
{
|
|
Dictionary<int, Dictionary<int, Face>> results = new();
|
|
Dictionary<int, Face> keyValuePairs;
|
|
foreach (Face face in distinctFilteredFaces)
|
|
{
|
|
if (face.Mapping is null)
|
|
throw new NotSupportedException();
|
|
if (!results.ContainsKey(face.Mapping.MappingFromItem.Id))
|
|
results.Add(face.Mapping.MappingFromItem.Id, new());
|
|
keyValuePairs = results[face.Mapping.MappingFromItem.Id];
|
|
if (keyValuePairs.ContainsKey(face.Mapping.MappingFromLocation.NormalizedPixelPercentage))
|
|
throw new NotSupportedException();
|
|
keyValuePairs.Add(face.Mapping.MappingFromLocation.NormalizedPixelPercentage, face);
|
|
}
|
|
return results;
|
|
}
|
|
|
|
public void CopyManualFiles(string dResultsFullGroupDirectory, List<Face> distinctFilteredFaces)
|
|
{
|
|
if (_Configuration is null)
|
|
throw new NullReferenceException(nameof(_Configuration));
|
|
int? id;
|
|
Face face;
|
|
string faceFile;
|
|
string checkFile;
|
|
string directory;
|
|
FileInfo fileInfo;
|
|
const int zero = 0;
|
|
string faceFileName;
|
|
string shortcutFile;
|
|
string? directoryName;
|
|
string facesDirectory;
|
|
string mappingSegmentB;
|
|
string personDirectory;
|
|
string personKeyFormatted;
|
|
string personDisplayFileName;
|
|
PersonBirthday personBirthday;
|
|
string? personDisplayDirectory;
|
|
int? normalizedPixelPercentage;
|
|
WindowsShortcut windowsShortcut;
|
|
Dictionary<int, PersonContainer[]>? keyValuePairs;
|
|
string by = nameof(Stateless.IMapLogic.ManualCopy);
|
|
Dictionary<int, Face>? normalizedPixelPercentageToFace;
|
|
string dFacesContentDirectory = Path.Combine(dResultsFullGroupDirectory, "()");
|
|
string successfull = $"_ {nameof(Stateless.IMapLogic.ManualCopy).Humanize(LetterCasing.Title)} Successfull";
|
|
Dictionary<int, Dictionary<int, Face>> idToNormalizedPixelPercentageToFace = GetKeyValuePairs(distinctFilteredFaces);
|
|
foreach (KeyValuePair<long, PersonContainer> keyValuePair in _PersonKeyToPersonContainer)
|
|
{
|
|
if (keyValuePair.Value.Key is null || keyValuePair.Value.Birthdays is null || !keyValuePair.Value.Birthdays.Any())
|
|
continue;
|
|
personBirthday = keyValuePair.Value.Birthdays[zero];
|
|
foreach (string personDisplayDirectoryAllFile in keyValuePair.Value.DisplayDirectoryAllFiles)
|
|
{
|
|
if (!personDisplayDirectoryAllFile.EndsWith(_FacesFileNameExtension))
|
|
continue;
|
|
(id, normalizedPixelPercentage, _) = IMapping.GetReversedDeterministicHashCodeKey(_Configuration.LocationDigits, _FacesFileNameExtension, personDisplayDirectoryAllFile);
|
|
if (id is null || normalizedPixelPercentage is null)
|
|
continue;
|
|
if (_IdThenNormalizedPixelPercentageToPersonContainers.TryGetValue(id.Value, out keyValuePairs))
|
|
{
|
|
if (keyValuePairs.ContainsKey(normalizedPixelPercentage.Value))
|
|
continue;
|
|
}
|
|
fileInfo = new(personDisplayDirectoryAllFile);
|
|
if (!fileInfo.Exists)
|
|
continue;
|
|
personDisplayFileName = Path.GetFileName(personDisplayDirectoryAllFile);
|
|
personDisplayDirectory = Path.GetDirectoryName(personDisplayDirectoryAllFile);
|
|
personKeyFormatted = IPersonBirthday.GetFormatted(_Configuration.PersonBirthdayFormat, personBirthday);
|
|
mappingSegmentB = GetMappingSegmentB(_Ticks, personBirthday, keyValuePair.Value.ApproximateYears, fileInfo.CreationTime, isWrongYear: null);
|
|
directory = Path.Combine(_EDistanceContentTicksDirectory, by, personKeyFormatted, mappingSegmentB);
|
|
personDirectory = Path.Combine(directory, keyValuePair.Value.DisplayDirectoryName, "lnk");
|
|
if (!idToNormalizedPixelPercentageToFace.TryGetValue(id.Value, out normalizedPixelPercentageToFace))
|
|
continue;
|
|
if (!normalizedPixelPercentageToFace.ContainsKey(normalizedPixelPercentage.Value))
|
|
continue;
|
|
face = idToNormalizedPixelPercentageToFace[id.Value][normalizedPixelPercentage.Value];
|
|
if (face.Mapping is null)
|
|
throw new NotSupportedException();
|
|
if (string.IsNullOrEmpty(personDisplayDirectory))
|
|
throw new NotSupportedException();
|
|
directoryName = Path.GetDirectoryName(face.RelativePath);
|
|
if (string.IsNullOrEmpty(directoryName))
|
|
throw new NotSupportedException();
|
|
shortcutFile = Path.Combine(personDisplayDirectory, $"{personDisplayFileName}.lnk");
|
|
facesDirectory = Path.Combine($"{dFacesContentDirectory}{directoryName}", face.Mapping.MappingFromItem.ImageFileHolder.NameWithoutExtension);
|
|
faceFileName = $"{face.Mapping.MappingFromLocation.DeterministicHashCodeKey}{face.Mapping.MappingFromItem.ImageFileHolder.ExtensionLowered}{_FacesFileNameExtension}";
|
|
checkFile = Path.Combine(directory, fileInfo.Name);
|
|
if (!Directory.Exists(personDirectory))
|
|
_ = Directory.CreateDirectory(personDirectory);
|
|
if (!File.Exists(checkFile))
|
|
File.Copy(personDisplayDirectoryAllFile, checkFile);
|
|
if (personDisplayDirectoryAllFile.Contains(successfull))
|
|
continue;
|
|
directoryName = Path.Combine(personDisplayDirectory, successfull);
|
|
if (!Directory.Exists(directoryName))
|
|
_ = Directory.CreateDirectory(directoryName);
|
|
checkFile = Path.Combine(directoryName, personDisplayFileName);
|
|
File.Move(personDisplayDirectoryAllFile, checkFile);
|
|
faceFile = Path.Combine(facesDirectory, faceFileName);
|
|
if (!File.Exists(faceFile))
|
|
continue;
|
|
if (File.Exists(shortcutFile))
|
|
continue;
|
|
windowsShortcut = new() { Path = faceFile };
|
|
windowsShortcut.Save(shortcutFile);
|
|
windowsShortcut.Dispose();
|
|
if (!File.Exists(shortcutFile))
|
|
continue;
|
|
File.SetLastWriteTime(shortcutFile, face.Mapping.MappingFromItem.MinimumDateTime);
|
|
}
|
|
}
|
|
}
|
|
|
|
} |