Added tests. Added shortcut to return SkipAffineTransform in

CenteredAffineTransformCalculation.
Oliver-Loeffler · Sep 8, 2019 · e524e5a · e524e5a
1 parent e98b42d
commit e524e5a
Show file tree

Hide file tree

Showing 3 changed files with 176 additions and 12 deletions.
diff --git a/src/main/java/net/raumzeitfalle/registration/displacement/DisplacementSummary.java b/src/main/java/net/raumzeitfalle/registration/displacement/DisplacementSummary.java
@@ -22,6 +22,7 @@
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
+import java.util.Locale;
 import java.util.function.DoubleConsumer;
 import java.util.function.Predicate;
 
@@ -93,18 +94,9 @@ private DisplacementSummary(Collection<Displacement> displacements, Predicate<Di
 						 update(d);
 					 });
 
-		if (Double.isFinite(this.statsDiffX.getAverage())) {
-			this.sd3x = 3 * stdev(this.statsDiffX.getAverage(), dx);	
-		} else {
-			this.sd3x = Double.NaN;	
-		}
+		this.sd3x = 3 * stdev(this.statsDiffX.getAverage(), dx);	
+		this.sd3y = 3* stdev(this.statsDiffY.getAverage(), dy);	
 
-		if (Double.isFinite(this.statsDiffY.getAverage())) {
-			this.sd3y = 3* stdev(this.statsDiffY.getAverage(), dy);	
-		} else {
-			this.sd3y = Double.NaN;	
-		}
-
 		RigidTransform alignment = new RigidTransformCalculation()
 				.apply(displacements, calculationSelection);
 
@@ -251,7 +243,7 @@ public long sizeY() {
 	}
 
 	private String format(double value) {
-		return String.format("%10.5f", value*1E3);
+		return String.format(Locale.US, "%10.5f", value*1E3);
 	}
 
 }
