Moved face area and confidence to before sorting

Distance/Models/DistanceLimits.cs

@@ -5,10 +5,8 @@ namespace View_by_Distance.Distance.Models;
 public class DistanceLimits : IDistanceLimits
 {
 
-    private int _Area;
     private int _Days;
     private int _Distance;
-    private int _Confidence;
 
     public double FaceAreaPermyriad { init; get; }
     public double RangeDaysDeltaTolerance { init; get; }
@@ -50,8 +48,6 @@ public class DistanceLimits : IDistanceLimits
         string result;
         List<(int Value, string Name)> results = new()
         {
-            new(_Area, nameof(_Area)),
-            new(_Confidence, nameof(_Confidence)),
             new(_Days, nameof(_Days)),
             new(_Distance, nameof(_Distance))
         };
@@ -59,12 +55,10 @@ public class DistanceLimits : IDistanceLimits
         return result;
     }
 
-    void IDistanceLimits.AddCounts(int area, int days, int distance, int confidence)
+    void IDistanceLimits.AddCounts(int days, int distance)
     {
-        _Area += area;
         _Days += days;
         _Distance += distance;
-        _Confidence += confidence;
     }
 
 }

Distance/Models/_E_Distance.cs

@@ -400,7 +400,7 @@ public partial class E_Distance
     {
         List<SortingContainer> results = new();
         SortingContainer sortingContainer;
-        int area = 0, days = 0, distance = 0, confidence = 0;
+        int days = 0, distance = 0;
         Sorting[] collection = Shared.Models.Stateless.Methods.ISorting.Sort(sortingCollection);
         foreach (Sorting sorting in collection)
         {
@@ -418,22 +418,12 @@ public partial class E_Distance
                 distance += 1;
                 continue;
             }
-            if (face.Mapping.MappingFromLocation.ConfidencePercent < distanceLimits.FaceConfidencePercent)
-            {
-                confidence += 1;
-                continue;
-            }
-            if (face.Mapping.MappingFromLocation.AreaPermyriad < distanceLimits.FaceAreaPermyriad)
-            {
-                area += 1;
-                continue;
-            }
             sortingContainer = new(face.Mapping, sorting);
             results.Add(sortingContainer);
             if (results.Count >= distanceLimits.SortingMaximumPerFaceShouldBeHigh)
                 break;
         }
-        distanceLimits.AddCounts(area, days, distance, confidence);
+        distanceLimits.AddCounts(days, distance);
         return results;
     }
 
@@ -483,13 +473,17 @@ public partial class E_Distance
         return faceDistanceEncodings;
     }
 
