From 41f0c2236a484d2911d21a55bb8ada742e02c61d Mon Sep 17 00:00:00 2001
From: Lennart Hensler <lennarthensler@aol.com>
Date: Mon, 7 Apr 2014 17:16:02 +0200
Subject: [PATCH] Implemented the new anti wrap around algorithm

---
 .../test/TestWindChartPointRecalculation.java | 20 ++++++------
 .../ui/client/shared/charts/WindChart.java    |  2 +-
 .../charts/WindChartPointRecalculator.java    | 31 ++++++++++++++++---
 3 files changed, 38 insertions(+), 15 deletions(-)

diff --git a/java/com.sap.sailing.gwt.ui.test/src/com/sap/sailing/gwt/ui/test/TestWindChartPointRecalculation.java b/java/com.sap.sailing.gwt.ui.test/src/com/sap/sailing/gwt/ui/test/TestWindChartPointRecalculation.java
index c39d660cbbd..a9e7d785915 100644
--- a/java/com.sap.sailing.gwt.ui.test/src/com/sap/sailing/gwt/ui/test/TestWindChartPointRecalculation.java
+++ b/java/com.sap.sailing.gwt.ui.test/src/com/sap/sailing/gwt/ui/test/TestWindChartPointRecalculation.java
@@ -18,22 +18,22 @@ public class TestWindChartPointRecalculation {
     @Test
     public void testRecalculaion() {
         Point notToBeRecalculated = new Point(10, 100);
-        assertThat(WindChartPointRecalculator.recalculateDirectionPoint(90.0, 110.0, notToBeRecalculated).getY(), equalTo(notToBeRecalculated.getY()));
-        assertThat(WindChartPointRecalculator.recalculateDirectionPoint(null, 110.0, notToBeRecalculated).getY(), equalTo(notToBeRecalculated.getY()));
-        assertThat(WindChartPointRecalculator.recalculateDirectionPoint(90.0, null, notToBeRecalculated).getY(), equalTo(notToBeRecalculated.getY()));
-        assertThat(WindChartPointRecalculator.recalculateDirectionPoint(100.27458, 110.0, notToBeRecalculated).getY(), equalTo(notToBeRecalculated.getY()));
-        assertThat(WindChartPointRecalculator.recalculateDirectionPoint(90.0, 100.75639, notToBeRecalculated).getY(), equalTo(notToBeRecalculated.getY()));
+        assertThat(WindChartPointRecalculator.keepOverallDeltaMinimal(90.0, 110.0, notToBeRecalculated).getY(), equalTo(notToBeRecalculated.getY()));
+        assertThat(WindChartPointRecalculator.keepOverallDeltaMinimal(null, 110.0, notToBeRecalculated).getY(), equalTo(notToBeRecalculated.getY()));
+        assertThat(WindChartPointRecalculator.keepOverallDeltaMinimal(90.0, null, notToBeRecalculated).getY(), equalTo(notToBeRecalculated.getY()));
+        assertThat(WindChartPointRecalculator.keepOverallDeltaMinimal(100.27458, 110.0, notToBeRecalculated).getY(), equalTo(notToBeRecalculated.getY()));
+        assertThat(WindChartPointRecalculator.keepOverallDeltaMinimal(90.0, 100.75639, notToBeRecalculated).getY(), equalTo(notToBeRecalculated.getY()));
         
         //Test for special case, which caused a wrong recalculation, because of the wrong use of Math.abs()
         notToBeRecalculated = new Point(10, 179.8537);
-        assertThat(WindChartPointRecalculator.recalculateDirectionPoint(180.12356, 190.0, notToBeRecalculated).getY(), equalTo(notToBeRecalculated.getY()));
-        assertThat(WindChartPointRecalculator.recalculateDirectionPoint(170.0, 179.5372, notToBeRecalculated).getY(), equalTo(notToBeRecalculated.getY()));
+        assertThat(WindChartPointRecalculator.keepOverallDeltaMinimal(180.12356, 190.0, notToBeRecalculated).getY(), equalTo(notToBeRecalculated.getY()));
+        assertThat(WindChartPointRecalculator.keepOverallDeltaMinimal(170.0, 179.5372, notToBeRecalculated).getY(), equalTo(notToBeRecalculated.getY()));
         
         Point toBeMovedDown = new Point(10, 356);
-        assertThat(WindChartPointRecalculator.recalculateDirectionPoint(4.0, 23.0, toBeMovedDown).getY(), equalTo(new Point(10, 356.0 - 360.0).getY()));
+        assertThat(WindChartPointRecalculator.keepOverallDeltaMinimal(4.0, 23.0, toBeMovedDown).getY(), equalTo(new Point(10, 356.0 - 360.0).getY()));
         
         Point toBeMovedUp = new Point(10, 5);
-        assertThat(WindChartPointRecalculator.recalculateDirectionPoint(356.0, 359.83364, toBeMovedUp).getY(), equalTo(new Point(10, 5.0 + 360.0).getY()));
+        assertThat(WindChartPointRecalculator.keepOverallDeltaMinimal(356.0, 359.83364, toBeMovedUp).getY(), equalTo(new Point(10, 5.0 + 360.0).getY()));
     }
     
     @Test
@@ -60,7 +60,7 @@ public class TestWindChartPointRecalculation {
         Double max = null;
         for (Double yValue : pointYValues) {
             Point p = new Point(10, yValue);
-            p = WindChartPointRecalculator.recalculateDirectionPoint(min, max, p);
+            p = WindChartPointRecalculator.keepOverallDeltaMinimal(min, max, p);
             Double newYValue = p.getY().doubleValue();
             recalculatedPointYValues.add(newYValue);
             
diff --git a/java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/shared/charts/WindChart.java b/java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/shared/charts/WindChart.java
index 33dd2ed3a9b..c3b77bba5fa 100755
--- a/java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/shared/charts/WindChart.java
+++ b/java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/shared/charts/WindChart.java
@@ -350,7 +350,7 @@ public class WindChart extends AbstractRaceChart implements Component<WindChartS
                         newDirectionPoint.setName(name);
                     }
                     
-                    newDirectionPoint = WindChartPointRecalculator.recalculateDirectionPoint(directionMin, directionMax, newDirectionPoint);
+                    newDirectionPoint = WindChartPointRecalculator.keepOverallDeltaMinimal(directionMin, directionMax, newDirectionPoint);
                     directionPoints[currentPointIndex] = newDirectionPoint;
 
                     double direction = newDirectionPoint.getY().doubleValue();
diff --git a/java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/shared/charts/WindChartPointRecalculator.java b/java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/shared/charts/WindChartPointRecalculator.java
index 09915d6fa12..340c2893140 100644
--- a/java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/shared/charts/WindChartPointRecalculator.java
+++ b/java/com.sap.sailing.gwt.ui/src/main/java/com/sap/sailing/gwt/ui/client/shared/charts/WindChartPointRecalculator.java
@@ -7,11 +7,34 @@ public final class WindChartPointRecalculator {
     private WindChartPointRecalculator() { }
     
     public static Point stayClosestToPreviousPoint(Point previousPoint, Point newPoint) {
+        double previousY = previousPoint.getY().doubleValue();
+        double newY = newPoint.getY().doubleValue();
+        
+        double deltaPreviousNew = Math.abs(previousY - newY);
+        double deltaPreviosNewUp = Math.abs(previousY - (newY + 360));
+        double deltaPreviosNewDown = Math.abs(previousY - (newY - 360));
+        
+        if (isStrictlyLessThan(deltaPreviosNewUp, deltaPreviousNew, deltaPreviosNewDown)) {
+            return new Point(newPoint.getX(), newPoint.getY().doubleValue() + 360);
+        }
+        if (isStrictlyLessThan(deltaPreviosNewDown, deltaPreviousNew, deltaPreviosNewUp)) {
+            return new Point(newPoint.getX(), newPoint.getY().doubleValue() - 360);
+        }
+        
         return newPoint;
     }
     
-    public static Point recalculateDirectionPoint(Double yMin, Double yMax, Point directionPoint) {
-        double y = directionPoint.getY().doubleValue();
+    private static boolean isStrictlyLessThan(double valueToCheck, double... valuesToCompare) {
+        for (double value : valuesToCompare) {
+            if (value <= valueToCheck) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public static Point keepOverallDeltaMinimal(Double yMin, Double yMax, Point newPoint) {
+        double y = newPoint.getY().doubleValue();
 
         if (yMax != null && yMin != null && (y < yMin || y > yMax)) {
             double deltaMin = Math.abs(yMin - y);
@@ -25,11 +48,11 @@ public final class WindChartPointRecalculator {
 
             if (isRecalculationNeeded(deltaMin, deltaMax, deltaMinDown, deltaMaxUp)) {
                 y = deltaMaxUp <= deltaMinDown ? yUp : yDown;
-                return new Point(directionPoint.getX(), y);
+                return new Point(newPoint.getX(), y);
             }
         }
         
-        return directionPoint;
+        return newPoint;
     }
 
     private static boolean isRecalculationNeeded(double deltaMin, double deltaMax, double deltaMinDown, double deltaMaxUp) {