diff --git a/...n/java/net/raumzeitfalle/registration/distortions/CenteredAffineTransformCalculation.java b/...n/java/net/raumzeitfalle/registration/distortions/CenteredAffineTransformCalculation.java
@@ -44,6 +44,8 @@ public CenteredAffineTransformCalculation(AffineModel model) {
 
 	@Override
 	public AffineTransform apply(Collection<Displacement> t, Predicate<Displacement> u) {
+		if (t.isEmpty())
+    		return SkipAffineTransform.centeredAt(0, 0);
 
     	TranslateFunction translate = Displacement.translationToCenter(t, u);
 
@@ -55,6 +57,9 @@ public AffineTransform apply(Collection<Displacement> t, Predicate<Displacement>
 									                .flatMap(AffineModelEquation::from)
 									                .map(dimension)
 									                .collect(Collectors.toList());
+
+    	if (finalEquations.isEmpty())
+    		return SkipAffineTransform.centeredAt(0, 0);
 
         AffineTransform transform = model.solve(finalEquations,dimension);
 

diff --git a/src/test/java/net/raumzeitfalle/registration/displacement/DisplacementSummaryTest.java b/src/test/java/net/raumzeitfalle/registration/displacement/DisplacementSummaryTest.java
@@ -0,0 +1,167 @@
+package net.raumzeitfalle.registration.displacement;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import org.junit.jupiter.api.Test;
+
+class DisplacementSummaryTest {
+
+	private static final double POS_TOLERANCE = 1E-6;
+
+	private DisplacementSummary classUnderTest;
+
+	@Test
+	void design() {
+
+		classUnderTest = DisplacementSummary.over(getRotated(), d->true);
+
+		assertEquals(  333.33, classUnderTest.designMeanX(), 1E-1);
+		assertEquals( -366.66, classUnderTest.designMeanY(), 1E-1);
+
+		assertEquals( -1000.0, classUnderTest.designMinX(), POS_TOLERANCE);
+		assertEquals( -1100.0, classUnderTest.designMinY(), POS_TOLERANCE);
+
+		assertEquals(  1000.0, classUnderTest.designMaxX(), POS_TOLERANCE);
+		assertEquals(  1100.0, classUnderTest.designMaxY(), POS_TOLERANCE);
+
+	}
+
+
+	@Test
+	void deltas() {
+
+		classUnderTest = DisplacementSummary.over(getRotated(), d->true);
+
+		assertEquals(    1.0, classUnderTest.meanX(), POS_TOLERANCE);
+		assertEquals(   -0.5, classUnderTest.meanY(), POS_TOLERANCE);
+
+		assertEquals( -999.0, classUnderTest.minX(), POS_TOLERANCE);
+		assertEquals(-1100.5, classUnderTest.minY(), POS_TOLERANCE);
+
+		assertEquals( 1011.0, classUnderTest.maxX(), POS_TOLERANCE);
+		assertEquals( 1099.5, classUnderTest.maxY(), POS_TOLERANCE);
+
+		assertEquals( 2658.0, classUnderTest.sd3X(), 1E-1);
+		assertEquals( 2802.2, classUnderTest.sd3Y(), 1E-1);
+
+		assertEquals( 4, classUnderTest.sizeX() );
+		assertEquals( 4, classUnderTest.sizeY() );
+
+	}
+
+	@Test
+	void displacedMean() {
+
+		classUnderTest = DisplacementSummary.over(getRotated(), d->true);
+
+		assertEquals(  1.0, classUnderTest.displacedMeanX(), POS_TOLERANCE);
+		assertEquals( -0.5, classUnderTest.displacedMeanY(), POS_TOLERANCE);
+
+	}
+
+	@Test
+	void emptyCollection() {
+
+		classUnderTest = DisplacementSummary.over(Collections.emptyList(), d->true);
+
+		// deltas
+		assertEquals(    0.0, classUnderTest.meanX(), POS_TOLERANCE);
+		assertEquals(    0.0, classUnderTest.meanY(), POS_TOLERANCE);
+
+		assertFalse( Double.isFinite(classUnderTest.minX()) );
+		assertFalse( Double.isFinite(classUnderTest.minY()) );
+
+		assertFalse( Double.isFinite(classUnderTest.maxX()) );
+		assertFalse( Double.isFinite(classUnderTest.maxY()) );
+
+		assertEquals( Double.NaN, classUnderTest.sd3X(), 1E-1);
+		assertEquals( Double.NaN, classUnderTest.sd3Y(), 1E-1);
+
+		assertEquals( 0, classUnderTest.sizeX() );
+		assertEquals( 0, classUnderTest.sizeY() );
+
+
+		// displaced mean
+		assertEquals(  0.0, classUnderTest.displacedMeanX(), POS_TOLERANCE);
+		assertEquals(  0.0, classUnderTest.displacedMeanY(), POS_TOLERANCE);
+
+		// design
+		assertEquals(  0.0, classUnderTest.designMeanX(), 1E-1);
+		assertEquals(  0.0, classUnderTest.designMeanY(), 1E-1);
+
+		assertFalse( Double.isFinite(classUnderTest.designMinX()) );
+		assertFalse( Double.isFinite(classUnderTest.designMinX()) );
+
+		assertFalse( Double.isFinite(classUnderTest.designMaxX()) );
+		assertFalse( Double.isFinite(classUnderTest.designMaxY()) );
+
+	}
+
+	@Test
+	void toStringMethodWithValues() {
+
+		classUnderTest = DisplacementSummary.over(getRotated(), d->true);
+
+		String text = classUnderTest.toString();
+
+		String expected = "\n" + 
+				"DisplacementSummary\n" + 
+				"Summary			X		Y		ISO\n" + 
+				"Mean		1000.00000	-500.00000\n" + 
+				"3Sigma		2658041.46653	2802210.01652\n" + 
+				"Min		-999000.00000	-1100500.00000\n" + 
+				"Max		1011000.00000	1099500.00000\n" + 
+				"Scales:		-297893218.81345	-357175653.46677	-327534436.14011\n" + 
+				"Orthos:		-707106781.18655	-642824346.53323	64282434.65332\n" + 
+				"Rotation:					671911421.03699\n" + 
+				"Sites		4		4\n" + 
+				"";
+
+		assertEquals(expected,text);
+	}
+
+	@Test
+	void toStringMethodWithoutValues() {
+
+		classUnderTest = DisplacementSummary.over(Collections.emptyList(), d->true);
+
+		String text = classUnderTest.toString();
+
+		String expected = "\n" + 
+				"DisplacementSummary\n" + 
+				"Summary			X		Y		ISO\n" + 
+				"Mean		   0.00000	   0.00000\n" + 
+				"3Sigma		       NaN	       NaN\n" + 
+				"Min		  Infinity	  Infinity\n" + 
+				"Max		 -Infinity	 -Infinity\n" + 
+				"Scales:		   0.00000	   0.00000	   0.00000\n" + 
+				"Orthos:		   0.00000	   0.00000	   0.00000\n" + 
+				"Rotation:					   0.00000\n" + 
+				"Sites		0		0\n" + 
+				"";
+
+		assertEquals(expected,text);
+	}
+
+
+	private List<Displacement> getRotated() {
+		List<Displacement> displaced = new ArrayList<>(4);
+
+		double rotated = Math.sqrt(2)*1E3;
+		double tx =  1.0;
+		double ty = -0.5;
+
+		displaced.add(Displacement.at(0, 0, -1000, -1100,        0+tx+10, -rotated+ty));
+		displaced.add(Displacement.at(0, 0, -1000,  1100, -rotated+tx,           0+ty));
+		displaced.add(Displacement.at(0, 0,  1000,  1100,        0+tx,     rotated+ty));
+		displaced.add(Displacement.at(0, 0,  1000, -1100,  rotated+tx-10,  Double.NaN));
+		displaced.add(Displacement.at(0, 0,  1000, -1100,     Double.NaN,  Double.NaN));
+		displaced.add(Displacement.at(0, 0,  1000, -1100,     Double.NaN,        0+ty));
+		return displaced;
+	}
+
+}