diff --git a/Comparison/src/main/java/cz/fidentis/analyst/EfficiencyTests.java b/Comparison/src/main/java/cz/fidentis/analyst/EfficiencyTests.java
new file mode 100644
index 0000000000000000000000000000000000000000..a9753f9fe942bb0b2942ffd288fe00ee52440b53
--- /dev/null
+++ b/Comparison/src/main/java/cz/fidentis/analyst/EfficiencyTests.java
@@ -0,0 +1,120 @@
+package cz.fidentis.analyst;
+
+import cz.fidentis.analyst.face.HumanFace;
+import cz.fidentis.analyst.mesh.core.MeshFacet;
+import cz.fidentis.analyst.visitors.mesh.HausdorffDistanceVisitor;
+import cz.fidentis.analyst.visitors.mesh.HausdorffDistanceVisitor.Strategy;
+import cz.fidentis.analyst.visitors.mesh.DistanceToTrianglesVisitor;
+import cz.fidentis.analyst.visitors.mesh.DistanceToVerticesVisitor;
+import java.io.File;
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+import javax.vecmath.Vector3d;
+
+/**
+ * A class for testing the efficiency of algorithms.
+ *
+ * @author Radek Oslejsek
+ */
+public class EfficiencyTests {
+
+ private static File girlFile = new File("src/test/resources/cz/fidentis/analyst/average_girl_17-20.obj");
+ private static File boyFile = new File("src/test/resources/cz/fidentis/analyst/average_boy_17-20.obj");
+
+ private static HumanFace boy;
+ private static HumanFace girl;
+
+ /**
+ * Main method
+ * @param args Input arguments
+ * @throws IOException on IO error
+ */
+ public static void main(String[] args) throws IOException {
+ boy = new HumanFace(boyFile);
+ girl = new HumanFace(girlFile);
+
+ System.out.println(measureKdTreeCreation(boy) + " msec: Kd-tree creation of the boy");
+ System.out.println(measureKdTreeCreation(boy) + " msec: Kd-tree creation of the girl");
+
+ boolean print = false;
+
+ System.out.println(measureDist(new Vector3d(), boy, false, print, true) + " msec: Distance (sequential, point-to-point)");
+ System.out.println(measureDist(new Vector3d(), boy, true, print, true) + " msec: Distance (concurrent, point-to-point)");
+ System.out.println(measureDist(new Vector3d(), boy, false, print, false) + " msec: Distance (sequential, point-to-tri)");
+ System.out.println(measureDist(new Vector3d(), boy, true, print, false) + " msec: Distance (concurrent, point-to-tri)");
+
+
+ System.out.println(measureHD(boy, girl, false, false, print, true) + " msec: Hausdorff distance (relative, sequential, point-to-point)");
+ System.out.println(measureHD(boy, girl, false, true, print, true) + " msec: Hausdorff distance (relative, concurrent, point-to-point)");
+ System.out.println(measureHD(boy, girl, false, false, print, false) + " msec: Hausdorff distance (relative, sequential, point-to-tri)");
+ System.out.println(measureHD(boy, girl, false, true, print, false) + " msec: Hausdorff distance (relative, concurrent, point-to-tri)");
+ }
+
+ private static long measureKdTreeCreation(HumanFace face) {
+ long startTime = System.currentTimeMillis();
+ face.buildKdTree();
+ return System.currentTimeMillis() - startTime;
+ }
+
+ private static long measureDist(
+ Vector3d point,
+ HumanFace face,
+ boolean concurrent,
+ boolean printResults,
+ boolean p2p) {
+
+ double dist;
+ long startTime, endTime;
+
+ if (p2p) {
+ DistanceToVerticesVisitor vis = new DistanceToVerticesVisitor(point, concurrent);
+ startTime = System.currentTimeMillis();
+ face.getMeshModel().compute(vis);
+ endTime = System.currentTimeMillis() - startTime;
+ dist = vis.getDistance();
+ } else {
+ DistanceToTrianglesVisitor vis = new DistanceToTrianglesVisitor(point, concurrent);
+ startTime = System.currentTimeMillis();
+ face.getMeshModel().compute(vis);
+ endTime = System.currentTimeMillis() - startTime;
+ dist = vis.getDistance();
+ }
+
+ if (printResults) {
+ System.out.println("Distance: " + dist);
+ }
+
+ return endTime;
+ }
+
+ private static long measureHD(
+ HumanFace face1,
+ HumanFace face2,
+ boolean relativeDist,
+ boolean concurrent,
+ boolean printResults,
+ boolean p2p) {
+
+ HausdorffDistanceVisitor vis = null;
+
+ if (p2p) {
+ vis = new HausdorffDistanceVisitor(face1.getMeshModel(), Strategy.POINT_TO_POINT, relativeDist, concurrent);
+ } else {
+ vis = new HausdorffDistanceVisitor(face1.getMeshModel(), Strategy.POINT_TO_TRIANGLE, relativeDist, concurrent);
+ }
+
+ long startTime = System.currentTimeMillis();
+ face2.getMeshModel().compute(vis);
+ long endTime = System.currentTimeMillis() - startTime;
+
+ if (printResults) {
+ Map<MeshFacet, List<Double>> results = vis.getDistances();
+ for (MeshFacet facet: results.keySet()) {
+ System.out.println(results.get(facet));
+ }
+ }
+
+ return endTime;
+ }
+}
diff --git a/Comparison/src/main/java/cz/fidentis/analyst/face/HumanFace.java b/Comparison/src/main/java/cz/fidentis/analyst/face/HumanFace.java
index 28836f6c061c1b752392e37eb24b827d367dcf35..2776b098580aa772dc42fc9beb51ca87c1df0d9a 100644
--- a/Comparison/src/main/java/cz/fidentis/analyst/face/HumanFace.java
+++ b/Comparison/src/main/java/cz/fidentis/analyst/face/HumanFace.java
@@ -22,6 +22,7 @@ import java.io.InputStream;
* Then the are informed about changes in the human automatically via methods
* prescribed by the interface.
* </p>
+ * <p>
* Events fired by the class:
* <ul>
* <li>{@link cz.fidentis.analyst.mesh.events.MeshEvent} or its sub-type if
diff --git a/Comparison/src/main/java/cz/fidentis/analyst/symmetry/SymmetryEstimator.java b/Comparison/src/main/java/cz/fidentis/analyst/symmetry/SymmetryEstimator.java
index f245e8690c03d508ee8f94e7907604939f2678f3..c2a3520f98e4110a4bbff851cc9c87ac9d2de471 100644
--- a/Comparison/src/main/java/cz/fidentis/analyst/symmetry/SymmetryEstimator.java
+++ b/Comparison/src/main/java/cz/fidentis/analyst/symmetry/SymmetryEstimator.java
@@ -89,7 +89,7 @@ public class SymmetryEstimator {
*/
public BoundingBox getBoundingBox() {
if (boundingBox == null) {
- BoundingBoxVisitor visitor = new BoundingBoxVisitor();
+ BoundingBoxVisitor visitor = new BoundingBoxVisitor(true);
facet.accept(visitor);
boundingBox = visitor.getBoundingBox();
}
diff --git a/Comparison/src/main/java/cz/fidentis/analyst/visitors/mesh/BoundingBoxVisitor.java b/Comparison/src/main/java/cz/fidentis/analyst/visitors/mesh/BoundingBoxVisitor.java
index 25451855fce826da972a9c045dba61af895d2fd0..6a121d1f4b9647266009fd51eb34ab3f17089f52 100644
--- a/Comparison/src/main/java/cz/fidentis/analyst/visitors/mesh/BoundingBoxVisitor.java
+++ b/Comparison/src/main/java/cz/fidentis/analyst/visitors/mesh/BoundingBoxVisitor.java
@@ -5,15 +5,28 @@ import cz.fidentis.analyst.mesh.core.MeshFacet;
/**
* Visitor that computes a 3D bounding box (cube).
+ * <p>
+ * This visitor is thread-safe. A single instance of the visitor can be used
+ * to inspect multiple mesh models or facets simultaneously.
+ * </p>
*
* @author Radek Oslejsek
*/
-public class BoundingBoxVisitor implements MeshVisitor {
+public class BoundingBoxVisitor extends MeshVisitor {
private BoundingBox bbox;
+ /**
+ *
+ * @param concurrently If {@code true} and this visitor is thread-safe, then
+ * the visitor is applied concurrently on multiple mesf facets.
+ */
+ public BoundingBoxVisitor(boolean concurrently) {
+ super(concurrently);
+ }
+
@Override
- public void visitMeshFacet(MeshFacet facet) {
+ protected synchronized void visitMeshFacet(MeshFacet facet) {
if (bbox == null) {
bbox = new BoundingBox(facet.getVertices());
} else {
@@ -23,6 +36,7 @@ public class BoundingBoxVisitor implements MeshVisitor {
/**
* Returns computed bounding box.
+ *
* @return Bounding box or null
*/
public BoundingBox getBoundingBox() {
diff --git a/Comparison/src/main/java/cz/fidentis/analyst/visitors/mesh/DistanceToTrianglesVisitor.java b/Comparison/src/main/java/cz/fidentis/analyst/visitors/mesh/DistanceToTrianglesVisitor.java
new file mode 100644
index 0000000000000000000000000000000000000000..6a8cfb050298e375b3c8a9c6668f70c4bf556598
--- /dev/null
+++ b/Comparison/src/main/java/cz/fidentis/analyst/visitors/mesh/DistanceToTrianglesVisitor.java
@@ -0,0 +1,215 @@
+package cz.fidentis.analyst.visitors.mesh;
+
+import cz.fidentis.analyst.mesh.MeshVisitor;
+import cz.fidentis.analyst.mesh.core.MeshFacet;
+import cz.fidentis.analyst.mesh.core.MeshPoint;
+import cz.fidentis.analyst.mesh.core.MeshPointImpl;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import javax.vecmath.Vector3d;
+
+/**
+ * This visitor finds the distance between given 3D point and a mesh facet.
+ * The minimal distance is computed between the 3D point and triangles of the mesh facet.
+ * This method is more precise, but slower.
+ * <p>
+ * The visitor returns the minimal distance and the closest triangle.
+ * However, a single visitor can be applied to multiple mesh facets.
+ * If closest point lies on the boundary edge (the edge "shared" by two independet
+ * mesh facets), then the visitor has to include both facets in result. In case of
+ * "shared" vertex more than two facets could be included.
+ * Therefore, the visitor returns a list of closest facets instead of just a single facet.
+ * <ul>
+ * <li>{@code MeshFacet f = getClosestFacets().get(i)} gives you the i-th closest facet.</li>
+ * <li>{@code int n = getClosestTriangles().get(i)} gives you the index of the closest
+ * triangle in the i-th facet.</li>
+ * <li>Then you can use the methods of {@link cz.fidentis.analyst.mesh.core.MeshFacet} and
+ * {@link cz.fidentis.analyst.mesh.core.CornerTable} to retrieve topological details
+ * of the triangle.</li>
+ * </ul>
+ * This visitor is thread-safe. A single instance of the visitor can be used
+ * to inspect multiple mesh models or facets simultaneously.
+ * </p>
+ *
+ * @author Matej Lukes
+ * @author Radek Oslejsek
+*/
+public class DistanceToTrianglesVisitor extends MeshVisitor {
+
+ public static final double EPS = 0.001; // tollerance for double computations
+ private boolean relativeDist;
+ private MeshPoint myPoint;
+ private int sign = 1;
+
+ private double distance = Double.POSITIVE_INFINITY;
+ private final List<MeshFacet> closestFacets = new ArrayList<>();
+ private final List<Integer> closestTriangles = new ArrayList<>();
+
+ /**
+ * @param point A 3D point from which distance is computed. Must not be {@code null}
+ * @param relativeDistance If{@true}, the visitor calculates the distances with respect
+ * to the normals of the 3D point (the normal has to be present),
+ * i.e., we can get negative distance.
+ * @param concurrently If {@code true} and this visitor is thread-safe, then
+ * the visitor is applied concurrently on multiple mesf facets.
+ * @throws IllegalArgumentException if some parametr is wrong
+ */
+ public DistanceToTrianglesVisitor(MeshPoint point, boolean relativeDistance, boolean concurrently) {
+ super(concurrently);
+ if (point == null) {
+ throw new IllegalArgumentException("point");
+ }
+ if (point.getNormal() == null && relativeDistance) {
+ throw new IllegalArgumentException("normal required for relative distance");
+ }
+ this.myPoint = point;
+ this.relativeDist = relativeDistance;
+ }
+
+ /**
+ * @param point A 3D point from which distance is computed. Must not be {@code null}
+ * @param strategy Strategy got the computation of distance
+ * @param concurrently If {@code true} and this visitor is thread-safe, then
+ * the visitor is applied concurrently on multiple mesf facets.
+ * @throws IllegalArgumentException if some parametr is wrong
+ */
+ public DistanceToTrianglesVisitor(Vector3d point, boolean concurrently) {
+ this (new MeshPointImpl(point, null, null), false, concurrently);
+ }
+
+ @Override
+ protected void visitMeshFacet(MeshFacet facet) {
+ Vector3d my = myPoint.getPosition();
+
+ DistanceToVerticesVisitor vis = new DistanceToVerticesVisitor(myPoint, relativeDist, false);
+ facet.accept(vis);
+
+ List<MeshFacet> clFacets = vis.getClosestFacets();
+ List<Integer> clVertices = vis.getClosestVertices();
+
+ for (int i = 0; i < clVertices.size(); i++) { // for all found closest vertices
+ MeshFacet closestF = clFacets.get(i);
+ int closestI = clVertices.get(i);
+
+ Vector3d projection = closestF.getClosestAdjacentPoint(my, closestI);
+ Vector3d aux = new Vector3d(projection);
+ aux.sub(myPoint.getPosition());
+
+ double dist = aux.length();
+
+ synchronized (this) {
+ if (dist > distance) {
+ continue;
+ }
+ if (dist < distance) { // new closest point
+ sign = relativeDist ? (int) Math.signum(aux.dot(myPoint.getNormal())): 1;
+ distance = dist;
+ closestFacets.clear();
+ closestTriangles.clear();
+ closestFacets.add(closestF);
+ closestTriangles.add(closestI);
+ } else { // the same distance
+ if (!closestFacets.contains(closestF)) {
+ closestFacets.add(closestF);
+ closestTriangles.add(closestI);
+ }
+ }
+ }
+
+ /*
+ CornerTable ct = closestF.getCornerTable();
+
+ List<Integer> adjacentTrianglesI = ct.getTriangleIndexesByVertexIndex(closestI);
+ for (Integer triI: adjacentTrianglesI) {
+ List<Integer> triVerticesI = ct.getIndexesOfVerticesByTriangleIndex(triI);
+ MeshTriangle tri = new MeshTriangle(
+ closestF.getVertex(triVerticesI.get(0)),
+ closestF.getVertex(triVerticesI.get(1)),
+ closestF.getVertex(triVerticesI.get(2)),
+ triVerticesI.get(0),
+ triVerticesI.get(1),
+ triVerticesI.get(2));
+
+ Vector3d projection = tri.getClosestPoint(my);
+ checkAndUpdateDistance(projection, facet, i);
+ }
+ */
+ }
+ }
+
+ /**
+ * Returns distance to the closest mesh point.
+ *
+ * @return distance to the closest mesh point,
+ * {@code Double.POSITIVE_INFINITY} if no distance has been calculated
+ */
+ public double getDistance() {
+ return relativeDist ? sign * distance : distance;
+ }
+
+ /**
+ * Returns indeces to the closest elements (points or triangles) of corresponding facet.
+ *
+ * @return indeces to the closest elements (points or triangles) of corresponding facet,
+ * {@code null} if no search has been performed
+ */
+ public List<Integer> getClosestTriangles() {
+ return Collections.unmodifiableList(closestTriangles);
+ }
+
+ /**
+ * Returns the closest mesh facets (containing the closest mesh points).
+ *
+ * @return the closest mesh facets
+ */
+ public List<MeshFacet> getClosestFacets() {
+ return Collections.unmodifiableList(closestFacets);
+ }
+
+ /**
+ * Returns {@code true} if the distance is computed as relative
+ * (with possibly negative values).
+ *
+ * @return {@code true} if the distance is computed as relative.
+ */
+ public boolean usesRelativeDist() {
+ return relativeDist;
+ }
+
+
+ /**
+ * Computes the minimal distance and if the mesh point is closer that
+ * the closest point found so far, then updates the visitor's state.
+ *
+ * @param pointOnSurface Point on the mesh facet (either mesh vertex or projection point)
+ * @param facet Mesh facet
+ * @param index Index of the mesh vertex or triangle in the mesh facet (depending on the distance strategy)
+ */
+ protected void checkAndUpdateDistance(Vector3d pointOnSurface, MeshFacet facet, int index) {
+ Vector3d aux = new Vector3d(pointOnSurface);
+ aux.sub(myPoint.getPosition());
+ sign = relativeDist ? (int) Math.signum(aux.dot(myPoint.getNormal())): 1;
+ double dist = aux.length();
+
+ synchronized (this) {
+ if (dist > distance) {
+ return;
+ }
+
+ if (dist < distance) { // new closest point
+ distance = dist;
+ closestFacets.clear();
+ closestTriangles.clear();
+ closestFacets.add(facet);
+ closestTriangles.add(index);
+ } else { // the same distance
+ if (!closestFacets.contains(facet)) {
+ closestFacets.add(facet);
+ closestTriangles.add(index);
+ }
+ }
+ }
+ }
+
+}
diff --git a/Comparison/src/main/java/cz/fidentis/analyst/visitors/mesh/DistanceToVerticesVisitor.java b/Comparison/src/main/java/cz/fidentis/analyst/visitors/mesh/DistanceToVerticesVisitor.java
new file mode 100644
index 0000000000000000000000000000000000000000..d4d353a67123bd832f9d64544f66982a0609fe56
--- /dev/null
+++ b/Comparison/src/main/java/cz/fidentis/analyst/visitors/mesh/DistanceToVerticesVisitor.java
@@ -0,0 +1,190 @@
+package cz.fidentis.analyst.visitors.mesh;
+
+import cz.fidentis.analyst.mesh.MeshVisitor;
+import cz.fidentis.analyst.mesh.core.MeshFacet;
+import cz.fidentis.analyst.mesh.core.MeshPoint;
+import cz.fidentis.analyst.mesh.core.MeshPointImpl;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import javax.vecmath.Vector3d;
+
+/**
+ * This visitor finds the distance between given 3D point and a mesh facet.
+ * The minimal distance is computed between the 3D point and
+ * vertices of the mesh facet.
+ * <p>
+ * The visitor returns the minimal distance and the closest vertex.
+ * However, a single visitor can be applied to multiple mesh facets.
+ * If closest vertex is boudary between neighbouring mesh facets (multiple
+ * facets have a vertex with the same coordinates), then the visitor has to
+ * include all these facets in result. Therefore, the visitor returns
+ * a list of closest facets instead of just a single facet.
+ * <p>
+ * <ul>
+ * <li>{@code MeshFacet f = getClosestFacets().get(i)} gives you the i-th closest facet.</li>
+ * <li>{@code int n = getClosestVertices().get(i)} gives you the index of the closest
+ * vertex in the i-th facet.</li>
+ * <li>Then you can use the methods of {@link cz.fidentis.analyst.mesh.core.MeshFacet} and
+ * {@link cz.fidentis.analyst.mesh.core.CornerTable} to retrieve topological details
+ * of the vertex.</li>
+ * </ul>
+ * </p>
+ * <p>
+ * This visitor is thread-safe. A single instance of the visitor can be used
+ * to inspect multiple mesh models or facets simultaneously.
+ * </p>
+ *
+ * @author Matej Lukes
+ * @author Radek Oslejsek
+ */
+public class DistanceToVerticesVisitor extends MeshVisitor {
+
+ private boolean relativeDist;
+ private MeshPoint myPoint;
+ private int sign = 1;
+
+ private double distance = Double.POSITIVE_INFINITY;
+ private final List<MeshFacet> closestFacets = new ArrayList<>();
+ private final List<Integer> closestVertices = new ArrayList<>();
+
+ /**
+ * @param point A 3D point from which distance is computed. Must not be {@code null}
+ * @param relativeDistance If{@true}, the visitor calculates the distances with respect
+ * to the normals of the 3D point (the normal has to be present),
+ * i.e., we can get negative distance.
+ * @param concurrently If {@code true} and this visitor is thread-safe, then
+ * the visitor is applied concurrently on multiple mesf facets.
+ * @throws IllegalArgumentException if some parametr is wrong
+ */
+ public DistanceToVerticesVisitor(MeshPoint point, boolean relativeDistance, boolean concurrently) {
+ super(concurrently);
+ if (point == null) {
+ throw new IllegalArgumentException("point");
+ }
+ if (point.getNormal() == null && relativeDistance) {
+ throw new IllegalArgumentException("normal required for relative distance");
+ }
+ this.myPoint = point;
+ this.relativeDist = relativeDistance;
+ }
+
+ /**
+ * @param point A 3D point from which distance is computed. Must not be {@code null}
+ * @param strategy Strategy got the computation of distance
+ * @param concurrently If {@code true} and this visitor is thread-safe, then
+ * the visitor is applied concurrently on multiple mesf facets.
+ * @throws IllegalArgumentException if some parametr is wrong
+ */
+ public DistanceToVerticesVisitor(Vector3d point, boolean concurrently) {
+ this (new MeshPointImpl(point, null, null), false, concurrently);
+ }
+
+ @Override
+ protected void visitMeshFacet(MeshFacet facet) {
+ List<MeshPoint> vertices = facet.getVertices();
+ for (int i = 0; i < vertices.size(); i++) {
+ //checkAndUpdateDistance(vertices.get(i).getPosition(), facet, i);
+ Vector3d pointOnSurface = vertices.get(i).getPosition();
+ Vector3d aux = new Vector3d(pointOnSurface);
+ aux.sub(myPoint.getPosition());
+ double dist = aux.length();
+
+ synchronized (this) {
+ if (dist > distance) {
+ continue;
+ }
+ if (dist < distance) { // new closest point
+ distance = dist;
+ sign = relativeDist ? (int) Math.signum(aux.dot(myPoint.getNormal())): 1;
+ closestFacets.clear();
+ closestVertices.clear();
+ closestFacets.add(facet);
+ closestVertices.add(i);
+ } else { // the same distance
+ if (!closestFacets.contains(facet)) {
+ closestFacets.add(facet);
+ closestVertices.add(i);
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * Returns distance to the closest mesh point.
+ *
+ * @return distance to the closest mesh point,
+ * {@code Double.POSITIVE_INFINITY} if no distance has been calculated
+ */
+ public double getDistance() {
+ return relativeDist ? sign * distance : distance;
+ }
+
+ /**
+ * Returns indeces to the closest elements (points or triangles) of corresponding facet.
+ *
+ * @return indeces to the closest elements (points or triangles) of corresponding facet,
+ * {@code null} if no search has been performed
+ */
+ public List<Integer> getClosestVertices() {
+ return Collections.unmodifiableList(closestVertices);
+ }
+
+ /**
+ * Returns the closest mesh facets (containing the closest mesh points).
+ *
+ * @return the closest mesh facets
+ */
+ public List<MeshFacet> getClosestFacets() {
+ return Collections.unmodifiableList(closestFacets);
+ }
+
+ /**
+ * Returns {@code true} if the distance is computed as relative
+ * (with possibly negative values).
+ *
+ * @return {@code true} if the distance is computed as relative.
+ */
+ public boolean usesRelativeDist() {
+ return relativeDist;
+ }
+
+ /***********************************************************
+ * PROTECTED METHODS
+ ***********************************************************/
+
+ /**
+ * Computes the minimal distance and if the mesh point is closer that
+ * the closest point found so far, then updates the visitor's state.
+ *
+ * @param pointOnSurface Point on the mesh facet (either mesh vertex or projection point)
+ * @param facet Mesh facet
+ * @param index Index of the mesh vertex or triangle in the mesh facet (depending on the distance strategy)
+ */
+ protected void checkAndUpdateDistance(Vector3d pointOnSurface, MeshFacet facet, int index) {
+ Vector3d aux = new Vector3d(pointOnSurface);
+ aux.sub(myPoint.getPosition());
+ double dist = aux.length();
+
+ synchronized (this) {
+ if (dist > distance) {
+ return;
+ }
+
+ if (dist < distance) { // new closest point
+ distance = dist;
+ sign = relativeDist ? (int) Math.signum(aux.dot(myPoint.getNormal())): 1;
+ closestFacets.clear();
+ closestVertices.clear();
+ closestFacets.add(facet);
+ closestVertices.add(index);
+ } else { // the same distance
+ if (!closestFacets.contains(facet)) {
+ closestFacets.add(facet);
+ closestVertices.add(index);
+ }
+ }
+ }
+ }
+}
diff --git a/Comparison/src/main/java/cz/fidentis/analyst/visitors/mesh/HausdorffDistMeshTriVisitor.java b/Comparison/src/main/java/cz/fidentis/analyst/visitors/mesh/HausdorffDistMeshTriVisitor.java
deleted file mode 100644
index e9befdb693da449252b4b2c931b483ec35660129..0000000000000000000000000000000000000000
--- a/Comparison/src/main/java/cz/fidentis/analyst/visitors/mesh/HausdorffDistMeshTriVisitor.java
+++ /dev/null
@@ -1,60 +0,0 @@
-package cz.fidentis.analyst.visitors.mesh;
-
-import cz.fidentis.analyst.mesh.core.MeshFacet;
-import cz.fidentis.analyst.mesh.core.MeshPoint;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-/**
- * Visitor for Hausdorff distance.
- * This visitor is instantiated on a single mesh facet or multiple facets.
- * When applied to other facets, it computes Huasdorff distance to them.
- *
- * Distances to triangles are computed, in constrast to the {@code HausdorffDistMeshTriVisitor}
- * which calculated distances to mesh points.
- *
- * @author Matej Lukes
- * @author Radek Oslejsek
- */
-public class HausdorffDistMeshTriVisitor extends HausdorffDistMeshVisitor {
-
- /**
- * @param mainFacets Facets whose distance to other facets is computed. Must not be {@code null}
- * @param relativeDistance If true, then the visitor calculates the relative distances with respect
- * to the normal vectors of source facets (normal vectors have to present),
- * i.e., we can get negative distances.
- * @throws IllegalArgumentException if some parametr is wrong
- */
- public HausdorffDistMeshTriVisitor(Set<MeshFacet> mainFacets, boolean relativeDistance) {
- super(mainFacets, relativeDistance);
- }
-
- /**
- * @param mainFacet Primary facet of which distance to others is to be computed. Must not be {@code null}
- * @param relativeDistance If true, then the visitor calculates the relative distances with respect
- * to the normal vectors of source facets (normal vectors have to present),
- * i.e., we can get negative distances.
- * @throws IllegalArgumentException if some parametr is wrong
- */
- public HausdorffDistMeshTriVisitor(MeshFacet mainFacet, boolean relativeDistance) {
- super(mainFacet, relativeDistance);
- }
-
- @Override
- public void visitMeshFacet(MeshFacet comparedFacet) {
- for (Map.Entry<MeshFacet, List<Double>> entry: getDistMap().entrySet()) {
- List<MeshPoint> vertices = entry.getKey().getVertices();
- List<Double> distList = entry.getValue();
-
- boolean firstComparison = distList.isEmpty();
-
- for (int i = 0; i < vertices.size(); i++) {
- Point2MeshTriVisitor visitor = new Point2MeshTriVisitor(vertices.get(i), isRelativeDistance());
- comparedFacet.accept(visitor);
- double dist = visitor.getDistance();
- updateDistances(distList, firstComparison, dist, i);
- }
- }
- }
-}
diff --git a/Comparison/src/main/java/cz/fidentis/analyst/visitors/mesh/HausdorffDistMeshVisitor.java b/Comparison/src/main/java/cz/fidentis/analyst/visitors/mesh/HausdorffDistMeshVisitor.java
deleted file mode 100644
index ef40c2d20891770baf00deaf4011692b44f158ea..0000000000000000000000000000000000000000
--- a/Comparison/src/main/java/cz/fidentis/analyst/visitors/mesh/HausdorffDistMeshVisitor.java
+++ /dev/null
@@ -1,111 +0,0 @@
-package cz.fidentis.analyst.visitors.mesh;
-
-import cz.fidentis.analyst.mesh.MeshVisitor;
-import cz.fidentis.analyst.mesh.core.MeshFacet;
-import cz.fidentis.analyst.mesh.core.MeshPoint;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-/**
- * Visitor for Hausdorff distance.
- * This visitor is instantiated on a single mesh facet or multiple facets.
- * When applied to other facets, it computes Huasdorff distance to them.
- *
- * @author Matej Lukes
- * @author Radek Oslejsek
- */
-public class HausdorffDistMeshVisitor implements MeshVisitor {
-
- private boolean relativeDistance;
- private Map<MeshFacet, List<Double>> distances = new HashMap<>();
-
- /**
- * @param mainFacets Facets whose distance to other facets is computed. Must not be {@code null}
- * @param relativeDistance If true, then the visitor calculates the relative distances with respect
- * to the normal vectors of source facets (normal vectors have to present),
- * i.e., we can get negative distances.
- * @throws IllegalArgumentException if some parametr is wrong
- */
- public HausdorffDistMeshVisitor(Set<MeshFacet> mainFacets, boolean relativeDistance) {
- if (mainFacets == null) {
- throw new IllegalArgumentException("mainFacets");
- }
- for (MeshFacet f: mainFacets) {
- distances.put(f, new ArrayList<>());
- }
- this.relativeDistance = relativeDistance;
- }
-
- /**
- * @param mainFacet Primary facet of which distance to others is to be computed. Must not be {@code null}
- * @param relativeDistance If true, then the visitor calculates the relative distances with respect
- * to the normal vectors of source facets (normal vectors have to present),
- * i.e., we can get negative distances.
- * @throws IllegalArgumentException if some parametr is wrong
- */
- public HausdorffDistMeshVisitor(MeshFacet mainFacet, boolean relativeDistance) {
- this(new HashSet<>(Collections.singleton(mainFacet)), relativeDistance);
- if (mainFacet == null) {
- throw new IllegalArgumentException("mainFacet");
- }
- }
-
- @Override
- public void visitMeshFacet(MeshFacet comparedFacet) {
- for (Map.Entry<MeshFacet, List<Double>> entry: distances.entrySet()) {
- List<MeshPoint> vertices = entry.getKey().getVertices();
- List<Double> distList = entry.getValue();
-
- boolean firstComparison = distList.isEmpty();
-
- for (int i = 0; i < vertices.size(); i++) {
- Point2MeshVisitor visitor = new Point2MeshVisitor(vertices.get(i), relativeDistance);
- comparedFacet.accept(visitor);
- double dist = visitor.getDistance();
- updateDistances(distList, firstComparison, dist, i);
- }
- }
- }
-
- /**
- * Return Hausdorff distance for all points of the source mesh.
- * A list of distances is returned for each mesh separaptely. Index of the
- * list corresponds to the order of vertives in the mesh facet.
- * Therefore, i-t number corresponds to the distance of i-th vertex of the
- * source mesh.
- *
- * @return Hausdorff distance for all points of the source mesh
- */
- public Map<MeshFacet, List<Double>> getDistances() {
- return Collections.unmodifiableMap(distances);
- }
-
- protected boolean isRelativeDistance() {
- return relativeDistance;
- }
-
- protected Map<MeshFacet, List<Double>> getDistMap() {
- return distances;
- }
-
- protected void updateDistances(List<Double> distList, boolean firstComparison, double dist, int index) {
- if (firstComparison) {
- distList.add(dist);
- return;
- }
-
- if (dist >= 0 && dist < distList.get(index)) {
- distList.set(index, dist);
- return;
- }
-
- if (dist < 0 && dist > distList.get(index)) { // for relative dist only
- distList.set(index, dist);
- }
- }
-}
diff --git a/Comparison/src/main/java/cz/fidentis/analyst/visitors/mesh/HausdorffDistanceVisitor.java b/Comparison/src/main/java/cz/fidentis/analyst/visitors/mesh/HausdorffDistanceVisitor.java
new file mode 100644
index 0000000000000000000000000000000000000000..e2dad53a1b4fdf655e41f4409c86c339bcb5a7cd
--- /dev/null
+++ b/Comparison/src/main/java/cz/fidentis/analyst/visitors/mesh/HausdorffDistanceVisitor.java
@@ -0,0 +1,196 @@
+package cz.fidentis.analyst.visitors.mesh;
+
+import cz.fidentis.analyst.mesh.MeshVisitor;
+import cz.fidentis.analyst.mesh.core.MeshFacet;
+import cz.fidentis.analyst.mesh.core.MeshModel;
+import cz.fidentis.analyst.mesh.core.MeshPoint;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Visitor for Hausdorff distance.
+ * This visitor is instantiated on a single mesh facet or multiple facets.
+ * When applied to other facets, it computes Huasdorff distance to them.
+ * <p>
+ * This visitor is thread-safe. A single instance of the visitor can be used
+ * to inspect multiple mesh models or facets simultaneously.
+ * </p>
+ *
+ * @author Matej Lukes
+ * @author Radek Oslejsek
+ */
+public class HausdorffDistanceVisitor extends MeshVisitor {
+
+ private boolean relativeDistance;
+ private Strategy strategy;
+ private final Map<MeshFacet, List<Double>> distances = new HashMap<>();
+
+ /**
+ * Computation strategy.
+ *
+ * @author Radek Oslejsek
+ */
+ public enum Strategy {
+ POINT_TO_POINT,
+ POINT_TO_TRIANGLE
+ }
+
+ /**
+ * @param mainFacets Facets of which distance to other facets is computed. Must not be {@code null}
+ * @param relativeDistance If true, then the visitor calculates the relative distances with respect
+ * to the normal vectors of source facets (normal vectors have to present),
+ * i.e., we can get negative distances.
+ * @param concurrently If {@code true} and this visitor is thread-safe, then
+ * the visitor is applied concurrently when inspecting multiple mesh facets.
+ * @throws IllegalArgumentException if some parametr is wrong
+ */
+ public HausdorffDistanceVisitor(Set<MeshFacet> mainFacets, Strategy strategy, boolean relativeDistance, boolean concurrently) {
+ super(concurrently);
+ if (mainFacets == null) {
+ throw new IllegalArgumentException("mainFacets");
+ }
+ for (MeshFacet f: mainFacets) {
+ // create the list of distances initiate it with infinity
+ distances.put(f, new ArrayList<>());
+ }
+ this.relativeDistance = relativeDistance;
+ this.strategy = strategy;
+ }
+
+ /**
+ * @param mainFacet Primary facet of which distance to others is to be computed. Must not be {@code null}
+ * @param relativeDistance If true, then the visitor calculates the relative distances with respect
+ * to the normal vectors of source facets (normal vectors have to present),
+ * i.e., we can get negative distances.
+ * @param concurrently If {@code true} and this visitor is thread-safe, then
+ * the visitor is applied concurrently when inspecting multiple mesh facets.
+ * @throws IllegalArgumentException if some parametr is wrong
+ */
+ public HausdorffDistanceVisitor(MeshFacet mainFacet, Strategy strategy, boolean relativeDistance, boolean concurrently) {
+ this(new HashSet<>(Collections.singleton(mainFacet)), strategy, relativeDistance, concurrently);
+ if (mainFacet == null) {
+ throw new IllegalArgumentException("mainFacet");
+ }
+ }
+
+ /**
+ * @param mainModel The mesh model with primary facets of which distance to
+ * others is to be computed. Must not be {@code null} or empty.
+ * @param relativeDistance If true, then the visitor calculates the relative distances with respect
+ * to the normal vectors of source facets (normal vectors have to present),
+ * i.e., we can get negative distances.
+ * @param concurrently If {@code true} and this visitor is thread-safe, then
+ * the visitor is applied concurrently when inspecting multiple mesh facets.
+ * @throws IllegalArgumentException if some parametr is wrong
+ */
+ public HausdorffDistanceVisitor(MeshModel mainModel, Strategy strategy, boolean relativeDistance, boolean concurrently) {
+ this(new HashSet<>(mainModel.getFacets()), strategy, relativeDistance, concurrently);
+ if (mainModel.getFacets().isEmpty()) {
+ throw new IllegalArgumentException("mainModel");
+ }
+ }
+
+ @Override
+ protected void visitMeshFacet(MeshFacet comparedFacet) {
+ int threads = Runtime.getRuntime().availableProcessors();
+ ExecutorService executor = Executors.newFixedThreadPool(threads);
+ List<Future<MeshVisitor>> results = new LinkedList<>();
+
+ // fo all my facets
+ for (Map.Entry<MeshFacet, List<Double>> entry: distances.entrySet()) {
+ List<MeshPoint> vertices = entry.getKey().getVertices();
+ List<Double> distList = entry.getValue();
+
+ if (concurrently()) {
+ for (int i = 0; i < vertices.size(); i++) { // for all my vertices
+ if (strategy == Strategy.POINT_TO_POINT) {
+ DistanceToVerticesVisitor visitor = new DistanceToVerticesVisitor(vertices.get(i), relativeDistance, true);
+ comparedFacet.accept(visitor);
+ Future<MeshVisitor> result = executor.submit(visitor); // fork and continue
+ results.add(result);
+ } else if (strategy == Strategy.POINT_TO_TRIANGLE) {
+ DistanceToTrianglesVisitor visitor = new DistanceToTrianglesVisitor(vertices.get(i), relativeDistance, true);
+ comparedFacet.accept(visitor);
+ Future<MeshVisitor> result = executor.submit(visitor); // fork and continue
+ results.add(result);
+ }
+ }
+
+ try {
+ boolean firstApplication = distList.isEmpty(); // first application of the visitor
+ for (int i = 0; i < results.size(); i++) { // wait ntil all computations are finished
+ if (strategy == Strategy.POINT_TO_POINT) {
+ DistanceToVerticesVisitor visitor = (DistanceToVerticesVisitor) results.get(i).get();
+ double dist = visitor.getDistance();
+ updateDistances(distList, firstApplication, dist, i);
+ } else if (strategy == Strategy.POINT_TO_TRIANGLE) {
+ DistanceToTrianglesVisitor visitor = (DistanceToTrianglesVisitor) results.get(i).get();
+ double dist = visitor.getDistance();
+ updateDistances(distList, firstApplication, dist, i);
+ }
+ }
+ } catch (InterruptedException | ExecutionException ex) {
+ Logger.getLogger(HausdorffDistanceVisitor.class.getName()).log(Level.SEVERE, null, ex);
+ }
+ } else { // sequentially
+ boolean firstApplication = distList.isEmpty(); // first application of the visitor
+ for (int i = 0; i < vertices.size(); i++) { // for all my vertices
+ if (strategy == Strategy.POINT_TO_POINT) {
+ DistanceToVerticesVisitor visitor = new DistanceToVerticesVisitor(vertices.get(i), relativeDistance, false);
+ comparedFacet.accept(visitor);
+ double dist = visitor.getDistance();
+ updateDistances(distList, firstApplication, dist, i);
+ } else if (strategy == Strategy.POINT_TO_TRIANGLE) {
+ DistanceToTrianglesVisitor visitor = new DistanceToTrianglesVisitor(vertices.get(i), relativeDistance, false);
+ comparedFacet.accept(visitor);
+ double dist = visitor.getDistance();
+ updateDistances(distList, firstApplication, dist, i);
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * Return Hausdorff distance for all points of the source mesh.
+ * A list of distances is returned for each mesh separaptely. Index of the
+ * list corresponds to the order of vertives in the mesh facet.
+ * Therefore, i-t number corresponds to the distance of i-th vertex of the
+ * source mesh.
+ *
+ * @return Hausdorff distance for all points of the source mesh
+ */
+ public Map<MeshFacet, List<Double>> getDistances() {
+ return Collections.unmodifiableMap(distances);
+ }
+
+ protected boolean isRelativeDistance() {
+ return relativeDistance;
+ }
+
+ protected Map<MeshFacet, List<Double>> getDistMap() {
+ return distances;
+ }
+
+ protected synchronized void updateDistances(List<Double> distList, boolean firstApplication, double dist, int index) {
+ if (firstApplication) {
+ distList.add(dist);
+ } else if (dist >= 0 && dist < distList.get(index)) {
+ distList.set(index, dist);
+ } else if (dist < 0 && dist > distList.get(index)) { // for relative dist only
+ distList.set(index, dist);
+ }
+ }
+}
diff --git a/Comparison/src/main/java/cz/fidentis/analyst/visitors/mesh/KdTreeBuildVisitor.java b/Comparison/src/main/java/cz/fidentis/analyst/visitors/mesh/KdTreeBuildVisitor.java
index 7538144f0bce7c8060f77dd6afb2d77e862ceae0..0c8d0af662d574d3582e552bb1a70fea59e9f572 100644
--- a/Comparison/src/main/java/cz/fidentis/analyst/visitors/mesh/KdTreeBuildVisitor.java
+++ b/Comparison/src/main/java/cz/fidentis/analyst/visitors/mesh/KdTreeBuildVisitor.java
@@ -14,11 +14,21 @@ import java.util.List;
* @author Maria Kocurekova
*/
-public class KdTreeBuildVisitor implements MeshVisitor {
+public class KdTreeBuildVisitor extends MeshVisitor {
+
private List<MeshFacet> facets = new LinkedList<>();
+
+ /**
+ *
+ * @param concurrently If {@code true} and this visitor is thread-safe, then
+ * the visitor is applied concurrently on multiple mesf facets.
+ */
+ public KdTreeBuildVisitor(boolean concurrently) {
+ super(concurrently);
+ }
@Override
- public void visitMeshFacet(MeshFacet facet) {
+ protected void visitMeshFacet(MeshFacet facet) {
this.facets.add(facet);
}
diff --git a/Comparison/src/main/java/cz/fidentis/analyst/visitors/mesh/Point2MeshTriVisitor.java b/Comparison/src/main/java/cz/fidentis/analyst/visitors/mesh/Point2MeshTriVisitor.java
deleted file mode 100644
index 050f68cb8462ca89e5d3e57a3f25af5ae10af784..0000000000000000000000000000000000000000
--- a/Comparison/src/main/java/cz/fidentis/analyst/visitors/mesh/Point2MeshTriVisitor.java
+++ /dev/null
@@ -1,175 +0,0 @@
-package cz.fidentis.analyst.visitors.mesh;
-
-import cz.fidentis.analyst.mesh.core.MeshFacet;
-import cz.fidentis.analyst.mesh.core.MeshPoint;
-import cz.fidentis.analyst.mesh.core.MeshPointImpl;
-import cz.fidentis.analyst.mesh.core.MeshTriangle;
-import java.util.ArrayList;
-import java.util.List;
-import javax.vecmath.Vector3d;
-
-/**
- * This visitor finds mesh points that are the closest to the given 3D point.
- * In contrast to the {@code Point2MeshVisitor} visitor,
- * which computes pont-to-point distance, this implementation measures
- * the distance to the triangles.
- *
- * Because there can be multiple triangles with the same minimal distance, the visitor
- * returns a list of mesh facets and a list of indices corresponding
- * to the facets.
- *
- * Returned lists have the same size.
- * {@code n = getIndices().get(i)} returns the index of the closest triangle on the i-th facet.
- * Then iterate into the n-th triangle of facet {@code getClosestFacets().get(i)} to get
- * the triangle instance.
- *
- * @author Matej Lukes
- * @author Radek Oslejsek
- */
-public class Point2MeshTriVisitor extends Point2MeshVisitor {
-
- public static final double EPS = 0.001; // tollerance for double computations
-
- /**
- * @param point Mesh point of which distance is computed. Must not be {@code null}
- * @param relativeDistance If true, the visitor calculates the distances with respect
- * to the normals of the source point (the normal has to be present),
- * i.e., we can get negative distance.
- * @throws IllegalArgumentException if some parametr is wrong
- */
- public Point2MeshTriVisitor(MeshPoint point, boolean relativeDistance) {
- super(point, relativeDistance);
- }
-
- /**
- * @param point 3D point of which distance is computed. Must not be {@code null}
- * @throws IllegalArgumentException if some parametr is wrong
- */
- public Point2MeshTriVisitor(Vector3d point) {
- this (new MeshPointImpl(point, null, null), true);
- }
-
- @Override
- public void visitMeshFacet(MeshFacet facet) {
- Vector3d my = getMyPoint().getPosition();
- int i = 0;
- for (MeshTriangle tri: facet) {
- Vector3d projection = getProjectionToTrianglePlane(my, tri);
- if (!isPointInTriangle(projection, tri)) {
- projection = getProjectionToClosestEdge(projection, tri);
- }
- checkAndUpdateDistance(projection, facet, i);
- }
- }
-
- /**
- * returns perpendicular projection from vertex to plane of triangle
- *
- * @param vertex vertex from which the projection is created
- * @param triangle triangle that defines the plane
- * @return projection to plane of triangle
- */
- private Vector3d getProjectionToTrianglePlane(Vector3d vertex, MeshTriangle triangle) {
- Vector3d ab = new Vector3d(triangle.vertex1.getPosition());
- ab.sub(triangle.vertex2.getPosition());
- Vector3d ac = new Vector3d(triangle.vertex1.getPosition());
- ac.sub(triangle.vertex3.getPosition());
- Vector3d normal = new Vector3d();
- normal.cross(ab, ac);
- normal.normalize();
-
- Vector3d projection = new Vector3d(vertex);
- Vector3d helperVector = new Vector3d(vertex);
- helperVector.sub(triangle.vertex1.getPosition());
- double dist = helperVector.dot(normal);
-
- projection.scaleAdd(-dist, normal, projection);
- return projection;
- }
-
- /**
- * checks if a point in the plane of triangle lies within the triangle
- *
- * @param point checked point
- * @param triangle triangle
- * @return true if point is in triangle, false otherwise
- */
- private boolean isPointInTriangle(Vector3d point, MeshTriangle triangle) {
- List<Vector3d> pointToVertices = new ArrayList<>();
- for (MeshPoint p: triangle) {
- Vector3d v = new Vector3d(p.getPosition());
- v.sub(point);
- pointToVertices.add(v);
- }
-
- double angleSum = 0;
- for (int i = 0; i < 3; i++) {
- angleSum += pointToVertices.get(i).angle(pointToVertices.get((i + 1) % 3));
- }
- angleSum -= 2 * Math.PI;
- return -EPS < angleSum && angleSum < EPS;
- }
-
- /**
- * returns projection to the nearest edge of the triangle
- *
- * @param point point in plane of triangle
- * @param triangle triangle
- * @return perpendicular projection to the nearest edge
- */
- private Vector3d getProjectionToClosestEdge(Vector3d point, MeshTriangle triangle) {
- Vector3d[] projections = new Vector3d[3];
- projections[0] = getProjectionToEdge(point, triangle.vertex1.getPosition(), triangle.vertex2.getPosition());
- projections[1] = getProjectionToEdge(point, triangle.vertex2.getPosition(), triangle.vertex3.getPosition());
- projections[2] = getProjectionToEdge(point, triangle.vertex3.getPosition(), triangle.vertex1.getPosition());
-
- double minDistance = Double.MAX_VALUE;
- Vector3d closestProjection = null;
- Vector3d helperVector = new Vector3d();
- for (Vector3d projection: projections) {
- helperVector.sub(point, projection);
- double dist = helperVector.length();
- if (dist < minDistance) {
- minDistance = dist;
- closestProjection = projection;
- }
- }
- return closestProjection;
- }
-
- /**
- * returns projection to edge
- *
- * @param point point in plane of triangle
- * @param edgeVertex1 first vertex of edge
- * @param edgeVertex2 second vertex of edge
- * @return projection to edge
- */
- private Vector3d getProjectionToEdge(Vector3d point, Vector3d edgeVertex1, Vector3d edgeVertex2) {
- Vector3d ab = new Vector3d();
- ab.sub(edgeVertex2, edgeVertex1);
- Vector3d ap = new Vector3d();
- ap.sub(point, edgeVertex1);
- double t = ab.dot(ap) / ab.lengthSquared();
- Vector3d projection = new Vector3d(
- edgeVertex1.x + t * ab.x,
- edgeVertex1.y + t * ab.y,
- edgeVertex1.z + t * ab.z);
-
- Vector3d projectionToEdgeVertex1 = new Vector3d();
- projectionToEdgeVertex1.sub(edgeVertex1, projection);
- Vector3d projectionToEdgeVertex2 = new Vector3d();
- projectionToEdgeVertex2.sub(edgeVertex2, projection);
-
- if (Math.abs((projectionToEdgeVertex1.length() + projectionToEdgeVertex2.length()) - ab.length()) < EPS) {
- return projection;
- }
-
- if (projectionToEdgeVertex1.length() < projectionToEdgeVertex2.length()) {
- return edgeVertex1;
- }
-
- return edgeVertex2;
- }
-
-}
diff --git a/Comparison/src/main/java/cz/fidentis/analyst/visitors/mesh/Point2MeshVisitor.java b/Comparison/src/main/java/cz/fidentis/analyst/visitors/mesh/Point2MeshVisitor.java
deleted file mode 100644
index 5208e7e202a4a2033728ff4b91d4b3f15681d8b7..0000000000000000000000000000000000000000
--- a/Comparison/src/main/java/cz/fidentis/analyst/visitors/mesh/Point2MeshVisitor.java
+++ /dev/null
@@ -1,130 +0,0 @@
-package cz.fidentis.analyst.visitors.mesh;
-
-import cz.fidentis.analyst.mesh.MeshVisitor;
-import cz.fidentis.analyst.mesh.core.MeshFacet;
-import cz.fidentis.analyst.mesh.core.MeshPoint;
-import cz.fidentis.analyst.mesh.core.MeshPointImpl;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import javax.vecmath.Vector3d;
-
-/**
- * This visitor finds mesh points that are the closest to the given 3D point.
- * Because there can be multiple points with the same minimal distance, the visitor
- * returns a list of mesh facets and a list of indices corresponding
- * to the facets.
- *
-* Returned lists have the same size.
- * {@code n = getIndices().get(i)} returns the index of the closest point on the i-th facet.
- * Then call {@code getClosestFacets().get(i).getVertex(n))} to get the closest point.
- *
- * @author Matej Lukes
- * @author Radek Oslejsek
- */
-public class Point2MeshVisitor implements MeshVisitor {
-
- private boolean relativeDist;
- private MeshPoint myPoint;
- private double distance = Double.POSITIVE_INFINITY;
- private int sign = 1;
- private final List<MeshFacet> closestFacets = new ArrayList<>();
- private final List<Integer> indices = new ArrayList<>();
-
- /**
- * @param point Mesh point of which distance is computed. Must not be {@code null}
- * @param relativeDistance If true, the visitor calculates the distances with respect
- * to the normals of the source point (the normal has to be present),
- * i.e., we can get negative distance.
- * @throws IllegalArgumentException if some parametr is wrong
- */
- public Point2MeshVisitor(MeshPoint point, boolean relativeDistance) {
- if (point == null) {
- throw new IllegalArgumentException("point");
- }
- if (point.getNormal() == null && relativeDistance) {
- throw new IllegalArgumentException("normal required for relative distance");
- }
- this.myPoint = point;
- this.relativeDist = relativeDistance;
- }
-
- /**
- * @param point 3D point of which distance is computed. Must not be {@code null}
- * @throws IllegalArgumentException if some parametr is wrong
- */
- public Point2MeshVisitor(Vector3d point) {
- this (new MeshPointImpl(point, null, null), true);
- }
-
- @Override
- public void visitMeshFacet(MeshFacet facet) {
- List<MeshPoint> vertices = facet.getVertices();
- for (int i = 0; i < vertices.size(); i++) {
- checkAndUpdateDistance(vertices.get(i).getPosition(), facet, i);
- }
- }
-
- /**
- * Returns distance to the closest mesh point.
- *
- * @return distance to the closest mesh point,
- * {@code Double.POSITIVE_INFINITY} if no distance has been calculated
- */
- public double getDistance() {
- return relativeDist ? sign * distance : distance;
- }
-
- /**
- * Returns indeces to the closest elements (points or triangles) of corresponding facet.
- *
- * @return indeces to the closest elements (points or triangles) of corresponding facet,
- * {@code null} if no search has been performed
- */
- public List<Integer> getIndices() {
- return Collections.unmodifiableList(indices);
- }
-
- /**
- * Returns the closest mesh facets (containing the closest mesh points).
- *
- * @return the closest mesh facets
- */
- public List<MeshFacet> getClosestFacets() {
- return Collections.unmodifiableList(closestFacets);
- }
-
- protected boolean isRelativeDist() {
- return relativeDist;
- }
-
- protected MeshPoint getMyPoint() {
- return myPoint;
- }
-
- protected int getSign() {
- return sign;
- }
-
- protected void checkAndUpdateDistance(Vector3d other, MeshFacet facet, int index) {
- Vector3d aux = new Vector3d(other);
- aux.sub(myPoint.getPosition());
- sign = relativeDist ? (int) Math.signum(aux.dot(myPoint.getNormal())): 1;
- double dist = aux.length();
-
- if (dist > distance) {
- return;
- }
-
- if (dist < distance) { // new closest point
- distance = dist;
- closestFacets.clear();
- indices.clear();
- closestFacets.add(facet);
- indices.add(index);
- } else { // the same distance
- closestFacets.add(facet);
- indices.add(index);
- }
- }
-}
diff --git a/Comparison/src/main/java/cz/fidentis/analyst/visitors/mesh/TriangleListVisitor.java b/Comparison/src/main/java/cz/fidentis/analyst/visitors/mesh/TriangleListVisitor.java
index bad7f8f962636bb68e0b31f2173fbdc140bb1328..d68315b17277833a1dfee477b3222f0e11cbd4bd 100644
--- a/Comparison/src/main/java/cz/fidentis/analyst/visitors/mesh/TriangleListVisitor.java
+++ b/Comparison/src/main/java/cz/fidentis/analyst/visitors/mesh/TriangleListVisitor.java
@@ -10,16 +10,29 @@ import java.util.List;
* A visitor that collects and returns a list of triangles.
* It is usefull for collecting triangles of multiple mesh facets.
* For iterating through triangles of a single facet, use the iterator instead.
- * Or iterate through the facet in a for-each cycle.
- *
+ * Or iterate through the facet in a for-each cycle.
+* <p>
+ * This visitor is thread-safe. A single instance of the visitor can be used
+ * to inspect multiple mesh models or facets simultaneously.
+ * </p>
+ *
* @author Radek Oslejsek
*/
-public class TriangleListVisitor implements MeshVisitor {
+public class TriangleListVisitor extends MeshVisitor {
private List<MeshTriangle> triangles = new ArrayList<>();
+
+ /**
+ *
+ * @param concurrently If {@code true} and this visitor is thread-safe, then
+ * the visitor is applied concurrently on multiple mesf facets.
+ */
+ public TriangleListVisitor(boolean concurrently) {
+ super(concurrently);
+ }
@Override
- public void visitMeshFacet(MeshFacet facet) {
+ protected synchronized void visitMeshFacet(MeshFacet facet) {
for (MeshTriangle tri : facet) {
triangles.add(tri);
}
diff --git a/Comparison/src/test/java/cz/fidentis/analyst/visitors/mesh/BoundingBoxVisitorTest.java b/Comparison/src/test/java/cz/fidentis/analyst/visitors/mesh/BoundingBoxVisitorTest.java
index f4ba298eccfae4528d9df881e79f9e9622e4861d..9fa2e80bfbf5e97c1bfca907a89b91398484e8a2 100644
--- a/Comparison/src/test/java/cz/fidentis/analyst/visitors/mesh/BoundingBoxVisitorTest.java
+++ b/Comparison/src/test/java/cz/fidentis/analyst/visitors/mesh/BoundingBoxVisitorTest.java
@@ -21,8 +21,8 @@ public class BoundingBoxVisitorTest {
void icoSphereTest() throws IOException {
MeshModel m = MeshObjLoader.read(new File(testFileDirectory.toFile(), "IcoSphere-20.obj"));
assertNotNull(m);
- BoundingBoxVisitor visitor = new BoundingBoxVisitor();
- m.accept(visitor);
+ BoundingBoxVisitor visitor = new BoundingBoxVisitor(false);
+ m.compute(visitor);
assertEquals(new Vector3d(0.8944249749183655, 1.0, 0.8506399989128113), visitor.getBoundingBox().getMaxPoint().getPosition());
assertEquals(new Vector3d(-0.8944249749183655, -1.0, -0.8506399989128113), visitor.getBoundingBox().getMinPoint().getPosition());
}
@@ -31,12 +31,12 @@ public class BoundingBoxVisitorTest {
void combinedTest() throws IOException {
MeshModel m = MeshObjLoader.read(new File(testFileDirectory.toFile(), "IcoSphere-20.obj"));
assertNotNull(m);
- BoundingBoxVisitor visitor = new BoundingBoxVisitor();
- m.accept(visitor);
+ BoundingBoxVisitor visitor = new BoundingBoxVisitor(false);
+ m.compute(visitor);
m = MeshObjLoader.read(new File(testFileDirectory.toFile(), "Tetrahedron.obj"));
assertNotNull(m);
- m.accept(visitor);
+ m.compute(visitor);
assertEquals(new Vector3d(1.0, 1.0, 1.0), visitor.getBoundingBox().getMaxPoint().getPosition());
assertEquals(new Vector3d(-1.0, -1.0, -1.0), visitor.getBoundingBox().getMinPoint().getPosition());
diff --git a/Comparison/src/test/java/cz/fidentis/analyst/visitors/mesh/DistanceToTrianglesVisitorTest.java b/Comparison/src/test/java/cz/fidentis/analyst/visitors/mesh/DistanceToTrianglesVisitorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..b267486328e95aeee4d950df624e8ee70f151886
--- /dev/null
+++ b/Comparison/src/test/java/cz/fidentis/analyst/visitors/mesh/DistanceToTrianglesVisitorTest.java
@@ -0,0 +1,89 @@
+package cz.fidentis.analyst.visitors.mesh;
+
+import cz.fidentis.analyst.mesh.core.CornerTableRow;
+import cz.fidentis.analyst.mesh.core.MeshFacet;
+import cz.fidentis.analyst.mesh.core.MeshFacetImpl;
+import cz.fidentis.analyst.mesh.core.MeshModel;
+import cz.fidentis.analyst.mesh.core.MeshPoint;
+import cz.fidentis.analyst.mesh.core.MeshPointImpl;
+import cz.fidentis.analyst.mesh.core.MeshTriangle;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.List;
+import javax.vecmath.Vector3d;
+import org.junit.jupiter.api.Assertions;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import org.junit.jupiter.api.Test;
+
+/**
+ *
+ * @author oslejsek
+ */
+public class DistanceToTrianglesVisitorTest {
+
+ protected MeshFacet getTrivialFacet(double offset, double size) {
+ MeshFacet facet = new MeshFacetImpl();
+ facet.addVertex(new MeshPointImpl(new Vector3d(0, 0, offset), new Vector3d(0, 0, 1), new Vector3d()));
+ facet.addVertex(new MeshPointImpl(new Vector3d(size, 0, offset), new Vector3d(0, 0, 1), new Vector3d()));
+ facet.addVertex(new MeshPointImpl(new Vector3d(0, size, offset), new Vector3d(0, 0, 1), new Vector3d()));
+
+ facet.getCornerTable().addRow(new CornerTableRow(0, -1));
+ facet.getCornerTable().addRow(new CornerTableRow(1, -1));
+ facet.getCornerTable().addRow(new CornerTableRow(2, -1));
+
+ return facet;
+ }
+
+ protected void distTest(double expectedDist, DistanceToTrianglesVisitor vis) {
+ MeshModel model = new MeshModel();
+ MeshFacet facet = getTrivialFacet(1.5, 1);
+ model.addFacet(facet);
+
+ model.compute(vis);
+ assertEquals(expectedDist, vis.getDistance());
+
+ List<Integer> closestTriangles = vis.getClosestTriangles();
+ List<MeshFacet> closestMeshes = vis.getClosestFacets();
+ assertNotNull(closestTriangles);
+ assertNotNull(closestMeshes);
+ assertEquals(1, closestTriangles.size());
+ assertEquals(1, closestMeshes.size());
+ assertEquals(facet, closestMeshes.get(0));
+ assertEquals(0, closestTriangles.get(0));
+ }
+
+ @Test
+ public void absoluteDistTest() {
+ MeshPoint point = new MeshPointImpl(new Vector3d(0,0,0), new Vector3d(0,0,-1), new Vector3d());
+ DistanceToTrianglesVisitor vis = new DistanceToTrianglesVisitor(point, false, false); // sequentially
+ distTest(1.5, vis);
+ }
+
+ @Test
+ public void relativeDistTest() {
+ MeshPoint point = new MeshPointImpl(new Vector3d(0,0,0), new Vector3d(0,0,-1), new Vector3d());
+ DistanceToTrianglesVisitor vis = new DistanceToTrianglesVisitor(point, true, false); // sequentially
+ distTest(-1.5, vis);
+ }
+
+ @Test
+ public void exactMatchTest() {
+ MeshPoint point = new MeshPointImpl(new Vector3d(0, 0, 1.5), new Vector3d(0, 0, 1), new Vector3d());
+ DistanceToTrianglesVisitor vis = new DistanceToTrianglesVisitor(point, true, false); // relative dist, sequentially
+ distTest(0, vis);
+ vis = new DistanceToTrianglesVisitor(point, false, false); // abosolute dist, sequentially
+ distTest(0, vis);
+ }
+
+ @Test
+ public void concurrencyTest() {
+ MeshPoint point = new MeshPointImpl(new Vector3d(0,0,0), new Vector3d(0,0,-1), new Vector3d());
+ DistanceToTrianglesVisitor vis = new DistanceToTrianglesVisitor(point, false, true); // absolute dist, concurrently
+ distTest(1.5, vis);
+ vis = new DistanceToTrianglesVisitor(point, true, true); // relative dist, concurrently
+ distTest(-1.5, vis);
+ }
+
+}
diff --git a/Comparison/src/test/java/cz/fidentis/analyst/visitors/mesh/Point2MeshVisitorTest.java b/Comparison/src/test/java/cz/fidentis/analyst/visitors/mesh/DistanceToVerticesVisitorTest.java
similarity index 56%
rename from Comparison/src/test/java/cz/fidentis/analyst/visitors/mesh/Point2MeshVisitorTest.java
rename to Comparison/src/test/java/cz/fidentis/analyst/visitors/mesh/DistanceToVerticesVisitorTest.java
index 7e60cf1d25dc3a0fae7bb06b149348b7332afa8c..6328a0c222800c058814d6b3296681d99fa534da 100644
--- a/Comparison/src/test/java/cz/fidentis/analyst/visitors/mesh/Point2MeshVisitorTest.java
+++ b/Comparison/src/test/java/cz/fidentis/analyst/visitors/mesh/DistanceToVerticesVisitorTest.java
@@ -1,8 +1,10 @@
package cz.fidentis.analyst.visitors.mesh;
+import cz.fidentis.analyst.mesh.MeshVisitor;
import cz.fidentis.analyst.mesh.core.CornerTableRow;
import cz.fidentis.analyst.mesh.core.MeshFacet;
import cz.fidentis.analyst.mesh.core.MeshFacetImpl;
+import cz.fidentis.analyst.mesh.core.MeshModel;
import cz.fidentis.analyst.mesh.core.MeshPoint;
import cz.fidentis.analyst.mesh.core.MeshPointImpl;
import java.util.List;
@@ -11,8 +13,9 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import org.junit.jupiter.api.Test;
-public class Point2MeshVisitorTest {
- private MeshFacet getTrivialFacet(double offset, double size) {
+public class DistanceToVerticesVisitorTest {
+
+ protected MeshFacet getTrivialFacet(double offset, double size) {
MeshFacet facet = new MeshFacetImpl();
facet.addVertex(new MeshPointImpl(new Vector3d(0, 0, offset), new Vector3d(0, 0, 1), new Vector3d()));
facet.addVertex(new MeshPointImpl(new Vector3d(size, 0, offset), new Vector3d(0, 0, 1), new Vector3d()));
@@ -24,17 +27,17 @@ public class Point2MeshVisitorTest {
return facet;
}
-
- @Test
- public void absoluteDistTest() {
+
+ protected void distTest(double expectedDist, DistanceToVerticesVisitor vis)
+ {
+ MeshModel model = new MeshModel();
MeshFacet facet = getTrivialFacet(1.5, 1);
- MeshPoint point = new MeshPointImpl(new Vector3d(0,0,0), new Vector3d(0,0,-1), new Vector3d());
+ model.addFacet(facet);
- Point2MeshVisitor vis = new Point2MeshVisitor(point, false);
- facet.accept(vis);
- assertEquals(1.5, vis.getDistance());
+ model.compute(vis);
+ assertEquals(expectedDist, vis.getDistance());
- List<Integer> closestPoints = vis.getIndices();
+ List<Integer> closestPoints = vis.getClosestVertices();
List<MeshFacet> closestMeshes = vis.getClosestFacets();
assertNotNull(closestPoints);
assertNotNull(closestMeshes);
@@ -44,43 +47,35 @@ public class Point2MeshVisitorTest {
assertEquals(0, closestPoints.get(0));
}
+ @Test
+ public void absoluteDistTest() {
+ MeshPoint point = new MeshPointImpl(new Vector3d(0,0,0), new Vector3d(0,0,-1), new Vector3d());
+ DistanceToVerticesVisitor vis = new DistanceToVerticesVisitor(point, false, false); // sequentially
+ distTest(1.5, vis);
+ }
+
@Test
public void relativeDistTest() {
- MeshFacet facet = getTrivialFacet(1.5, 1);
MeshPoint point = new MeshPointImpl(new Vector3d(0,0,0), new Vector3d(0,0,-1), new Vector3d());
-
- Point2MeshVisitor vis = new Point2MeshVisitor(point, true);
- facet.accept(vis);
- assertEquals(-1.5, vis.getDistance());
-
- List<Integer> closestPoints = vis.getIndices();
- List<MeshFacet> closestMeshes = vis.getClosestFacets();
- assertNotNull(closestPoints);
- assertNotNull(closestMeshes);
- assertEquals(1, closestPoints.size());
- assertEquals(1, closestMeshes.size());
- assertEquals(facet, closestMeshes.get(0));
- assertEquals(0, closestPoints.get(0));
+ DistanceToVerticesVisitor vis = new DistanceToVerticesVisitor(point, true, false); // sequentially
+ distTest(-1.5, vis);
}
@Test
public void exactMatchTest() {
- MeshFacet facet = getTrivialFacet(1.5, 1);
MeshPoint point = new MeshPointImpl(new Vector3d(0, 0, 1.5), new Vector3d(0, 0, 1), new Vector3d());
-
- System.out.println(facet.getVertices());
-
- Point2MeshVisitor vis = new Point2MeshVisitor(point, false);
- facet.accept(vis);
- assertEquals(0, vis.getDistance());
-
- List<Integer> closestPoints = vis.getIndices();
- List<MeshFacet> closestMeshes = vis.getClosestFacets();
- assertNotNull(closestPoints);
- assertNotNull(closestMeshes);
- assertEquals(1, closestPoints.size());
- assertEquals(1, closestMeshes.size());
- assertEquals(facet, closestMeshes.get(0));
- assertEquals(0, closestPoints.get(0));
+ DistanceToVerticesVisitor vis = new DistanceToVerticesVisitor(point, true, false); // relative dist, sequentially
+ distTest(0, vis);
+ vis = new DistanceToVerticesVisitor(point, false, false); // abosolute dist, sequentially
+ distTest(0, vis);
+ }
+
+ @Test
+ public void concurrencyTest() {
+ MeshPoint point = new MeshPointImpl(new Vector3d(0,0,0), new Vector3d(0,0,-1), new Vector3d());
+ DistanceToVerticesVisitor vis = new DistanceToVerticesVisitor(point, false, true); // absolute dist, concurrently
+ distTest(1.5, vis);
+ vis = new DistanceToVerticesVisitor(point, true, true); // relative dist, concurrently
+ distTest(-1.5, vis);
}
}
diff --git a/Comparison/src/test/java/cz/fidentis/analyst/visitors/mesh/HausdorffDistMeshTriVisitorTest.java b/Comparison/src/test/java/cz/fidentis/analyst/visitors/mesh/HausdorffDistMeshTriVisitorTest.java
deleted file mode 100644
index 6f6b4264778966afdf53d232f49c29051563831a..0000000000000000000000000000000000000000
--- a/Comparison/src/test/java/cz/fidentis/analyst/visitors/mesh/HausdorffDistMeshTriVisitorTest.java
+++ /dev/null
@@ -1,89 +0,0 @@
-package cz.fidentis.analyst.visitors.mesh;
-
-import cz.fidentis.analyst.visitors.mesh.HausdorffDistMeshTriVisitor;
-import cz.fidentis.analyst.mesh.core.CornerTableRow;
-import cz.fidentis.analyst.mesh.core.MeshFacet;
-import cz.fidentis.analyst.mesh.core.MeshFacetImpl;
-import cz.fidentis.analyst.mesh.core.MeshPointImpl;
-import java.util.List;
-import java.util.Map;
-import javax.vecmath.Vector3d;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import org.junit.jupiter.api.Test;
-
-public class HausdorffDistMeshTriVisitorTest {
-
- private MeshFacet getTrivialFacet(double offset, double size) {
- MeshFacet facet = new MeshFacetImpl();
- facet.addVertex(new MeshPointImpl(new Vector3d(0, 0, offset), new Vector3d(0, 0, 1), new Vector3d()));
- facet.addVertex(new MeshPointImpl(new Vector3d(size, 0, offset), new Vector3d(0, 0, 1), new Vector3d()));
- facet.addVertex(new MeshPointImpl(new Vector3d(0, size, offset), new Vector3d(0, 0, 1), new Vector3d()));
-
- facet.getCornerTable().addRow(new CornerTableRow(0, -1));
- facet.getCornerTable().addRow(new CornerTableRow(1, -1));
- facet.getCornerTable().addRow(new CornerTableRow(2, -1));
-
- return facet;
- }
-
- @Test
- public void visitToVerticesTest() {
- MeshFacet mainFacet = getTrivialFacet(1, 1);
- MeshFacet comparedFacet = getTrivialFacet(1.5, 1);
-
- HausdorffDistMeshTriVisitor hausdorffDistance = new HausdorffDistMeshTriVisitor(mainFacet, false);
- hausdorffDistance.visitMeshFacet(comparedFacet);
-
- Map<MeshFacet, List<Double>> map = hausdorffDistance.getDistances();
- List<Double> results = map.get(mainFacet);
- for (int i = 0; i < mainFacet.getNumberOfVertices(); i++) {
- assertEquals(0.5, results.get(i));
- }
- }
-
- @Test
- public void visitToVerticesBehindMeshTest() {
- MeshFacet mainFacet = getTrivialFacet(1, 1);
- MeshFacet comparedFacet = getTrivialFacet(-1.5, 1);
-
- HausdorffDistMeshTriVisitor hausdorffDistance = new HausdorffDistMeshTriVisitor(mainFacet, false);
- hausdorffDistance.visitMeshFacet(comparedFacet);
-
- Map<MeshFacet, List<Double>> map = hausdorffDistance.getDistances();
- List<Double> results = map.get(mainFacet);
- for (int i = 0; i < mainFacet.getNumberOfVertices(); i++) {
- assertEquals(2.5, results.get(i));
- }
- }
-
- @Test
- public void visitToVerticesRelativeDistanceTest() {
- MeshFacet mainFacet = getTrivialFacet(1, 1);
- MeshFacet comparedFacet = getTrivialFacet(1.5, 1);
-
- HausdorffDistMeshTriVisitor hausdorffDistance = new HausdorffDistMeshTriVisitor(mainFacet, true);
- hausdorffDistance.visitMeshFacet(comparedFacet);
-
- Map<MeshFacet, List<Double>> map = hausdorffDistance.getDistances();
- List<Double> results = map.get(mainFacet);
- for (int i = 0; i < mainFacet.getNumberOfVertices(); i++) {
- assertEquals(0.5, results.get(i));
- }
- }
-
- @Test
- public void visitToVerticesBehindMeshRelativeDistanceTest() {
- MeshFacet mainFacet = getTrivialFacet(1, 1);
- MeshFacet comparedFacet = getTrivialFacet(-1.5, 1);
-
- HausdorffDistMeshTriVisitor hausdorffDistance = new HausdorffDistMeshTriVisitor(mainFacet, true);
- hausdorffDistance.visitMeshFacet(comparedFacet);
-
- Map<MeshFacet, List<Double>> map = hausdorffDistance.getDistances();
- List<Double> results = map.get(mainFacet);
- for (int i = 0; i < mainFacet.getNumberOfVertices(); i++) {
- assertEquals(-2.5, results.get(i));
- }
- }
-
-}
diff --git a/Comparison/src/test/java/cz/fidentis/analyst/visitors/mesh/HausdorffDistMeshVisitorTest.java b/Comparison/src/test/java/cz/fidentis/analyst/visitors/mesh/HausdorffDistMeshVisitorTest.java
deleted file mode 100644
index ffa1210c0e2db3391d3a7dd27182856040a4eedd..0000000000000000000000000000000000000000
--- a/Comparison/src/test/java/cz/fidentis/analyst/visitors/mesh/HausdorffDistMeshVisitorTest.java
+++ /dev/null
@@ -1,89 +0,0 @@
-package cz.fidentis.analyst.visitors.mesh;
-
-import cz.fidentis.analyst.visitors.mesh.HausdorffDistMeshVisitor;
-import cz.fidentis.analyst.mesh.core.CornerTableRow;
-import cz.fidentis.analyst.mesh.core.MeshFacet;
-import cz.fidentis.analyst.mesh.core.MeshFacetImpl;
-import cz.fidentis.analyst.mesh.core.MeshPointImpl;
-import java.util.List;
-import java.util.Map;
-import javax.vecmath.Vector3d;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import org.junit.jupiter.api.Test;
-
-public class HausdorffDistMeshVisitorTest {
-
- private MeshFacet getTrivialFacet(double offset, double size) {
- MeshFacet facet = new MeshFacetImpl();
- facet.addVertex(new MeshPointImpl(new Vector3d(0, 0, offset), new Vector3d(0, 0, 1), new Vector3d()));
- facet.addVertex(new MeshPointImpl(new Vector3d(size, 0, offset), new Vector3d(0, 0, 1), new Vector3d()));
- facet.addVertex(new MeshPointImpl(new Vector3d(0, size, offset), new Vector3d(0, 0, 1), new Vector3d()));
-
- facet.getCornerTable().addRow(new CornerTableRow(0, -1));
- facet.getCornerTable().addRow(new CornerTableRow(1, -1));
- facet.getCornerTable().addRow(new CornerTableRow(2, -1));
-
- return facet;
- }
-
- @Test
- public void visitToVerticesTest() {
- MeshFacet mainFacet = getTrivialFacet(1, 1);
- MeshFacet comparedFacet = getTrivialFacet(1.5, 1);
-
- HausdorffDistMeshVisitor hausdorffDistance = new HausdorffDistMeshVisitor(mainFacet, false);
- hausdorffDistance.visitMeshFacet(comparedFacet);
-
- Map<MeshFacet, List<Double>> map = hausdorffDistance.getDistances();
- List<Double> results = map.get(mainFacet);
- for (int i = 0; i < mainFacet.getNumberOfVertices(); i++) {
- assertEquals(0.5, results.get(i));
- }
- }
-
- @Test
- public void visitToVerticesBehindMeshTest() {
- MeshFacet mainFacet = getTrivialFacet(1, 1);
- MeshFacet comparedFacet = getTrivialFacet(-1.5, 1);
-
- HausdorffDistMeshVisitor hausdorffDistance = new HausdorffDistMeshVisitor(mainFacet, false);
- hausdorffDistance.visitMeshFacet(comparedFacet);
-
- Map<MeshFacet, List<Double>> map = hausdorffDistance.getDistances();
- List<Double> results = map.get(mainFacet);
- for (int i = 0; i < mainFacet.getNumberOfVertices(); i++) {
- assertEquals(2.5, results.get(i));
- }
- }
-
- @Test
- public void visitToVerticesRelativeDistanceTest() {
- MeshFacet mainFacet = getTrivialFacet(1, 1);
- MeshFacet comparedFacet = getTrivialFacet(1.5, 1);
-
- HausdorffDistMeshVisitor hausdorffDistance = new HausdorffDistMeshVisitor(mainFacet, true);
- hausdorffDistance.visitMeshFacet(comparedFacet);
-
- Map<MeshFacet, List<Double>> map = hausdorffDistance.getDistances();
- List<Double> results = map.get(mainFacet);
- for (int i = 0; i < mainFacet.getNumberOfVertices(); i++) {
- assertEquals(0.5, results.get(i));
- }
- }
-
- @Test
- public void visitToVerticesBehindMeshRelativeDistanceTest() {
- MeshFacet mainFacet = getTrivialFacet(1, 1);
- MeshFacet comparedFacet = getTrivialFacet(-1.5, 1);
-
- HausdorffDistMeshVisitor hausdorffDistance = new HausdorffDistMeshVisitor(mainFacet, true);
- hausdorffDistance.visitMeshFacet(comparedFacet);
-
- Map<MeshFacet, List<Double>> map = hausdorffDistance.getDistances();
- List<Double> results = map.get(mainFacet);
- for (int i = 0; i < mainFacet.getNumberOfVertices(); i++) {
- assertEquals(-2.5, results.get(i));
- }
- }
-
-}
diff --git a/Comparison/src/test/java/cz/fidentis/analyst/visitors/mesh/HausdorffDistanceVisitorTest.java b/Comparison/src/test/java/cz/fidentis/analyst/visitors/mesh/HausdorffDistanceVisitorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..e682fecfdff373fb7e19e4218d8e3786587654cf
--- /dev/null
+++ b/Comparison/src/test/java/cz/fidentis/analyst/visitors/mesh/HausdorffDistanceVisitorTest.java
@@ -0,0 +1,101 @@
+package cz.fidentis.analyst.visitors.mesh;
+
+import cz.fidentis.analyst.mesh.core.CornerTableRow;
+import cz.fidentis.analyst.mesh.core.MeshFacet;
+import cz.fidentis.analyst.mesh.core.MeshFacetImpl;
+import cz.fidentis.analyst.mesh.core.MeshModel;
+import cz.fidentis.analyst.mesh.core.MeshPointImpl;
+import cz.fidentis.analyst.visitors.mesh.HausdorffDistanceVisitor.Strategy;
+import java.util.List;
+import java.util.Map;
+import javax.vecmath.Vector3d;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import org.junit.jupiter.api.Test;
+
+public class HausdorffDistanceVisitorTest {
+
+ protected MeshFacet getTrivialFacet(double offset, double size) {
+ MeshFacet facet = new MeshFacetImpl();
+ facet.addVertex(new MeshPointImpl(new Vector3d(0, 0, offset), new Vector3d(0, 0, 1), new Vector3d()));
+ facet.addVertex(new MeshPointImpl(new Vector3d(size, 0, offset), new Vector3d(0, 0, 1), new Vector3d()));
+ facet.addVertex(new MeshPointImpl(new Vector3d(0, size, offset), new Vector3d(0, 0, 1), new Vector3d()));
+
+ facet.getCornerTable().addRow(new CornerTableRow(0, -1));
+ facet.getCornerTable().addRow(new CornerTableRow(1, -1));
+ facet.getCornerTable().addRow(new CornerTableRow(2, -1));
+
+ return facet;
+ }
+
+ protected MeshModel getTrivialModel(double offset, double size) {
+ MeshModel model = new MeshModel();
+ model.addFacet(getTrivialFacet(offset, size));
+ return model;
+ }
+
+ protected void testDist(HausdorffDistanceVisitor vis, MeshModel firstModel, MeshModel secondModel, double expectedDist) {
+ MeshFacet firstFacet = firstModel.getFacets().get(0);
+
+ secondModel.compute(vis);
+ Map<MeshFacet, List<Double>> map = vis.getDistances();
+
+ assertTrue(map.containsKey(firstFacet));
+ List<Double> results = map.get(firstFacet);
+ for (int i = 0; i < firstFacet.getNumberOfVertices(); i++) {
+ assertEquals(expectedDist, results.get(i));
+ }
+ }
+
+
+ @Test
+ public void visitToVerticesTest() {
+ MeshModel firstModel = getTrivialModel(1, 1);
+ MeshModel secondModel = getTrivialModel(1.5, 1);
+ testDist(new HausdorffDistanceVisitor(firstModel, Strategy.POINT_TO_POINT, false, false), firstModel, secondModel, 0.5);
+ testDist(new HausdorffDistanceVisitor(secondModel, Strategy.POINT_TO_POINT,false, false), secondModel, firstModel, 0.5);
+ testDist(new HausdorffDistanceVisitor(firstModel, Strategy.POINT_TO_TRIANGLE, false, false), firstModel, secondModel, 0.5);
+ testDist(new HausdorffDistanceVisitor(secondModel, Strategy.POINT_TO_TRIANGLE,false, false), secondModel, firstModel, 0.5);
+ }
+
+ @Test
+ public void visitToVerticesBehindMeshTest() {
+ MeshModel firstModel = getTrivialModel(1, 1);
+ MeshModel secondModel = getTrivialModel(-1.5, 1);
+ testDist(new HausdorffDistanceVisitor(firstModel, Strategy.POINT_TO_POINT,false, false), firstModel, secondModel, 2.5);
+ testDist(new HausdorffDistanceVisitor(secondModel, Strategy.POINT_TO_POINT,false, false), secondModel, firstModel, 2.5);
+ testDist(new HausdorffDistanceVisitor(firstModel, Strategy.POINT_TO_TRIANGLE,false, false), firstModel, secondModel, 2.5);
+ testDist(new HausdorffDistanceVisitor(secondModel, Strategy.POINT_TO_TRIANGLE,false, false), secondModel, firstModel, 2.5);
+ }
+
+ @Test
+ public void visitToVerticesRelativeDistanceTest() {
+ MeshModel firstModel = getTrivialModel(1, 1);
+ MeshModel secondModel = getTrivialModel(1.5, 1);
+ testDist(new HausdorffDistanceVisitor(firstModel, Strategy.POINT_TO_POINT,true, false), firstModel, secondModel, 0.5);
+ testDist(new HausdorffDistanceVisitor(secondModel, Strategy.POINT_TO_POINT,true, false), secondModel, firstModel, -0.5);
+ testDist(new HausdorffDistanceVisitor(firstModel, Strategy.POINT_TO_TRIANGLE,true, false), firstModel, secondModel, 0.5);
+ testDist(new HausdorffDistanceVisitor(secondModel, Strategy.POINT_TO_TRIANGLE,true, false), secondModel, firstModel, -0.5);
+ }
+
+ @Test
+ public void visitToVerticesBehindMeshRelativeDistanceTest() {
+ MeshModel firstModel = getTrivialModel(1, 1);
+ MeshModel secondModel = getTrivialModel(-1.5, 1);
+ testDist(new HausdorffDistanceVisitor(firstModel, Strategy.POINT_TO_POINT,true, false), firstModel, secondModel, -2.5);
+ testDist(new HausdorffDistanceVisitor(secondModel, Strategy.POINT_TO_POINT,true, false), secondModel, firstModel, 2.5);
+ testDist(new HausdorffDistanceVisitor(firstModel, Strategy.POINT_TO_TRIANGLE,true, false), firstModel, secondModel, -2.5);
+ testDist(new HausdorffDistanceVisitor(secondModel, Strategy.POINT_TO_TRIANGLE,true, false), secondModel, firstModel, 2.5);
+ }
+
+ @Test
+ public void concurrencyTest() {
+ MeshModel firstModel = getTrivialModel(1, 1);
+ MeshModel secondModel = getTrivialModel(1.5, 1);
+ testDist(new HausdorffDistanceVisitor(firstModel, Strategy.POINT_TO_POINT,false, true), firstModel, secondModel, 0.5);
+ testDist(new HausdorffDistanceVisitor(secondModel, Strategy.POINT_TO_POINT,false, true), secondModel, firstModel, 0.5);
+ testDist(new HausdorffDistanceVisitor(firstModel, Strategy.POINT_TO_TRIANGLE,false, true), firstModel, secondModel, 0.5);
+ testDist(new HausdorffDistanceVisitor(secondModel, Strategy.POINT_TO_TRIANGLE,false, true), secondModel, firstModel, 0.5);
+ }
+
+}
diff --git a/Comparison/src/test/java/cz/fidentis/analyst/visitors/mesh/KdTreeBuildVisitorTest.java b/Comparison/src/test/java/cz/fidentis/analyst/visitors/mesh/KdTreeBuildVisitorTest.java
index 97c6c24cc7a20e00aa19008898e57b07b06bad70..599c56acb339c5372cde6157862a1f456bd63e79 100644
--- a/Comparison/src/test/java/cz/fidentis/analyst/visitors/mesh/KdTreeBuildVisitorTest.java
+++ b/Comparison/src/test/java/cz/fidentis/analyst/visitors/mesh/KdTreeBuildVisitorTest.java
@@ -21,8 +21,8 @@ public class KdTreeBuildVisitorTest {
void testCreateVisitorsAndGetKdTree() throws IOException {
MeshModel m = MeshObjLoader.read(new File(testFileDirectory.toFile(), "IcoSphere-20.obj"));
assertNotNull(m);
- KdTreeBuildVisitor visitor = new KdTreeBuildVisitor();
- m.accept(visitor);
+ KdTreeBuildVisitor visitor = new KdTreeBuildVisitor(false);
+ m.compute(visitor);
assertEquals(1, m.getFacets().size());
List<MeshPoint> points = new LinkedList<>();
@@ -38,15 +38,15 @@ public class KdTreeBuildVisitorTest {
KdNode node = tree.closestNode(p);
assertNotNull(node);
- assertEquals(node.get3dLocation(), p.getPosition());
+ assertEquals(node.getLocation(), p.getPosition());
}
@Test
void testCreateVisitorsAndGetKdTreeDuplicate() throws IOException {
MeshModel m = MeshObjLoader.read(new File(testFileDirectory.toFile(), "IcoSphere-20.obj"));
assertNotNull(m);
- KdTreeBuildVisitor visitor = new KdTreeBuildVisitor();
- m.accept(visitor);
+ KdTreeBuildVisitor visitor = new KdTreeBuildVisitor(false);
+ m.compute(visitor);
assertEquals(1, m.getFacets().size());
List<MeshPoint> points = new LinkedList<>();
@@ -70,7 +70,7 @@ public class KdTreeBuildVisitorTest {
KdNode node = tree.closestNode(p);
assertNotNull(node);
- assertEquals(node.get3dLocation(), p.getPosition());
+ assertEquals(node.getLocation(), p.getPosition());
assertEquals(2, node.getFacets().size());
}
diff --git a/Comparison/src/test/java/cz/fidentis/analyst/visitors/mesh/Point2MeshTriVisitorTest.java b/Comparison/src/test/java/cz/fidentis/analyst/visitors/mesh/Point2MeshTriVisitorTest.java
deleted file mode 100644
index bb3a99054bc862537821fb3d94562a8001c0ddd8..0000000000000000000000000000000000000000
--- a/Comparison/src/test/java/cz/fidentis/analyst/visitors/mesh/Point2MeshTriVisitorTest.java
+++ /dev/null
@@ -1,318 +0,0 @@
-package cz.fidentis.analyst.visitors.mesh;
-
-import cz.fidentis.analyst.mesh.core.CornerTableRow;
-import cz.fidentis.analyst.mesh.core.MeshFacet;
-import cz.fidentis.analyst.mesh.core.MeshFacetImpl;
-import cz.fidentis.analyst.mesh.core.MeshPoint;
-import cz.fidentis.analyst.mesh.core.MeshPointImpl;
-import cz.fidentis.analyst.mesh.core.MeshTriangle;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.util.List;
-import javax.vecmath.Vector3d;
-import org.junit.jupiter.api.Assertions;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-import org.junit.jupiter.api.Test;
-
-/**
- *
- * @author oslejsek
- */
-public class Point2MeshTriVisitorTest {
- private MeshFacet getTrivialFacet(double offset, double size) {
- MeshFacet facet = new MeshFacetImpl();
- facet.addVertex(new MeshPointImpl(new Vector3d(0, 0, offset), new Vector3d(0, 0, 1), new Vector3d()));
- facet.addVertex(new MeshPointImpl(new Vector3d(size, 0, offset), new Vector3d(0, 0, 1), new Vector3d()));
- facet.addVertex(new MeshPointImpl(new Vector3d(0, size, offset), new Vector3d(0, 0, 1), new Vector3d()));
-
- facet.getCornerTable().addRow(new CornerTableRow(0, -1));
- facet.getCornerTable().addRow(new CornerTableRow(1, -1));
- facet.getCornerTable().addRow(new CornerTableRow(2, -1));
-
- return facet;
- }
-
- @Test
- public void absoluteDistTest() {
- MeshFacet facet = getTrivialFacet(1.5, 1);
- MeshPoint point = new MeshPointImpl(new Vector3d(0,0,0), new Vector3d(0,0,-1), new Vector3d());
-
- Point2MeshVisitor vis = new Point2MeshTriVisitor(point, false);
- facet.accept(vis);
- assertEquals(1.5, vis.getDistance());
-
- List<Integer> closestPoints = vis.getIndices();
- List<MeshFacet> closestMeshes = vis.getClosestFacets();
- assertNotNull(closestPoints);
- assertNotNull(closestMeshes);
- assertEquals(1, closestPoints.size());
- assertEquals(1, closestMeshes.size());
- assertEquals(facet, closestMeshes.get(0));
- assertEquals(0, closestPoints.get(0));
- }
-
- @Test
- public void relativeDistTest() {
- MeshFacet facet = getTrivialFacet(1.5, 1);
- MeshPoint point = new MeshPointImpl(new Vector3d(0,0,0), new Vector3d(0,0,-1), new Vector3d());
-
- Point2MeshVisitor vis = new Point2MeshTriVisitor(point, true);
- facet.accept(vis);
- assertEquals(-1.5, vis.getDistance());
-
- List<Integer> closestPoints = vis.getIndices();
- List<MeshFacet> closestMeshes = vis.getClosestFacets();
- assertNotNull(closestPoints);
- assertNotNull(closestMeshes);
- assertEquals(1, closestPoints.size());
- assertEquals(1, closestMeshes.size());
- assertEquals(facet, closestMeshes.get(0));
- assertEquals(0, closestPoints.get(0));
- }
-
- @Test
- public void exactMatchTest() {
- MeshFacet facet = getTrivialFacet(1.5, 1);
- MeshPoint point = new MeshPointImpl(new Vector3d(0, 0, 1.5), new Vector3d(0, 0, 1), new Vector3d());
-
- System.out.println(facet.getVertices());
-
- Point2MeshVisitor vis = new Point2MeshTriVisitor(point, false);
- facet.accept(vis);
- assertEquals(0, vis.getDistance());
-
- System.out.println(facet.getVertices());
-
- List<Integer> closestPoints = vis.getIndices();
- List<MeshFacet> closestMeshes = vis.getClosestFacets();
- assertNotNull(closestPoints);
- assertNotNull(closestMeshes);
- assertEquals(1, closestPoints.size());
- assertEquals(1, closestMeshes.size());
- assertEquals(facet, closestMeshes.get(0));
- assertEquals(0, closestPoints.get(0));
- }
-
- @Test
- public void getProjectionToTrianglePlaneTest()
- throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
- Class<?>[] argClasses = new Class[2];
- argClasses[0] = Vector3d.class;
- argClasses[1] = MeshTriangle.class;
- Method method = Point2MeshTriVisitor.class.getDeclaredMethod("getProjectionToTrianglePlane", argClasses);
- method.setAccessible(true);
- Object[] args = new Object[2];
-
- args[0] = new Vector3d(0, 0.5, 1);
- MeshTriangle triangle = new MeshTriangle(
- new MeshPointImpl(new Vector3d(1, 0, 0), null, null),
- new MeshPointImpl(new Vector3d(1, 2, 0), null, null),
- new MeshPointImpl(new Vector3d(2, 0, 0), null, null)
- );
- args[1] = triangle;
-
- Point2MeshTriVisitor hausdorffDistance = new Point2MeshTriVisitor(new MeshPointImpl(new Vector3d(), null, null), false);
- Vector3d result = (Vector3d) method.invoke(hausdorffDistance, args);
-
- Assertions.assertEquals(0d, result.x);
- Assertions.assertEquals(0.5d, result.y);
- Assertions.assertEquals(0d, result.z);
- }
-
- @Test
- public void getProjectionToTrianglePlaneBelowPLaneTest()
- throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
- Class<?>[] argClasses = new Class[2];
- argClasses[0] = Vector3d.class;
- argClasses[1] = MeshTriangle.class;
- Method method = Point2MeshTriVisitor.class.getDeclaredMethod("getProjectionToTrianglePlane", argClasses);
- method.setAccessible(true);
- Object[] args = new Object[2];
-
- args[0] = new Vector3d(0, 0.5, 1);
- MeshTriangle triangle = new MeshTriangle(
- new MeshPointImpl(new Vector3d(1, 0, 0), null, null),
- new MeshPointImpl(new Vector3d(1, 2, 0), null, null),
- new MeshPointImpl(new Vector3d(2, 0, 0), null, null)
- );
- args[1] = triangle;
-
- Point2MeshTriVisitor hausdorffDistance = new Point2MeshTriVisitor(new MeshPointImpl(new Vector3d(), null, null), false);
- Vector3d result = (Vector3d) method.invoke(hausdorffDistance, args);
-
- Assertions.assertEquals(0d, result.x);
- Assertions.assertEquals(0.5d, result.y);
- Assertions.assertEquals(0d, result.z);
- }
-
- @Test
- public void isPointInTriangleInsideTriangleTest()
- throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
- Class<?>[] argClasses = new Class[2];
- argClasses[0] = Vector3d.class;
- argClasses[1] = MeshTriangle.class;
- Method method = Point2MeshTriVisitor.class.getDeclaredMethod("isPointInTriangle", argClasses);
- method.setAccessible(true);
- Object[] args = new Object[2];
-
- args[0] = new Vector3d(1.2, 0.2, 0);
- MeshTriangle triangle = new MeshTriangle(
- new MeshPointImpl(new Vector3d(1, 0, 0), null, null),
- new MeshPointImpl(new Vector3d(1, 2, 0), null, null),
- new MeshPointImpl(new Vector3d(2, 0, 0), null, null)
- );
- args[1] = triangle;
-
- Point2MeshTriVisitor hausdorffDistance = new Point2MeshTriVisitor(new MeshPointImpl(new Vector3d(), null, null), false);
- boolean result = (boolean) method.invoke(hausdorffDistance, args);
-
- Assertions.assertTrue(result);
- }
-
- @Test
- public void isPointInTriangleOutsideTriangleTest()
- throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
- Class<?>[] argClasses = new Class[2];
- argClasses[0] = Vector3d.class;
- argClasses[1] = MeshTriangle.class;
- Method method = Point2MeshTriVisitor.class.getDeclaredMethod("isPointInTriangle", argClasses);
- method.setAccessible(true);
- Object[] args = new Object[2];
-
- args[0] = new Vector3d(0, 0.5, 0);
- MeshTriangle triangle = new MeshTriangle(
- new MeshPointImpl(new Vector3d(1, 0, 0), null, null),
- new MeshPointImpl(new Vector3d(1, 2, 0), null, null),
- new MeshPointImpl(new Vector3d(2, 0, 0), null, null)
- );
- args[1] = triangle;
-
- Point2MeshTriVisitor hausdorffDistance = new Point2MeshTriVisitor(new MeshPointImpl(new Vector3d(), null, null), false);
- boolean result = (boolean) method.invoke(hausdorffDistance, args);
-
- Assertions.assertFalse(result);
- }
-
- @Test
- public void getProjectionToClosestEdgeTest()
- throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
- Class<?>[] argClasses = new Class[2];
- argClasses[0] = Vector3d.class;
- argClasses[1] = MeshTriangle.class;
- Method method = Point2MeshTriVisitor.class.getDeclaredMethod("getProjectionToClosestEdge", argClasses);
- method.setAccessible(true);
- Object[] args = new Object[2];
-
- args[0] = new Vector3d(0, 0.5, 0);
- MeshTriangle triangle = new MeshTriangle(
- new MeshPointImpl(new Vector3d(1, 0, 0), null, null),
- new MeshPointImpl(new Vector3d(1, 2, 0), null, null),
- new MeshPointImpl(new Vector3d(2, 0, 0), null, null)
- );
- args[1] = triangle;
-
- Point2MeshTriVisitor hausdorffDistance = new Point2MeshTriVisitor(new MeshPointImpl(new Vector3d(), null, null), false);
- Vector3d result = (Vector3d) method.invoke(hausdorffDistance, args);
-
- Assertions.assertEquals(1d, result.x);
- Assertions.assertEquals(0.5d, result.y);
- Assertions.assertEquals(0d, result.z);
- }
-
- @Test
- public void getProjectionToClosestEdgeNormalProjectionOutsideEdgeTestTest()
- throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
- Class<?>[] argClasses = new Class[2];
- argClasses[0] = Vector3d.class;
- argClasses[1] = MeshTriangle.class;
- Method method = Point2MeshTriVisitor.class.getDeclaredMethod("getProjectionToClosestEdge", argClasses);
- method.setAccessible(true);
- Object[] args = new Object[2];
-
- args[0] = new Vector3d(0, -0.5, 0);
- MeshTriangle triangle = new MeshTriangle(
- new MeshPointImpl(new Vector3d(1, 0, 0), null, null),
- new MeshPointImpl(new Vector3d(1, 2, 0), null, null),
- new MeshPointImpl(new Vector3d(2, 0, 0), null, null)
- );
- args[1] = triangle;
-
- Point2MeshTriVisitor hausdorffDistance = new Point2MeshTriVisitor(new MeshPointImpl(new Vector3d(), null, null), false);
- Vector3d result = (Vector3d) method.invoke(hausdorffDistance, args);
-
- Assertions.assertEquals(1d, result.x);
- Assertions.assertEquals(0d, result.y);
- Assertions.assertEquals(0d, result.z);
- }
-
- @Test
- public void getProjectionToEdgeTest()
- throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
- Class<?>[] argClasses = new Class[3];
- argClasses[0] = Vector3d.class;
- argClasses[1] = Vector3d.class;
- argClasses[2] = Vector3d.class;
- Method method = Point2MeshTriVisitor.class.getDeclaredMethod("getProjectionToEdge", argClasses);
- method.setAccessible(true);
- Object[] args = new Object[3];
-
- args[0] = new Vector3d(0, 0.5, 0);
- args[1] = new Vector3d(1, 2, 0);
- args[2] = new Vector3d(1, 0, 0);
-
- Point2MeshTriVisitor hausdorffDistance = new Point2MeshTriVisitor(new MeshPointImpl(new Vector3d(), null, null), false);
- Vector3d result = (Vector3d) method.invoke(hausdorffDistance, args);
-
- Assertions.assertEquals(1d, result.x);
- Assertions.assertEquals(0.5d, result.y);
- Assertions.assertEquals(0d, result.z);
- }
-
- @Test
- public void getProjectionToEdgeNormalProjectionOutsideEdgeTest()
- throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
- Class<?>[] argClasses = new Class[3];
- argClasses[0] = Vector3d.class;
- argClasses[1] = Vector3d.class;
- argClasses[2] = Vector3d.class;
- Method method = Point2MeshTriVisitor.class.getDeclaredMethod("getProjectionToEdge", argClasses);
- method.setAccessible(true);
- Object[] args = new Object[3];
-
- args[0] = new Vector3d(0, -0.5, 0);
- args[1] = new Vector3d(1, 2, 0);
- args[2] = new Vector3d(1, 0, 0);
-
- Point2MeshTriVisitor hausdorffDistance = new Point2MeshTriVisitor(new MeshPointImpl(new Vector3d(), null, null), false);
- Vector3d result = (Vector3d) method.invoke(hausdorffDistance, args);
-
- Assertions.assertEquals(1d, result.x);
- Assertions.assertEquals(0d, result.y);
- Assertions.assertEquals(0d, result.z);
- }
-
- @Test
- public void getProjectionToEdgeNormalProjectionOutsideEdge2Test()
- throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
- Class<?>