Constructor adapted to accept set of feature point types

Comparison/src/main/java/cz/fidentis/analyst/visitors/face/HausdorffDistancePrioritized.java

@@ -41,7 +41,7 @@ public class HausdorffDistancePrioritized extends HumanFaceVisitor  {
     
     private final HausdorffDistance distanceVisitor;
     
-    private final FeaturePointType featurePointType;
+    private final Set<FeaturePointType> featurePointTypes;
     
     private final Map<MeshFacet, List<Double>> priorities = new HashMap<>();
     
@@ -50,7 +50,8 @@ public class HausdorffDistancePrioritized extends HumanFaceVisitor  {
      * 
      * @param mainFacets Facets to which distance from the visited human face's facets is to be computed.
      * Must not be {@code null}.
-     * @param featurePoint Feature point according to which the Hausdorff distances will be prioritized
+     * @param featurePoints Feature points according to which the Hausdorff distances will be prioritized.
+     * Must not be {@code null}.
      * @param strategy Strategy of the computation of distance
      * @param relativeDistance If {@code true}, then the visitor calculates the relative distances with respect 
      * to the normal vectors of source facets (normal vectors have to present),
@@ -58,16 +59,20 @@ public class HausdorffDistancePrioritized extends HumanFaceVisitor  {
      * @param parallel If {@code true}, then the algorithm runs concurrently utilizing all CPU cores
      * @throws IllegalArgumentException if some parameter is wrong
      */
-    public HausdorffDistancePrioritized(Set<MeshFacet> mainFacets, FeaturePointType featurePoint, Strategy strategy, boolean relativeDistance, boolean parallel) {
+    public HausdorffDistancePrioritized(Set<MeshFacet> mainFacets, Set<FeaturePointType> featurePoints, Strategy strategy, boolean relativeDistance, boolean parallel) {
         distanceVisitor = new HausdorffDistance(mainFacets, strategy, relativeDistance, parallel);
-        featurePointType = featurePoint;
+        if (featurePoints == null) {
+            throw new IllegalArgumentException("featurePoints");
+        }
+        featurePointTypes = featurePoints;
     }
     
     /**
      * Constructor.
      * 
      * @param mainFacet Primary facet to which distance from the visited human face's facets is to be computed. Must not be {@code null}.
-     * @param featurePoint Feature point according to which the Hausdorff distances will be prioritized
+     * @param featurePoints Feature points according to which the Hausdorff distances will be prioritized.
+     * Must not be {@code null}.
      * @param strategy Strategy of the computation of distance
      * @param relativeDistance If {@code true}, then the visitor calculates the relative distances with respect 
      * to the normal vectors of source facets (normal vectors have to present),
@@ -75,8 +80,8 @@ public class HausdorffDistancePrioritized extends HumanFaceVisitor  {
      * @param parallel If {@code true}, then the algorithm runs concurrently utilizing all CPU cores
      * @throws IllegalArgumentException if some parameter is wrong
      */
-    public HausdorffDistancePrioritized(MeshFacet mainFacet, FeaturePointType featurePoint, Strategy strategy, boolean relativeDistance, boolean parallel) {
-        this(new HashSet<>(Collections.singleton(mainFacet)), featurePoint, strategy, relativeDistance, parallel);
+    public HausdorffDistancePrioritized(MeshFacet mainFacet, Set<FeaturePointType> featurePoints, Strategy strategy, boolean relativeDistance, boolean parallel) {
+        this(new HashSet<>(Collections.singleton(mainFacet)), featurePoints, strategy, relativeDistance, parallel);
     }
     
     /**
@@ -84,7 +89,8 @@ public class HausdorffDistancePrioritized extends HumanFaceVisitor  {
      * 
      * @param mainModel The mesh model with primary facets to which distance from the visited human face's facets is to be computed.
      * Must not be {@code null} or empty.
-     * @param featurePoint Feature point according to which the Hausdorff distances will be prioritized
+     * @param featurePoints Feature points according to which the Hausdorff distances will be prioritized.
+     * Must not be {@code null}.
      * @param strategy Strategy of the computation of distance
      * @param relativeDistance If {@code true}, then the visitor calculates the relative distances with respect 
      * to the normal vectors of source facets (normal vectors have to present),
@@ -92,15 +98,16 @@ public class HausdorffDistancePrioritized extends HumanFaceVisitor  {
      * @param parallel If {@code true}, then the algorithm runs concurrently utilizing all CPU cores
      * @throws IllegalArgumentException if some parameter is wrong
      */
-    public HausdorffDistancePrioritized(MeshModel mainModel, FeaturePointType featurePoint, Strategy strategy, boolean relativeDistance, boolean parallel) {
-        this(new HashSet<>(mainModel.getFacets()), featurePoint, strategy, relativeDistance, parallel);
+    public HausdorffDistancePrioritized(MeshModel mainModel, Set<FeaturePointType> featurePoints, Strategy strategy, boolean relativeDistance, boolean parallel) {
+        this(new HashSet<>(mainModel.getFacets()), featurePoints, strategy, relativeDistance, parallel);
     }
     
     /**
      * Constructor.
      * 
      * @param face Human face to which distance from other human faces is to be computed. Must not be {@code null}.
-     * @param featurePoint Feature point according to which the Hausdorff distances will be prioritized
+     * @param featurePoints Feature points according to which the Hausdorff distances will be prioritized.
+     * Must not be {@code null}.
      * @param strategy Strategy of the computation of distance
      * @param relativeDistance If {@code true}, then the visitor calculates the relative distances with respect 
      * to the normal vectors of source facets (normal vectors have to present),
@@ -108,8 +115,8 @@ public class HausdorffDistancePrioritized extends HumanFaceVisitor  {
      * @param parallel If {@code true}, then the algorithm runs concurrently utilizing all CPU cores
      * @throws IllegalArgumentException if some parameter is wrong
      */
-    public HausdorffDistancePrioritized(HumanFace face, FeaturePointType featurePoint, Strategy strategy, boolean relativeDistance, boolean parallel) {
-        this(face.getMeshModel(), featurePoint, strategy, relativeDistance, parallel);
+    public HausdorffDistancePrioritized(HumanFace face, Set<FeaturePointType> featurePoints, Strategy strategy, boolean relativeDistance, boolean parallel) {
+        this(face.getMeshModel(), featurePoints, strategy, relativeDistance, parallel);
     }
     
     /**
@@ -117,7 +124,8 @@ public class HausdorffDistancePrioritized extends HumanFaceVisitor  {
      * 
      * @param mainKdTree The KD tree to which distance from the visited human face's facets is to be computed.
      * Must not be {@code null}.
-     * @param featurePoint Feature point according to which the Hausdorff distances will be prioritized
+     * @param featurePoints Feature points according to which the Hausdorff distances will be prioritized.
+     * Must not be {@code null}.
      * @param strategy Strategy of the computation of distance
      * @param relativeDistance If {@code true}, then the visitor calculates the relative distances with respect 
      * to the normal vectors of source facets (normal vectors have to present),
@@ -125,13 +133,16 @@ public class HausdorffDistancePrioritized extends HumanFaceVisitor  {
      * @param parallel If {@code true}, then the algorithm runs concurrently utilizing all CPU cores
      * @throws IllegalArgumentException if some parameter is wrong
      */
-    public HausdorffDistancePrioritized(KdTree mainKdTree, FeaturePointType featurePoint, Strategy strategy, boolean relativeDistance, boolean parallel) {
+    public HausdorffDistancePrioritized(KdTree mainKdTree, Set<FeaturePointType> featurePoints, Strategy strategy, boolean relativeDistance, boolean parallel) {
         distanceVisitor = new HausdorffDistance(mainKdTree, strategy, relativeDistance, parallel);
-        featurePointType = featurePoint;
+        if (featurePoints == null) {
+            throw new IllegalArgumentException("featurePoints");
+        }
+        featurePointTypes = featurePoints;
     }
 
-    public FeaturePointType getFeaturePointType() {
-        return featurePointType;
+    public Set<FeaturePointType> getFeaturePointTypes() {
+        return Collections.unmodifiableSet(featurePointTypes);
     }
     
     /**
@@ -220,23 +231,27 @@ public class HausdorffDistancePrioritized extends HumanFaceVisitor  {
 
     @Override
     public void visitHumanFace(HumanFace humanFace) {
-        humanFace.getMeshModel().compute(distanceVisitor, inParallel());
-        
-        final FeaturePoint featurePoint = humanFace.getFeaturePoints().get(featurePointType.getType());
-        final PrioritySphere priorityVisitor = new PrioritySphere(featurePoint.getPosition(), computeSphereRadius(humanFace));
-        humanFace.getMeshModel().compute(priorityVisitor, inParallel());
-        
-        synchronized(this) {
-            // Retrieve results from the visitor's internal structure
-            priorities.putAll(priorityVisitor.getPriorities());
-        }
+        throw new UnsupportedOperationException();
+//        TODO TEMPORARY BEGIN
+//        Needs to be updated for multiple feature points
+//        humanFace.getMeshModel().compute(distanceVisitor, inParallel());
+//        
+//        final FeaturePoint featurePoint = humanFace.getFeaturePoints().get(featurePointTypes.getType());
+//        final PrioritySphere priorityVisitor = new PrioritySphere(featurePoint.getPosition(), computeSphereRadius(humanFace));
+//        humanFace.getMeshModel().compute(priorityVisitor, inParallel());
+//        
+//        synchronized(this) {
+//            // Retrieve results from the visitor's internal structure
+//            priorities.putAll(priorityVisitor.getPriorities());
+//        }
+//        TODO TEMPORARY END
     }
     
     private double computeSphereRadius(HumanFace humanFace) {
-        // TODO TEMPORARY
+        // TODO TEMPORARY BEGIN
         // Sphere radius needs to be computed dynamically.
         // The best way to compute the right radius should be thought out in more depth.
         return 1;
-        // TODO TEMPORARY
+        // TODO TEMPORARY END
     }
 }