Test infrastructure for prioritized-HD-HumanFace visitor prepared

Comparison/src/test/java/cz/fidentis/analyst/visitors/face/HausdorffDistancePrioritizedTest.java

+package cz.fidentis.analyst.visitors.face;
+
+import cz.fidentis.analyst.face.HumanFace;
+import cz.fidentis.analyst.feature.FeaturePoint;
+import cz.fidentis.analyst.feature.FeaturePointType;
+import cz.fidentis.analyst.mesh.core.MeshFacet;
+import cz.fidentis.analyst.mesh.core.MeshModel;
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import javax.vecmath.Point3d;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class HausdorffDistancePrioritizedTest {
+    
+    private static final double DELTA = 1e-11;
+    private static final File BOY = new File("src/test/resources/cz/fidentis/analyst/average_boy_17-20.obj");
+    
+    private static HumanFace getHumanFace(List<MeshFacet> facets,
+            List<Point3d> featurePoints,
+            List<FeaturePointType> featurePointTypes) throws IOException {
+        
+        assertEquals(featurePoints.size(), featurePointTypes.size());
+        
+        final HumanFace face = new HumanFace(BOY);
+        
+        final MeshModel model = new MeshModel();
+        for (final MeshFacet facet: facets) {
+            model.addFacet(facet);
+        }
+        face.setMeshModel(model);
+        
+        final List<FeaturePoint> featurePointsList = new ArrayList<>();
+        for (int i = 0; i < featurePoints.size(); i++) {
+            final Point3d fpCoordinates = featurePoints.get(i);
+            featurePointsList.add(new FeaturePoint(
+                    fpCoordinates.x,
+                    fpCoordinates.y,
+                    fpCoordinates.z,
+                    featurePointTypes.get(i)));
+        }
+        face.setFeaturePoints(featurePointsList);
+        
+        return face;
+    }
+    
+    protected void performTest(HumanFace face,
+            Map<FeaturePointType, Map<MeshFacet, List<Double>>> expectedPriorities,
+            Map<FeaturePointType, Map<MeshFacet, Double>> expectedFeaturePointWeights,
+            Map<MeshFacet, List<Double>> expectedMergedPriorities,
+            HausdorffDistancePrioritized visitor) {
+        
+        final Set<FeaturePointType> featurePointTypes = visitor.getFeaturePointTypes();
+        final List<FeaturePoint> faceFeaturePoints = face.getFeaturePoints();
+        featurePointTypes.forEach(fpType -> assertTrue(faceFeaturePoints.stream()
+                .anyMatch(fPoint -> fPoint.getFeaturePointType().equals(fpType))));
+                
+        face.accept(visitor);
+        
+        final List<MeshFacet> faceFacets = face.getMeshModel().getFacets();
+        
+        // ---------------------------------------------------------------------
+        // Test priorities
+        // ---------------------------------------------------------------------
+        final Map<HumanFace, Map<FeaturePointType, Map<MeshFacet, List<Double>>>> priorities =
+                visitor.getPriorities();
+        assertTrue(priorities.containsKey(face));
+        final Map<FeaturePointType, Map<MeshFacet, List<Double>>> facePriorities =
+                priorities.get(face);
+        assertEquals(featurePointTypes.size(), facePriorities.size());
+        
+        for (final FeaturePointType fpType: featurePointTypes) {
+            assertTrue(facePriorities.containsKey(fpType));
+            
+            final Map<MeshFacet, List<Double>> facePrioritiesMap = facePriorities.get(fpType);
+            final Map<MeshFacet, List<Double>> expectedPrioritiesMap = expectedPriorities.get(fpType);
+            assertEquals(faceFacets.size(), facePrioritiesMap.size());
+            
+            for (final MeshFacet facet: faceFacets) {
+                assertTrue(facePrioritiesMap.containsKey(facet));
+                
+                final List<Double> facePrioritiesList = facePrioritiesMap.get(facet);
+                final List<Double> expectedPrioritiesList = expectedPrioritiesMap.get(facet);
+                assertEquals(expectedPrioritiesList.size(), facePrioritiesList.size());
+                
+                for (int i = 0; i < expectedPrioritiesList.size(); i++) {
+                    assertEquals(expectedPrioritiesList.get(i), facePrioritiesList.get(i), DELTA);
+                }
+            }
+        }
+        
+        // ---------------------------------------------------------------------
+        // Test feature point weights
+        // ---------------------------------------------------------------------
+        final Map<HumanFace, Map<FeaturePointType, Map<MeshFacet, Double>>> featurePointWeights =
+                visitor.getFeaturePointWeights();
+        assertTrue(featurePointWeights.containsKey(face));
+        final Map<FeaturePointType, Map<MeshFacet, Double>> faceFeaturePointWeights =
+                featurePointWeights.get(face);
+        assertEquals(featurePointTypes.size(), faceFeaturePointWeights.size());
+        
+        for (final FeaturePointType fpType: featurePointTypes) {
+            assertTrue(faceFeaturePointWeights.containsKey(fpType));
+            
+            final Map<MeshFacet, Double> faceFPWeightsMap = faceFeaturePointWeights.get(fpType);
+            final Map<MeshFacet, Double> expectedFPWeightsMap = expectedFeaturePointWeights.get(fpType);
+            assertEquals(faceFacets.size(), faceFPWeightsMap.size());
+            
+            for (final MeshFacet facet: faceFacets) {
+                assertTrue(faceFPWeightsMap.containsKey(facet));
+                
+                final double expectedWeightedDistance = expectedFPWeightsMap.get(facet);
+                final double actualWeightedDistance = faceFPWeightsMap.get(facet);
+                assertEquals(expectedWeightedDistance, actualWeightedDistance, DELTA);
+            }
+        }
+        
+        // ---------------------------------------------------------------------
+        // Test merged priorities
+        // ---------------------------------------------------------------------
+        final Map<HumanFace, Map<MeshFacet, List<Double>>> mergedPriorities =
+                visitor.getMergedPriorities();
+        assertTrue(mergedPriorities.containsKey(face));
+        final Map<MeshFacet, List<Double>> faceMergedPriorities =
+                mergedPriorities.get(face);
+        assertEquals(faceFacets.size(), faceMergedPriorities.size());
+        
+        for (final MeshFacet facet: faceFacets) {
+            assertTrue(faceMergedPriorities.containsKey(facet));
+            
+            final List<Double> faceMergedPrioritiesList = faceMergedPriorities.get(facet);
+            final List<Double> expectedMergedPrioritiesList = expectedMergedPriorities.get(facet);
+            assertEquals(expectedMergedPrioritiesList.size(), faceMergedPrioritiesList.size());
+            
+            for (int i = 0; i < expectedMergedPrioritiesList.size(); i++) {
+                assertEquals(expectedMergedPrioritiesList.get(i), faceMergedPrioritiesList.get(i), DELTA);
+            }
+        }
+    }
+    
+}