-    public static FaceDistanceContainer[] FilteredFaceDistanceContainers(Map.Models.MapLogic mapLogic, FaceDistanceContainer[] faceDistanceContainers)
+    public static FaceDistanceContainer[] FilteredFaceDistanceContainers(Map.Models.MapLogic mapLogic, FaceDistanceContainer[] faceDistanceContainers, DistanceLimits distanceLimits)
     {
         List<FaceDistanceContainer> results = new();
         foreach (FaceDistanceContainer faceDistanceContainer in faceDistanceContainers)
         {
             if (faceDistanceContainer.FaceDistance is null || faceDistanceContainer.Face.Mapping?.MappingFromLocation is null)
                 throw new NotSupportedException();
+            if (faceDistanceContainer.Face.Mapping.MappingFromLocation.ConfidencePercent < distanceLimits.FaceConfidencePercent)
+                continue;
+            if (faceDistanceContainer.Face.Mapping.MappingFromLocation.AreaPermyriad < distanceLimits.FaceAreaPermyriad)
+                continue;
             if (faceDistanceContainer.Face.Mapping.MappingFromFilter.IsFocusModel is not null && !faceDistanceContainer.Face.Mapping.MappingFromFilter.IsFocusModel.Value)
                 continue;
             if (faceDistanceContainer.Face.Mapping.MappingFromFilter.IsFocusRelativePath is not null && !faceDistanceContainer.Face.Mapping.MappingFromFilter.IsFocusRelativePath.Value)

Instance/DlibDotNet.cs

@@ -724,47 +724,56 @@ public partial class DlibDotNet
         return items;
     }
 
-    private void SaveFaceDistances(long ticks, MapLogic mapLogic, Mapping[] mappingCollection, string dFacesContentDirectory, string d2FacePartsContentDirectory, Dictionary<int, Dictionary<int, Mapping>> idToNormalizedRectangleToMapping, List<FaceDistance> faceDistanceEncodings, FaceDistanceContainer[] filteredFaceDistanceContainers)
+    private void SaveFaceDistances(long ticks, MapLogic mapLogic, Mapping[] mappingCollection, string dFacesContentDirectory, string d2FacePartsContentDirectory, Dictionary<int, Dictionary<int, Mapping>> idToNormalizedRectangleToMapping, List<FaceDistance> faceDistanceEncodings, FaceDistanceContainer[] faceDistanceContainers)
     {
+        if (_Log is null)
+            throw new NullReferenceException(nameof(_Log));
         DistanceLimits distanceLimits;
         int? useFiltersCounter = null;
         SortingContainer[] sortingContainers;
+        FaceDistanceContainer[] filteredFaceDistanceContainers;
         distanceLimits = new(_Configuration.FaceAreaPermyriad, _Configuration.FaceConfidencePercent, _Configuration.FaceDistancePermyriad, _Configuration.RangeDaysDeltaTolerance, _Configuration.RangeDistanceTolerance, _Configuration.RangeFaceAreaTolerance, _Configuration.RangeFaceConfidence, _Configuration.SortingMaximumPerFaceShouldBeHigh);
-        sortingContainers = E_Distance.SetFaceMappingSortingCollectionThenGetSortingContainers(_AppSettings.MaxDegreeOfParallelism, _MapConfiguration, ticks, mapLogic, distanceLimits, faceDistanceEncodings, filteredFaceDistanceContainers);
+        filteredFaceDistanceContainers = E_Distance.FilteredFaceDistanceContainers(mapLogic, faceDistanceContainers, distanceLimits);
-        if (!sortingContainers.Any())
+        if (!filteredFaceDistanceContainers.Any())
+            _Log.Information("All images have been filtered!");
+        else
         {
-            for (useFiltersCounter = 1; useFiltersCounter < _Configuration.UseFilterTries; useFiltersCounter++)
+            sortingContainers = E_Distance.SetFaceMappingSortingCollectionThenGetSortingContainers(_AppSettings.MaxDegreeOfParallelism, _MapConfiguration, ticks, mapLogic, distanceLimits, faceDistanceEncodings, filteredFaceDistanceContainers);
+            if (!sortingContainers.Any())
             {
-                distanceLimits = new(_Configuration.FaceAreaPermyriad, _Configuration.FaceConfidencePercent, _Configuration.FaceDistancePermyriad, _Configuration.RangeDaysDeltaTolerance, _Configuration.RangeDistanceTolerance, _Configuration.RangeFaceAreaTolerance, _Configuration.RangeFaceConfidence, _Configuration.SortingMaximumPerFaceShouldBeHigh, useFiltersCounter);
+                for (useFiltersCounter = 1; useFiltersCounter < _Configuration.UseFilterTries; useFiltersCounter++)
-                sortingContainers = E_Distance.SetFaceMappingSortingCollectionThenGetSortingContainers(_AppSettings.MaxDegreeOfParallelism, _MapConfiguration, ticks, mapLogic, distanceLimits, faceDistanceEncodings, filteredFaceDistanceContainers);
+                {
-                if (sortingContainers.Any())
+                    distanceLimits = new(_Configuration.FaceAreaPermyriad, _Configuration.FaceConfidencePercent, _Configuration.FaceDistancePermyriad, _Configuration.RangeDaysDeltaTolerance, _Configuration.RangeDistanceTolerance, _Configuration.RangeFaceAreaTolerance, _Configuration.RangeFaceConfidence, _Configuration.SortingMaximumPerFaceShouldBeHigh, useFiltersCounter);
-                    break;
+                    filteredFaceDistanceContainers = E_Distance.FilteredFaceDistanceContainers(mapLogic, faceDistanceContainers, distanceLimits);
+                    if (filteredFaceDistanceContainers.Any())
+                        _Log.Information("All images have been filtered!");
+                    else
+                    {
+                        sortingContainers = E_Distance.SetFaceMappingSortingCollectionThenGetSortingContainers(_AppSettings.MaxDegreeOfParallelism, _MapConfiguration, ticks, mapLogic, distanceLimits, faceDistanceEncodings, filteredFaceDistanceContainers);
+                        if (sortingContainers.Any())
+                            break;
+                    }
+                }
+            }
+            E_Distance.SaveFaceDistances(_Configuration.PropertyConfiguration, sortingContainers);
+            if (filteredFaceDistanceContainers.Length > 0)
+            {
+                int updated = mapLogic.UpdateFromSortingContainers(distanceLimits, sortingContainers);
+                List<SaveContainer> saveContainers = mapLogic.GetSaveContainers(dFacesContentDirectory, d2FacePartsContentDirectory, mappingCollection, idToNormalizedRectangleToMapping, useFiltersCounter, sortingContainers.Any());
+                mapLogic.SaveContainers(filteredFaceDistanceContainers.Length, updated, saveContainers);
             }
-        }
-        E_Distance.SaveFaceDistances(_Configuration.PropertyConfiguration, sortingContainers);
-        if (filteredFaceDistanceContainers.Length > 0)
-        {
-            int updated = mapLogic.UpdateFromSortingContainers(distanceLimits, sortingContainers);
-            List<SaveContainer> saveContainers = mapLogic.GetSaveContainers(dFacesContentDirectory, d2FacePartsContentDirectory, mappingCollection, idToNormalizedRectangleToMapping, useFiltersCounter, sortingContainers.Any());
-            mapLogic.SaveContainers(filteredFaceDistanceContainers.Length, updated, saveContainers);
         }
     }
 
     private void SaveFaceDistances(long ticks, MapLogic mapLogic, List<Shared.Models.Face> distinctFilteredFaces, Mapping[] mappingCollection, string dFacesContentDirectory, string d2FacePartsContentDirectory, string dFacesCollectionDirectory, Dictionary<int, Dictionary<int, Mapping>> idToNormalizedRectangleToMapping)
     {
-        if (_Log is null)
-            throw new NullReferenceException(nameof(_Log));
         E_Distance.SetFaceDistances(_AppSettings.MaxDegreeOfParallelism, ticks, distinctFilteredFaces);
         FaceDistanceContainer[] faceDistanceContainers = E_Distance.GetFaceDistanceContainers(distinctFilteredFaces);
         Dictionary<int, Dictionary<int, PersonContainer[]>> missingIdThenNormalizedRectangleToPersonContainers = mapLogic.GetMissing(idToNormalizedRectangleToMapping);
         List<FaceDistanceContainer> missingFaceDistanceContainers = _Distance.GetMissingFaceDistanceContainer(_AppSettings.MaxDegreeOfParallelism, ticks, dFacesCollectionDirectory, missingIdThenNormalizedRectangleToPersonContainers);
         List<FaceDistance> faceDistanceEncodings = E_Distance.GetFaceDistanceEncodings(faceDistanceContainers, missingFaceDistanceContainers);
-        FaceDistanceContainer[] filteredFaceDistanceContainers = E_Distance.FilteredFaceDistanceContainers(mapLogic, faceDistanceContainers);
+        if (faceDistanceContainers.Any())
-        int totalNotMappedAfterFiltered = filteredFaceDistanceContainers.Length;
+            SaveFaceDistances(ticks, mapLogic, mappingCollection, dFacesContentDirectory, d2FacePartsContentDirectory, idToNormalizedRectangleToMapping, faceDistanceEncodings, faceDistanceContainers);
-        if (totalNotMappedAfterFiltered == 0)
-            _Log.Information("All images have been filtered!");
-        else
-            SaveFaceDistances(ticks, mapLogic, mappingCollection, dFacesContentDirectory, d2FacePartsContentDirectory, idToNormalizedRectangleToMapping, faceDistanceEncodings, filteredFaceDistanceContainers);
     }
 
     private void MapLogic(string argZero, long ticks, Container[] containers, string a2PeopleSingletonDirectory, string dResultsFullGroupDirectory, string d2ResultsFullGroupDirectory, string fPhotoPrismContentDirectory, MapLogic mapLogic, string outputResolution, Dictionary<long, List<int>> personKeyToIds, List<Shared.Models.Face> distinctFilteredFaces, Mapping[] mappingCollection, int totalNotMapped)

Shared/Models/Methods/IDistanceLimits.cs

@@ -11,6 +11,6 @@ public interface IDistanceLimits
     public bool RangeDaysDeltaTargetLessThenUpper { init; get; }
 
     string GetCounts();
-    void AddCounts(int area, int days, int distance, int confidence);
+    void AddCounts(int days, int distance);
 
 }