diff --git a/Comparison/src/main/java/cz/fidentis/analyst/visitors/face/HausdorffDistancePrioritized.java b/Comparison/src/main/java/cz/fidentis/analyst/visitors/face/HausdorffDistancePrioritized.java
index 4402d79bc6c8b6a203563fcb75206e924390ac1e..1d2ccb68250f1d628c034be348ed6529a64d7855 100644
--- a/Comparison/src/main/java/cz/fidentis/analyst/visitors/face/HausdorffDistancePrioritized.java
+++ b/Comparison/src/main/java/cz/fidentis/analyst/visitors/face/HausdorffDistancePrioritized.java
@@ -29,23 +29,25 @@ import javax.vecmath.Point3d;
* points separately</li>
* <li>Priorities of the faces' vertices with respect to all the given types
* of feature points merged together</li>
- * <li>Average weighted Hausdorff distance with respect to the given types of feature
- * points for each of the faces' mesh facets</li>
+ * <li>Weighted average of Hausdorff distance of all vertices within the priority sphere
+ * of feature points of the given types for each of the faces' mesh facets</li>
* </ul>
* This visitor is instantiated with a single k-d tree (either given as the input
* parameter, or automatically created from the triangular mesh).
* When applied to other human faces, it computes the Hausdorff distance from their mesh facets
* to the instantiated k-d tree.
+ *
* <p>
- * The Hausdorff distance is computed either as absolute or relative. Absolute
- * represents Euclidean distance (all numbers are positive). On the contrary,
- * relative distance considers orientation of the visited face's facets (determined by its normal vectors)
- * and produces positive or negative distances depending on whether the primary
- * mesh is "in front of" or "behind" the given vertex.
+ * The Hausdorff distance is computed either as absolute or relative. Absolute
+ * represents Euclidean distance (all numbers are positive). On the contrary,
+ * relative distance considers orientation of the visited face's facets (determined by its normal vectors)
+ * and produces positive or negative distances depending on whether the primary
+ * mesh is "in front of" or "behind" the given vertex.
* </p>
+ *
* <p>
- * This visitor is thread-safe, i.e., a single instance of the visitor can be used
- * to inspect multiple human faces simultaneously.
+ * This visitor is thread-safe, i.e., a single instance of the visitor can be used
+ * to inspect multiple human faces simultaneously.
* </p>
*
* @author Daniel Schramm
@@ -187,12 +189,14 @@ public class HausdorffDistancePrioritized extends HumanFaceVisitor {
/**
* Returns Hausdorff distance of the visited faces' mesh facets to the source mesh facets.
*
+ * <p>
* Keys in the map contain mesh facets that were measured with the
- * source facets.
+ * source facets.<br>
* For each facet of the visited human face, a list of distances to the source
* facets is stored. The order of distances corresponds to the order of vertices
* in the measured facet, i.e., the i-th value is the distance of the i-th vertex
* of the visited face's facet.
+ * </p>
*
* @return Hausdorff distance for all points of all the visited human faces' facets
*/
@@ -203,12 +207,14 @@ public class HausdorffDistancePrioritized extends HumanFaceVisitor {
/**
* Returns the nearest points of the visited faces' mesh facets to the source mesh facets.
*
+ * <p>
* Keys in the map contain mesh facets that were measured with the
- * source facets.
+ * source facets.<br>
* For each facet of the visited human face, a list of the nearest points to the source
* facets is stored. The order of points corresponds to the order of vertices
* in the measured facet, i.e., the i-th point is the nearest point of the i-th vertex
* of the visited face's facet.
+ * </p>
*
* @return The nearest points for all points of all the visited human faces' facets
*/
@@ -221,15 +227,17 @@ public class HausdorffDistancePrioritized extends HumanFaceVisitor {
* to the given types of feature points.
* Priorities are calculated for each type of feature point separately.
*
+ * <p>
* Keys in the map contain human faces whose mesh facets were measured with the
- * source facets.
- * For each human face, there is a map of examined types of feature points.
+ * source facets.<br>
+ * For each human face, there is a map of examined types of feature points.<br>
* Each feature point type then stores a map of priorities of vertices
* of the face's mesh facets computed with respect to the face's feature point of
* the corresponding type.
* The order of priorities in the innermost map's value (list) corresponds to the order of vertices
* in its corresponding key (facet), i.e., the i-th value in the list is the priority of
* the i-th vertex of the facet.
+ * </p>
*
* @return Priorities of vertices with respect to the given types of feature points
*/
@@ -238,24 +246,26 @@ public class HausdorffDistancePrioritized extends HumanFaceVisitor {
}
/**
- * For all visited faces' mesh facets, the method returns the average weighted Hausdorff distance
- * with respect to the given types of feature points (i.e. the sum of weighted distances
- * of the mesh facet's vertices to the source facets divided by the number of vertices
- * located within the feature point's priority sphere).
- * The average weighted distances are calculated for each type of feature point separately.
+ * For all visited faces' mesh facets, the method returns the weighted average of Hausdorff distance
+ * of all vertices within the priority sphere of feature points of the given types
+ * (i.e. the sum of weighted distances of the mesh facet's vertices to the source facets
+ * divided by the sum of their priorities).
+ * The weighted average is calculated for each type of feature point separately.
*
+ * <p>
* Keys in the map contain human faces whose mesh facets were measured with the
- * source facets.
- * For each human face, there is a map of examined types of feature points.
+ * source facets.<br>
+ * For each human face, there is a map of examined types of feature points.<br>
* Each feature point type then stores a map of the face's mesh facets together with
- * the average weighted distances of their vertices to the source facets.
- * The average weighted distances are calculated with respect to the face's feature point
- * of the corresponding type.
+ * the weighted average of distance of their vertices to the source facets.
+ * The weighted average of distance is calculated with respect to the face's feature point
+ * of the corresponding type.<br>
* <i>If there is no vertex within the priority sphere of a feature point,
- * the value of the average weighted Hausdorff distance is {@link Double#NaN}</i>
+ * the value of the average weighted Hausdorff distance is {@link Double#NaN}</i>
+ * </p>
*
- * @return Average weighted Hausdorff distances with respect to the given types
- * of feature points
+ * @return Weighted average of Hausdorff distance of all vertices within the priority sphere
+ * of feature points of the given types
*/
public Map<HumanFace, Map<FeaturePointType, Map<MeshFacet, Double>>> getFeaturePointWeights() {
return Collections.unmodifiableMap(featurePointWeights);
@@ -265,14 +275,16 @@ public class HausdorffDistancePrioritized extends HumanFaceVisitor {
* Returns priorities of vertices of the visited faces' mesh facets with respect
* to all the given types of feature points merged together.
*
+ * <p>
* Keys in the map contain human faces whose mesh facets were measured with the
- * source facets.
+ * source facets.<br>
* For each human face, there is a map of priorities of vertices of the visited
* face's mesh facets. The priorities are computed with respect to all the face's
* feature points of given types together.
* The order of priorities in the inner map's value (list) corresponds to the order of vertices
* in its corresponding key (facet), i.e., the i-th value in the list is the priority of
* the i-th vertex of the facet.
+ * </p>
*
* @return Priorities of vertices with respect to all given types of feature
* points merged together
@@ -370,19 +382,24 @@ public class HausdorffDistancePrioritized extends HumanFaceVisitor {
synchronized (this) {
/*
- * Calculate the average weighted Hausdorff distance for the feature point.
+ * Calculate the weighted average of Hausdorff distance
+ * of all vertices within the feature point's priority sphere.
*/
final List<Double> facetDistances = hausdorffDistances.get(facet);
featurePointWeights.computeIfAbsent(humanFace, face -> new HashMap<>())
.computeIfAbsent(featurePointType, fPointType -> new HashMap<>())
.put(facet, IntStream.range(0, facetDistances.size())
.filter(i -> facetPriorities.get(i) > 0) // Filter out vertices that are outside of the priority sphere
- .mapToDouble(i -> facetDistances.get(i) * facetPriorities.get(i))
- .average()
- .orElse(Double.NaN)); // If there is no vertex in the priority sphere
+ .boxed()
+ .collect(WeightedAverageCollector.toWeightedAverage(
+ facetDistances::get,
+ facetPriorities::get
+ ))
+ );
/*
- * Merge priorities computed for the current feature point type with the priorities of already computed feature point types.
+ * Merge priorities computed for the current feature point type
+ * with the priorities of already computed feature point types.
*/
final List<Double> storedFacetPriorities = mergedPriorities
.computeIfAbsent(humanFace, face -> new HashMap<>())
diff --git a/Comparison/src/main/java/cz/fidentis/analyst/visitors/face/WeightedAverageCollector.java b/Comparison/src/main/java/cz/fidentis/analyst/visitors/face/WeightedAverageCollector.java
new file mode 100644
index 0000000000000000000000000000000000000000..f42241899438a6bec7f06a3148fa2c39c5e2035b
--- /dev/null
+++ b/Comparison/src/main/java/cz/fidentis/analyst/visitors/face/WeightedAverageCollector.java
@@ -0,0 +1,135 @@
+package cz.fidentis.analyst.visitors.face;
+
+import java.util.Set;
+import java.util.function.BiConsumer;
+import java.util.function.BinaryOperator;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.function.ToDoubleFunction;
+import java.util.stream.Collector;
+
+/**
+ * A collector for calculation of the weighted average, suitable for use in Java 8 streams.
+ *
+ * <p>
+ * A mutable reduction operation that accumulates input elements into a mutable
+ * result container, transforming the accumulated result into a final
+ * representation after all input elements have been processed.
+ * </p>
+ *
+ * @author Daniel Schramm
+ * @param <T> Data type of the stream elements
+ */
+public class WeightedAverageCollector<T> implements Collector<T, IntemediateResults, Double> {
+
+ private final ToDoubleFunction<? super T> valueFunction, weightFunction;
+
+ /**
+ * Constructor.
+ *
+ * @param valueFunction Function returning the value for a given stream element
+ * @param weightFunction Function returning the weight for a given stream element
+ */
+ public WeightedAverageCollector(
+ ToDoubleFunction<? super T> valueFunction,
+ ToDoubleFunction<? super T> weightFunction) {
+ this.valueFunction = valueFunction;
+ this.weightFunction = weightFunction;
+ }
+
+ /**
+ * Returns a {@link Collector} interface object used to compute the weighted average.
+ *
+ * @param <T> Data type of the stream elements
+ * @param valueFunction Function returning the value for a given stream element
+ * @param weightFunction Function returning the weight for a given stream element
+ * @return A Collector interface object used to compute the weighted average
+ */
+ public static <T> Collector<T, ?, Double> toWeightedAverage(
+ ToDoubleFunction<? super T> valueFunction,
+ ToDoubleFunction<? super T> weightFunction) {
+ return new WeightedAverageCollector(valueFunction, weightFunction);
+ }
+
+ /**
+ * A function that creates and returns a new mutable result container.
+ *
+ * @return A function which returns a new, mutable result container
+ */
+ @Override
+ public Supplier<IntemediateResults> supplier() {
+ return IntemediateResults::new;
+ }
+
+ /**
+ * A function that folds a value into a mutable result container.
+ *
+ * @return A function which folds a value into a mutable result container
+ */
+ @Override
+ public BiConsumer<IntemediateResults, T> accumulator() {
+ return (iResult, streamElement) -> {
+ iResult.weightedValSum += valueFunction.applyAsDouble(streamElement)
+ * weightFunction.applyAsDouble(streamElement);
+ iResult.weightSum += weightFunction.applyAsDouble(streamElement);
+ };
+ }
+
+ /**
+ * A function that accepts two partial results and merges them. The
+ * combiner function may fold state from one argument into the other and
+ * return that, or may return a new result container.
+ *
+ * @return A function which combines two partial results into a combined
+ * result
+ */
+ @Override
+ public BinaryOperator<IntemediateResults> combiner() {
+ return (iResult1, iResult2) -> {
+ iResult1.weightedValSum += iResult2.weightedValSum;
+ iResult1.weightSum += iResult2.weightSum;
+
+ return iResult1;
+ };
+ }
+
+ /**
+ * Perform the final transformation from the intermediate accumulation type
+ * {@link IntemediateResults} to the final result type {@link Double}.
+ *
+ * <p>
+ * If the characteristic {@code IDENTITY_FINISH} is
+ * set, this function may be presumed to be an identity transform with an
+ * unchecked cast from {@link IntemediateResults} to {@link Double}.
+ * </p>
+ *
+ * @return A function which transforms the intermediate result to the final
+ * result
+ */
+ @Override
+ public Function<IntemediateResults, Double> finisher() {
+ return iResult -> iResult.weightedValSum / iResult.weightSum;
+ }
+
+ /**
+ * Returns a {@code Set} of {@code Collector.Characteristics} indicating
+ * the characteristics of this Collector.
+ *
+ * @return An immutable set of collector characteristics
+ */
+ @Override
+ public Set<Characteristics> characteristics() {
+ return Set.of(Characteristics.UNORDERED);
+ }
+}
+
+/**
+ * A helper class which stores intermediate results
+ * for the {@link WeightedAverageCollector} class.
+ *
+ * @author Daniel Schramm
+ */
+class IntemediateResults {
+ double weightedValSum = 0;
+ double weightSum = 0;
+}
diff --git a/Comparison/src/test/java/cz/fidentis/analyst/visitors/face/HausdorffDistancePrioritizedTest.java b/Comparison/src/test/java/cz/fidentis/analyst/visitors/face/HausdorffDistancePrioritizedTest.java
index 90bfef802aefa36c307f1dca9b2894d72e2f8803..9706a4224d06ac9bbda21e6f68e9c8f354b82f85 100644
--- a/Comparison/src/test/java/cz/fidentis/analyst/visitors/face/HausdorffDistancePrioritizedTest.java
+++ b/Comparison/src/test/java/cz/fidentis/analyst/visitors/face/HausdorffDistancePrioritizedTest.java
@@ -45,7 +45,9 @@ public class HausdorffDistancePrioritizedTest {
private final List<Double> prioritiesListFP1 = List.of(1d, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 0d, 0d);
private final double weightedDistanceFP1 = 0 + 0.09 + 0.16 + 0.21 + 0.24 + 0.25 + 0.24 + 0.21 + 0.16 + 0.09 + 0 + 0;
- private final double averageWeightedDistanceFP1 = weightedDistanceFP1 / 10; // There are 10 vertices inside the priority sphere
+ private final double averageWeightedDistanceFP1 = weightedDistanceFP1 / prioritiesListFP1.stream()
+ .mapToDouble(Double::doubleValue)
+ .sum();
private final Point3d featurePoint1 = new Point3d(0, 0, 0);
private final FeaturePointType fpType1 = new FeaturePointType(0, null, null, null);
@@ -282,7 +284,8 @@ public class HausdorffDistancePrioritizedTest {
for (final MeshFacet facet: facets) {
expectedPrioritiesMapFP2.put(facet, Collections.nCopies(VERTICES_NUM, 0d));
}
- expectedPrioritiesMapFP2.put(facet1, List.of(0d, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1d, 0.9));
+ final List<Double> prioritiesList = List.of(0d, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1d, 0.9);
+ expectedPrioritiesMapFP2.put(facet1, prioritiesList);
final Map<FeaturePointType, Map<MeshFacet, List<Double>>> expectedPriorities = Map.of(fpType1, expectedPrioritiesMapFP1,
fpType2, expectedPrioritiesMapFP2);
@@ -290,7 +293,12 @@ public class HausdorffDistancePrioritizedTest {
for (final MeshFacet facet: facets) {
expectedWeightedDistancesMapFP2.put(facet, Double.NaN);
}
- expectedWeightedDistancesMapFP2.put(facet1, (0 + 0.01 + 0.04 + 0.09 + 0.16 + 0.25 + 0.36 + 0.49 + 0.64 + 0.81 + 1 + 0.99) / 11);
+ expectedWeightedDistancesMapFP2.put(
+ facet1,
+ (0 + 0.01 + 0.04 + 0.09 + 0.16 + 0.25 + 0.36 + 0.49 + 0.64 + 0.81 + 1 + 0.99) / prioritiesList.stream()
+ .mapToDouble(Double::doubleValue)
+ .sum()
+ );
final Map<FeaturePointType, Map<MeshFacet, Double>> expectedFeaturePointsWeights = Map.of(fpType1, expectedWeightedDistancesMapFP1,
fpType2, expectedWeightedDistancesMapFP2);
@@ -346,7 +354,9 @@ public class HausdorffDistancePrioritizedTest {
expectedWeightedDistancesMapFP3.put(facet, Double.NaN);
expectedWeightedDistancesMapFP4.put(facet, Double.NaN);
}
- final double weightedDistance = (0 + 0.01 + 0.04 + 0.09 + 0.16 + 0.25 + 0.36 + 0.49 + 0.64 + 0.81 + 1 + 0.99) / 11;
+ final double weightedDistance = (0 + 0.01 + 0.04 + 0.09 + 0.16 + 0.25 + 0.36 + 0.49 + 0.64 + 0.81 + 1 + 0.99) / prioritiesList.stream()
+ .mapToDouble(Double::doubleValue)
+ .sum();
expectedWeightedDistancesMapFP2.put(facet1, weightedDistance);
expectedWeightedDistancesMapFP3.put(facet3, weightedDistance);
expectedWeightedDistancesMapFP4.put(facet5, -weightedDistance);
@@ -409,7 +419,9 @@ public class HausdorffDistancePrioritizedTest {
expectedWeightedDistancesMapFP2.put(facet, Double.NaN);
expectedWeightedDistancesMapFP3.put(facet, Double.NaN);
}
- final double weightedDistance = 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 1 * vertexPriority + 0;
+ final double weightedDistance = (0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 1 * vertexPriority + 0) / prioritiesList.stream()
+ .mapToDouble(Double::doubleValue)
+ .sum();
expectedWeightedDistancesMapFP2.put(facet1, weightedDistance);
expectedWeightedDistancesMapFP2.put(facet3, weightedDistance);
expectedWeightedDistancesMapFP3.put(facet1, weightedDistance);
@@ -473,7 +485,9 @@ public class HausdorffDistancePrioritizedTest {
expectedWeightedDistancesMapFP3.put(facet, Double.NaN);
expectedWeightedDistancesMapFP4.put(facet, Double.NaN);
}
- final double weightedDistance = (0 + 0.01 + 0.04 + 0.09 + 0.16 + 0.25 + 0.36 + 0.49 + 0.64 + 0.81 + 1 + 0.99) / 11;
+ final double weightedDistance = (0 + 0.01 + 0.04 + 0.09 + 0.16 + 0.25 + 0.36 + 0.49 + 0.64 + 0.81 + 1 + 0.99) / prioritiesList.stream()
+ .mapToDouble(Double::doubleValue)
+ .sum();
expectedWeightedDistancesMapFP2.put(facet1, weightedDistance);
expectedWeightedDistancesMapFP3.put(facet3, weightedDistance);
expectedWeightedDistancesMapFP4.put(facet5, -weightedDistance);