473 lines
27 KiB
C#
473 lines
27 KiB
C#
using System.Text;
|
|
using System.Text.Json;
|
|
using System.Text.RegularExpressions;
|
|
using View_by_Distance.FaceRecognitionDotNet;
|
|
using View_by_Distance.Metadata.Models;
|
|
using View_by_Distance.Property.Models;
|
|
using View_by_Distance.Resize.Models;
|
|
using View_by_Distance.Shared.Models.Stateless;
|
|
|
|
namespace View_by_Distance.Instance.Models;
|
|
|
|
/// <summary>
|
|
// List<D_Faces>
|
|
/// </summary>
|
|
|
|
internal class E_Distance
|
|
{
|
|
|
|
private readonly Serilog.ILogger? _Log;
|
|
private readonly Configuration _Configuration;
|
|
private readonly JsonSerializerOptions _WriteIndentedJsonSerializerOptions;
|
|
|
|
internal E_Distance(Configuration configuration)
|
|
{
|
|
_Configuration = configuration;
|
|
_Log = Serilog.Log.ForContext<E_Distance>();
|
|
_WriteIndentedJsonSerializerOptions = new JsonSerializerOptions { WriteIndented = true };
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string result = JsonSerializer.Serialize(this, new JsonSerializerOptions() { WriteIndented = true });
|
|
return result;
|
|
}
|
|
|
|
private static void LoadFaceEncodingCollections(PropertyHolder[] filteredPropertyHolderCollection, List<List<D_Face>> faceCollections, List<int[]> locationIndicesCollection, List<FaceEncoding> faceEncodingCollection, List<List<FaceEncoding>> faceEncodingCollections)
|
|
{
|
|
List<D_Face> faceCollection;
|
|
FaceEncoding faceEncoding;
|
|
for (int i = 0; i < filteredPropertyHolderCollection.Length; i++)
|
|
{
|
|
faceCollection = faceCollections[i];
|
|
if (!faceCollection.Any())
|
|
throw new Exception();
|
|
faceEncodingCollections.Add(new List<FaceEncoding>());
|
|
for (int j = 0; j < faceCollection.Count; j++)
|
|
{
|
|
if (!faceCollection[j].Populated)
|
|
continue;
|
|
faceEncoding = FaceRecognition.LoadFaceEncoding(faceCollection[j].FaceEncoding.RawEncoding);
|
|
faceEncodingCollection.Add(faceEncoding);
|
|
faceEncodingCollections[i].Add(faceEncoding);
|
|
locationIndicesCollection.Add(new int[] { i, j });
|
|
}
|
|
}
|
|
}
|
|
|
|
private List<Tuple<Shared.Models.Properties.IFace, string>> GetOrderedNoFaceCollection(List<List<D_Face>> faceCollections, int i, D_Face face)
|
|
{
|
|
List<Tuple<Shared.Models.Properties.IFace, string>> results = new() { new(face, string.Empty) };
|
|
if (_Configuration.MaxItemsInDistanceCollection is null)
|
|
throw new Exception();
|
|
for (int n = 0; n < faceCollections.Count; n++)
|
|
{
|
|
if (i == n)
|
|
continue;
|
|
for (int j = 0; j < faceCollections[n].Count; j++)
|
|
results.Add(new(faceCollections[n][j], string.Empty));
|
|
}
|
|
for (int r = results.Count - 1; r > _Configuration.MaxItemsInDistanceCollection.Value; r--)
|
|
results.RemoveAt(r);
|
|
return results;
|
|
}
|
|
|
|
private List<double[]> GetValues(List<List<D_Face>> faceCollections, List<int[]> locationIndicesCollection, List<double> faceDistances)
|
|
{
|
|
List<double[]> results = new();
|
|
if (_Configuration.LocationConfidenceFactor is null)
|
|
throw new Exception();
|
|
if (_Configuration.DistanceFactor is null)
|
|
throw new Exception();
|
|
D_Face face;
|
|
int[] locationIndices;
|
|
for (int d = 0; d < faceDistances.Count; d++)
|
|
{
|
|
locationIndices = locationIndicesCollection[d];
|
|
face = faceCollections[locationIndices[0]][locationIndices[1]];
|
|
if (face.Populated && face.LocationIndex is not null && locationIndices[1] != face.LocationIndex)
|
|
throw new Exception();
|
|
results.Add(new double[] { d, faceDistances[d], (faceDistances[d] * _Configuration.DistanceFactor.Value) + face.Location.Confidence * _Configuration.LocationConfidenceFactor.Value / 10 });
|
|
}
|
|
results = (from l in results orderby l[2] select l).ToList();
|
|
return results;
|
|
}
|
|
|
|
private List<Tuple<Shared.Models.Properties.IFace, string>> GetOrderedFaceCollection(List<List<D_Face>> faceCollections, List<int[]> locationIndicesCollection, List<double[]> indicesAndValues)
|
|
{
|
|
List<Tuple<Shared.Models.Properties.IFace, string>> results = new();
|
|
if (_Configuration.MaxItemsInDistanceCollection is null)
|
|
throw new Exception();
|
|
int[] locationIndices;
|
|
for (int t = 0; t < indicesAndValues.Count; t++)
|
|
{
|
|
locationIndices = locationIndicesCollection[(int)indicesAndValues[t][0]];
|
|
results.Add(new(faceCollections[locationIndices[0]][locationIndices[1]], string.Join('|', (from l in indicesAndValues[t] select l.ToString("0.000")).ToArray(), 1, indicesAndValues[t].Length - 1)));
|
|
}
|
|
for (int r = results.Count - 1; r > _Configuration.MaxItemsInDistanceCollection.Value; r--)
|
|
results.RemoveAt(r);
|
|
return results;
|
|
}
|
|
|
|
private static string GetText(string fileNameWithoutExtension, List<List<D_Face>> faceCollections, List<int[]> locationIndicesCollection, List<double[]> indicesAndValues)
|
|
{
|
|
string result;
|
|
D_Face face;
|
|
int[] locationIndices;
|
|
StringBuilder tvs = new();
|
|
_ = tvs.Append("FileNameWithoutExtension").Append('\t').Append("LocationIndex").Append('\t').Append("FaceConfidence").Append('\t').Append("FaceDistance").Append('\t').Append("FactoredValue").AppendLine();
|
|
for (int t = 0; t < indicesAndValues.Count; t++)
|
|
{
|
|
locationIndices = locationIndicesCollection[(int)indicesAndValues[t][0]];
|
|
face = faceCollections[locationIndices[0]][locationIndices[1]];
|
|
if (face.Populated && face.LocationIndex is not null && locationIndices[1] != face.LocationIndex)
|
|
throw new Exception();
|
|
_ = tvs.Append(fileNameWithoutExtension).Append('\t').Append(face.LocationIndex).Append('\t').Append(face.Location.Confidence).Append('\t').Append(indicesAndValues[t][1]).Append('\t').Append(indicesAndValues[t][2]).AppendLine();
|
|
}
|
|
result = tvs.ToString();
|
|
return result;
|
|
}
|
|
|
|
private void LoadOrCreateThenSaveDistanceResultsForOutputResolutionsLoop(Property.Models.Configuration configuration, List<List<D_Face>> faceCollections, int subFilesCount, int i, List<D_Face> faceCollection, List<int[]> locationIndicesCollection, List<Tuple<string, DateTime>> subFileTuples, List<FaceEncoding> faceEncodingCollection, List<FaceEncoding> faceEncodingCollections, string fileNameWithoutExtension, string jsonDirectory, string tvsDirectory)
|
|
{
|
|
string text;
|
|
string json;
|
|
string jsonFile;
|
|
List<Tuple<Shared.Models.Properties.IFace, string>> orderedFaceCollection;
|
|
if (!Directory.Exists(jsonDirectory))
|
|
_ = Directory.CreateDirectory(jsonDirectory);
|
|
if (!Directory.Exists(tvsDirectory))
|
|
_ = Directory.CreateDirectory(tvsDirectory);
|
|
if (!faceEncodingCollections.Any())
|
|
{
|
|
int j = 0;
|
|
orderedFaceCollection = GetOrderedNoFaceCollection(faceCollections, i, faceCollection[j]);
|
|
json = JsonSerializer.Serialize(orderedFaceCollection, _WriteIndentedJsonSerializerOptions);
|
|
jsonFile = Path.Combine(jsonDirectory, $"{j} - {fileNameWithoutExtension}.json");
|
|
if (Property.Models.Stateless.IPath.WriteAllText(jsonFile, json, compareBeforeWrite: true))
|
|
subFileTuples.Add(new Tuple<string, DateTime>(nameof(E_Distance), DateTime.Now));
|
|
}
|
|
else
|
|
{
|
|
string tvsFile;
|
|
List<double> faceDistances;
|
|
List<double[]> indicesAndValues;
|
|
for (int j = 0; j < faceEncodingCollections.Count; j++)
|
|
{
|
|
if (!faceCollection[j].Populated)
|
|
continue;
|
|
tvsFile = Path.Combine(tvsDirectory, $"{j} - {fileNameWithoutExtension}.tvs");
|
|
jsonFile = Path.Combine(jsonDirectory, $"{j} - {fileNameWithoutExtension}.json");
|
|
faceDistances = FaceRecognition.FaceDistances(faceEncodingCollection, faceEncodingCollections[j]);
|
|
indicesAndValues = GetValues(faceCollections, locationIndicesCollection, faceDistances);
|
|
orderedFaceCollection = GetOrderedFaceCollection(faceCollections, locationIndicesCollection, indicesAndValues);
|
|
text = GetText(fileNameWithoutExtension, faceCollections, locationIndicesCollection, indicesAndValues);
|
|
if (Property.Models.Stateless.IPath.WriteAllText(tvsFile, text, compareBeforeWrite: true))
|
|
subFileTuples.Add(new Tuple<string, DateTime>(nameof(E_Distance), DateTime.Now));
|
|
json = JsonSerializer.Serialize(orderedFaceCollection, _WriteIndentedJsonSerializerOptions);
|
|
if (Property.Models.Stateless.IPath.WriteAllText(jsonFile, json, compareBeforeWrite: true))
|
|
subFileTuples.Add(new Tuple<string, DateTime>(nameof(E_Distance), DateTime.Now));
|
|
}
|
|
}
|
|
}
|
|
|
|
private void LoadOrCreateThenSaveDistanceResultsForOutputResolutions(Property.Models.Configuration configuration, PropertyHolder[] filteredPropertyHolderCollection, List<List<D_Face>> faceCollections, List<string[]> directories)
|
|
{
|
|
FileInfo? fileInfo;
|
|
string fileNameWithoutExtension;
|
|
List<int[]> locationIndicesCollection = new();
|
|
List<Tuple<string, DateTime>> subFileTuples = new();
|
|
List<FaceEncoding> faceEncodingCollection = new();
|
|
List<List<FaceEncoding>> faceEncodingCollections = new();
|
|
LoadFaceEncodingCollections(filteredPropertyHolderCollection, faceCollections, locationIndicesCollection, faceEncodingCollection, faceEncodingCollections);
|
|
if (faceEncodingCollections.Count != faceCollections.Count)
|
|
throw new Exception();
|
|
if (locationIndicesCollection.Count != faceEncodingCollection.Count)
|
|
throw new Exception();
|
|
for (int i = 0; i < filteredPropertyHolderCollection.Length; i++)
|
|
{
|
|
fileInfo = filteredPropertyHolderCollection[i].ImageFileInfo;
|
|
if (fileInfo is null)
|
|
continue;
|
|
fileNameWithoutExtension = Path.GetFileNameWithoutExtension(fileInfo.FullName);
|
|
LoadOrCreateThenSaveDistanceResultsForOutputResolutionsLoop(configuration, faceCollections, filteredPropertyHolderCollection.Length, i, faceCollections[i], locationIndicesCollection, subFileTuples, faceEncodingCollection, faceEncodingCollections[i], fileNameWithoutExtension, directories[i][0], directories[i][1]);
|
|
}
|
|
}
|
|
|
|
internal void LoadOrCreateThenSaveDistanceResultsForOutputResolutions(Property.Models.Configuration configuration, Model? model, PredictorModel? predictorModel, string sourceDirectory, string outputResolution, List<Tuple<string, DateTime>> sourceDirectoryChanges, PropertyHolder[] filteredPropertyHolderCollection, List<List<D_Face>> faceCollections)
|
|
{
|
|
if (_Configuration.CheckJsonForDistanceResults is null)
|
|
throw new Exception();
|
|
if (_Configuration.PropertiesChangedForDistance is null)
|
|
throw new Exception();
|
|
string json;
|
|
FileInfo? fileInfo;
|
|
bool check = false;
|
|
string parentCheck;
|
|
FileInfo[] fileInfoCollection;
|
|
string fileNameWithoutExtension;
|
|
List<string[]> directories = new();
|
|
System.IO.DirectoryInfo directoryInfo;
|
|
System.IO.DirectoryInfo tvsDirectoryInfo;
|
|
string[] changesFrom = new string[] { nameof(A_Property), nameof(B_Metadata), nameof(C_Resize), nameof(D_Face) };
|
|
List<DateTime> dateTimes = (from l in sourceDirectoryChanges where changesFrom.Contains(l.Item1) select l.Item2).ToList();
|
|
List<string> directoryInfoCollection = Property.Models.Stateless.IResult.GetDirectoryInfoCollection(configuration,
|
|
model,
|
|
predictorModel,
|
|
sourceDirectory,
|
|
nameof(E_Distance),
|
|
outputResolution,
|
|
includeResizeGroup: true,
|
|
includeModel: true,
|
|
includePredictorModel: true,
|
|
contentDescription: ".tvs File",
|
|
singletonDescription: string.Empty,
|
|
collectionDescription: "n json file(s) for each face found (one to many)");
|
|
for (int i = 0; i < filteredPropertyHolderCollection.Length; i++)
|
|
{
|
|
fileInfo = filteredPropertyHolderCollection[i].ImageFileInfo;
|
|
if (fileInfo is null)
|
|
continue;
|
|
fileNameWithoutExtension = Path.GetFileNameWithoutExtension(fileInfo.FullName);
|
|
directoryInfo = new System.IO.DirectoryInfo(Path.Combine(directoryInfoCollection[0].Replace("<>", "[]"), fileNameWithoutExtension));
|
|
if (!directoryInfo.Exists)
|
|
{
|
|
if (directoryInfo.Parent?.Parent is null)
|
|
throw new Exception();
|
|
parentCheck = Path.Combine(directoryInfo.Parent.Parent.FullName, directoryInfo.Name);
|
|
if (Directory.Exists(parentCheck))
|
|
{
|
|
foreach (string file in Directory.GetFiles(parentCheck))
|
|
File.Delete(file);
|
|
Directory.Delete(parentCheck);
|
|
}
|
|
}
|
|
tvsDirectoryInfo = new System.IO.DirectoryInfo(Path.Combine(directoryInfoCollection[0].Replace("<>", "()"), fileNameWithoutExtension));
|
|
directories.Add(new string[] { directoryInfo.FullName, tvsDirectoryInfo.FullName });
|
|
if (_Configuration.CheckJsonForDistanceResults.Value && directoryInfo.Exists)
|
|
{
|
|
fileInfoCollection = directoryInfo.GetFiles("*.json", SearchOption.AllDirectories);
|
|
for (int j = 0; j < fileInfoCollection.Length; j++)
|
|
{
|
|
json = Shared.Models.Stateless.Methods.IIndex.GetJson(fileInfoCollection[j].FullName, fileInfoCollection[j]);
|
|
if (!_Configuration.PropertiesChangedForDistance.Value && Shared.Models.Stateless.Methods.IFace.GetFace(fileInfoCollection[j].FullName) is null)
|
|
check = true;
|
|
}
|
|
}
|
|
if (check)
|
|
continue;
|
|
if (_Configuration.PropertiesChangedForDistance.Value)
|
|
check = true;
|
|
else if (!directoryInfo.Exists)
|
|
check = true;
|
|
else if (!tvsDirectoryInfo.Exists)
|
|
check = true;
|
|
else if (dateTimes.Any() && dateTimes.Max() > directoryInfo.LastWriteTime)
|
|
check = true;
|
|
}
|
|
if (check)
|
|
LoadOrCreateThenSaveDistanceResultsForOutputResolutions(configuration, filteredPropertyHolderCollection, faceCollections, directories);
|
|
_ = Property.Models.Stateless.IPath.DeleteEmptyDirectories(directoryInfoCollection[0].Replace("<>", "()"));
|
|
}
|
|
|
|
private List<(string, List<KeyValuePair<string, Shared.Models.Face[]>>)> GetFiles(Property.Models.Configuration configuration, Model? model, PredictorModel? predictorModel, string outputResolution)
|
|
{
|
|
string json;
|
|
List<KeyValuePair<string, Shared.Models.Face[]>>? facesKeyValuePairCollection;
|
|
List<(string, List<KeyValuePair<string, Shared.Models.Face[]>>)> results = new();
|
|
string dFacesCollectionDirectory = Path.Combine(Property.Models.Stateless.IResult.GetResultsFullGroupDirectory(configuration, model, predictorModel, nameof(D_Face), outputResolution, includeResizeGroup: true, includeModel: true, includePredictorModel: true), "[[]]");
|
|
string[] dFacesCollectionFiles = Directory.GetFiles(dFacesCollectionDirectory, "*.json", SearchOption.TopDirectoryOnly);
|
|
foreach (string dFacesCollectionFile in dFacesCollectionFiles)
|
|
{
|
|
json = File.ReadAllText(dFacesCollectionFile);
|
|
facesKeyValuePairCollection = JsonSerializer.Deserialize<List<KeyValuePair<string, Shared.Models.Face[]>>>(json);
|
|
if (facesKeyValuePairCollection is null)
|
|
continue;
|
|
results.Add(new(dFacesCollectionFile, facesKeyValuePairCollection));
|
|
}
|
|
return results;
|
|
}
|
|
|
|
private static List<(string, List<Shared.Models.Face>, List<FaceEncoding>)> GetMatches(List<(string, List<KeyValuePair<string, Shared.Models.Face[]>>)> files)
|
|
{
|
|
List<(string, List<Shared.Models.Face>, List<FaceEncoding>)> results = new();
|
|
FaceEncoding faceEncoding;
|
|
List<Shared.Models.Face> faces;
|
|
List<FaceEncoding> faceEncodings;
|
|
foreach ((string, List<KeyValuePair<string, Shared.Models.Face[]>>) file in files)
|
|
{
|
|
faces = new();
|
|
faceEncodings = new();
|
|
foreach (KeyValuePair<string, Shared.Models.Face[]> keyValuePair in file.Item2)
|
|
{
|
|
foreach (Shared.Models.Face face in keyValuePair.Value)
|
|
{
|
|
if (!face.Populated)
|
|
continue;
|
|
faces.Add(face);
|
|
faceEncoding = FaceRecognition.LoadFaceEncoding(face.FaceEncoding.RawEncoding);
|
|
faceEncodings.Add(faceEncoding);
|
|
}
|
|
}
|
|
results.Add(new(file.Item1, faces, faceEncodings));
|
|
}
|
|
return results;
|
|
}
|
|
|
|
private static int GetIndex(double[] faceDistances)
|
|
{
|
|
int result;
|
|
List<double[]> faceDistancesWithIndex = new();
|
|
for (int y = 0; y < faceDistances.Length; y++)
|
|
faceDistancesWithIndex.Add(new double[] { faceDistances[y], y });
|
|
faceDistancesWithIndex = (from l in faceDistancesWithIndex orderby l[0] select l).ToList();
|
|
result = (int)faceDistancesWithIndex[0][1];
|
|
return result;
|
|
}
|
|
|
|
private void Save(Property.Models.Configuration configuration, Model? model, PredictorModel? predictorModel, string outputResolution, string eDistanceCollectionDirectory, int k, string relativePath, Shared.Models.Face face, List<Tuple<Shared.Models.Face, string>> faceAndFaceDistanceCollection)
|
|
{
|
|
if (string.IsNullOrEmpty(eDistanceCollectionDirectory))
|
|
eDistanceCollectionDirectory = Path.Combine(Property.Models.Stateless.IResult.GetResultsFullGroupDirectory(configuration, model, predictorModel, nameof(E_Distance), outputResolution, includeResizeGroup: true, includeModel: true, includePredictorModel: true), "[]");
|
|
string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(face.RelativePath);
|
|
string jsonDirectory = string.Concat(eDistanceCollectionDirectory, Path.Combine(relativePath, fileNameWithoutExtension));
|
|
if (!Directory.Exists(jsonDirectory))
|
|
_ = Directory.CreateDirectory(jsonDirectory);
|
|
string json = JsonSerializer.Serialize(faceAndFaceDistanceCollection, _WriteIndentedJsonSerializerOptions);
|
|
string jsonFile = Path.Combine(jsonDirectory, $"{k} - {fileNameWithoutExtension}.nosj");
|
|
_ = Property.Models.Stateless.IPath.WriteAllText(jsonFile, json, compareBeforeWrite: true);
|
|
}
|
|
|
|
private static Tuple<Shared.Models.Face, double> Get(FaceEncoding faceEncoding, (string, List<Shared.Models.Face>, List<FaceEncoding>) match)
|
|
{
|
|
Tuple<Shared.Models.Face, double> result;
|
|
double[] faceDistances = FaceRecognition.FaceDistances(match.Item3, faceEncoding).ToArray();
|
|
int index = GetIndex(faceDistances);
|
|
result = new(match.Item2[index], faceDistances[index]);
|
|
return result;
|
|
}
|
|
|
|
internal void LoadOrCreateThenSaveDirectoryDistanceResultsForOutputResolutions(Property.Models.Configuration configuration, Model? model, PredictorModel? predictorModel, string outputResolution)
|
|
{
|
|
if (_Log is null)
|
|
throw new Exception($"{nameof(_Log)} is null!");
|
|
string? relativePath;
|
|
Shared.Models.Face face;
|
|
ParallelOptions parallelOptions = new();
|
|
FaceEncoding faceEncoding;
|
|
string eDistanceCollectionDirectory = string.Empty;
|
|
Tuple<Shared.Models.Face, double> faceAndFaceDistance;
|
|
List<Tuple<Shared.Models.Face, string>> faceAndFaceDistanceCollection;
|
|
List<(string, List<KeyValuePair<string, Shared.Models.Face[]>>)> files = GetFiles(configuration, model, predictorModel, outputResolution);
|
|
List<(string, List<Shared.Models.Face>, List<FaceEncoding>)> matches = GetMatches(files);
|
|
if (files.Count != matches.Count)
|
|
throw new Exception();
|
|
int filesCount = files.Count;
|
|
for (int i = 0; i < filesCount; i++)
|
|
{
|
|
if (_Configuration.CrossDirectoryMaxItemsInDistanceCollection is null)
|
|
continue;
|
|
_Log.Debug(string.Concat("LoadOrCreateThenSaveDirectoryDistanceResultsForOutputResolutions - ", nameof(outputResolution), ' ', outputResolution, " - ", i, " of ", filesCount));
|
|
for (int j = 0; j < files[i].Item2.Count; j++)
|
|
{
|
|
if (!matches[i].Item2.Any())
|
|
continue;
|
|
for (int k = 0; k < files[i].Item2[j].Value.Length; k++)
|
|
{
|
|
if (!files[i].Item2[j].Value[k].Populated)
|
|
continue;
|
|
face = files[i].Item2[j].Value[k];
|
|
faceAndFaceDistanceCollection = new(matches.Count);
|
|
relativePath = Path.GetDirectoryName(face.RelativePath);
|
|
if (string.IsNullOrEmpty(relativePath))
|
|
continue;
|
|
faceEncoding = FaceRecognition.LoadFaceEncoding(face.FaceEncoding.RawEncoding);
|
|
_ = Parallel.For(0, matches.Count, parallelOptions, z =>
|
|
{
|
|
if (z != i && matches[z].Item2.Any())
|
|
{
|
|
faceAndFaceDistance = Get(faceEncoding, matches[z]);
|
|
// if (faceAndFaceDistance.Item2 < _Configuration.)
|
|
faceAndFaceDistanceCollection.Add(new(faceAndFaceDistance.Item1, faceAndFaceDistance.Item2.ToString("0.000")));
|
|
}
|
|
});
|
|
if (faceAndFaceDistanceCollection.Any())
|
|
{
|
|
faceAndFaceDistanceCollection = (from l in faceAndFaceDistanceCollection orderby l.Item2 select l).Take(_Configuration.CrossDirectoryMaxItemsInDistanceCollection.Value).ToList();
|
|
Save(configuration, model, predictorModel, outputResolution, eDistanceCollectionDirectory, k, relativePath, face, faceAndFaceDistanceCollection);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static Dictionary<string, List<(string directory, string personKey, D_Face face)>> Convert(string argZero, List<PropertyHolder[]> propertyHolderCollections)
|
|
{
|
|
Dictionary<string, List<(string directory, string personKey, D_Face face)>> results = new();
|
|
string key;
|
|
foreach (PropertyHolder[] propertyHolderCollection in propertyHolderCollections)
|
|
{
|
|
if (!propertyHolderCollection.Any())
|
|
continue;
|
|
if (!propertyHolderCollection[0].SourceDirectory.StartsWith(argZero))
|
|
continue;
|
|
foreach (PropertyHolder propertyHolder in propertyHolderCollection)
|
|
{
|
|
if (propertyHolder.ImageFileInfo is null || propertyHolder.Property is null || !propertyHolder.Named.Any())
|
|
continue;
|
|
foreach ((string directory, string personKey, object @object) in propertyHolder.Named)
|
|
{
|
|
if (string.IsNullOrEmpty(directory) || string.IsNullOrEmpty(personKey) || !directory.Contains(personKey))
|
|
continue;
|
|
if (@object is not D_Face face || face.FaceEncoding is null)
|
|
continue;
|
|
key = directory.Split(personKey)[1];
|
|
if (!results.ContainsKey(key))
|
|
results.Add(key, new());
|
|
results[key].Add(new(directory, personKey, face));
|
|
}
|
|
}
|
|
}
|
|
return results;
|
|
}
|
|
|
|
internal static void SaveGroupedFaceEncodings(Property.Models.Configuration configuration, Model? model, PredictorModel? predictorModel, string argZero, Dictionary<string, List<Shared.Models.Person>> peopleCollection, string outputResolution, List<PropertyHolder[]> propertyHolderCollections)
|
|
{
|
|
string json;
|
|
string checkFile;
|
|
string directory;
|
|
Shared.Models.Person person;
|
|
List<string> checkDirectories = new();
|
|
List<Shared.Models.Properties.IFace> collection;
|
|
const string pattern = @"[\\,\/,\:,\*,\?,\"",\<,\>,\|]";
|
|
string eDistanceCollectionDirectory = Path.Combine(Property.Models.Stateless.IResult.GetResultsFullGroupDirectory(configuration, model, predictorModel, nameof(E_Distance), outputResolution, includeResizeGroup: true, includeModel: true, includePredictorModel: true), "[_]");
|
|
Dictionary<string, List<(string directory, string personKey, D_Face face)>> keyValuePairs = Convert(argZero, propertyHolderCollections);
|
|
foreach (KeyValuePair<string, List<(string directory, string personKey, D_Face face)>> keyValuePair in keyValuePairs)
|
|
{
|
|
collection = new();
|
|
checkDirectories.Clear();
|
|
checkFile = string.Empty;
|
|
foreach ((string _, string personKey, D_Face face) in keyValuePair.Value)
|
|
{
|
|
if (string.IsNullOrEmpty(personKey) || !peopleCollection.ContainsKey(personKey))
|
|
continue;
|
|
person = peopleCollection[personKey][0];
|
|
directory = Path.Combine(eDistanceCollectionDirectory, $"{personKey}{keyValuePair.Key}");
|
|
checkFile = Path.Combine(directory, Regex.Replace($"{Shared.Models.Stateless.Methods.IPersonName.GetFullName(person.Name)}.json", pattern, string.Empty));
|
|
checkDirectories.Add(directory);
|
|
collection.Add(face);
|
|
}
|
|
if (!string.IsNullOrEmpty(checkFile) && checkDirectories.Any())
|
|
{
|
|
foreach (string checkDirectory in checkDirectories)
|
|
{
|
|
if (!Directory.Exists(checkDirectory))
|
|
_ = Directory.CreateDirectory(checkDirectory);
|
|
}
|
|
json = JsonSerializer.Serialize(collection, new JsonSerializerOptions { WriteIndented = true });
|
|
_ = Property.Models.Stateless.IPath.WriteAllText(checkFile, json, compareBeforeWrite: true);
|
|
}
|
|
}
|
|
}
|
|
|
|
} |