Improve curvature of curved edges. They are now perfectly symmetric between vertices.

Author: brunomnsilva

src/main/java/com/brunomnsilva/smartgraph/graphview/SmartGraphEdgeCurve.java

@@ -24,7 +24,6 @@
 package com.brunomnsilva.smartgraph.graphview;
 
 import com.brunomnsilva.smartgraph.graph.Edge;
-import javafx.beans.value.ObservableValue;
 import javafx.geometry.Point2D;
 import javafx.scene.shape.CubicCurve;
 import javafx.scene.transform.Rotate;
@@ -51,7 +50,10 @@
  */
 public class SmartGraphEdgeCurve<E, V> extends CubicCurve implements SmartGraphEdgeBase<E, V> {
 
-    private static final double MAX_EDGE_CURVE_ANGLE = 20;
+    private static final double MAX_EDGE_CURVE_ANGLE = 45;
+    private static final double MIN_EDGE_CURVE_ANGLE = 3;
+    public static final int DISTANCE_THRESHOLD = 400;
+    public static final int LOOP_RADIUS_FACTOR = 4;
 
     private final Edge<E, V> underlyingEdge;
 
@@ -61,7 +63,7 @@ public class SmartGraphEdgeCurve<E, V> extends CubicCurve implements SmartGraphE
     private SmartLabel attachedLabel = null;
     private SmartArrow attachedArrow = null;
 
-    private double randomAngleFactor = 0;
+    private double randomAngleFactor;
 
     /* Styling proxy */
     private final SmartStyleProxy styleProxy;
@@ -112,63 +114,70 @@ private void update() {
             /* Make a loop using the control points proportional to the vertex radius */
 
             //TODO: take into account several "self-loops" with randomAngleFactor
-            double midpointX1 = outbound.getCenterX() - inbound.getRadius() * 5;
-            double midpointY1 = outbound.getCenterY() - inbound.getRadius() * 2;
+            double midpointX1 = outbound.getCenterX() - inbound.getRadius() * LOOP_RADIUS_FACTOR;
+            double midpointY1 = outbound.getCenterY() - inbound.getRadius() * LOOP_RADIUS_FACTOR;
 
-            double midpointX2 = outbound.getCenterX() + inbound.getRadius() * 5;
-            double midpointY2 = outbound.getCenterY() - inbound.getRadius() * 2;
+            double midpointX2 = outbound.getCenterX() + inbound.getRadius() * LOOP_RADIUS_FACTOR;
+            double midpointY2 = outbound.getCenterY() - inbound.getRadius() * LOOP_RADIUS_FACTOR;
 
             setControlX1(midpointX1);
             setControlY1(midpointY1);
             setControlX2(midpointX2);
             setControlY2(midpointY2);
 
         } else {          
-            /* Make a curved edge. The curve is proportional to the distance  */
-            double midpointX = (outbound.getCenterX() + inbound.getCenterX()) / 2;
-            double midpointY = (outbound.getCenterY() + inbound.getCenterY()) / 2;
-
-            Point2D midpoint = new Point2D(midpointX, midpointY);
+            /* Make a curved edge. The curvature is bounded and proportional to the distance;
+                higher curvature for closer vertices  */
 
             Point2D startpoint = new Point2D(inbound.getCenterX(), inbound.getCenterY());
             Point2D endpoint = new Point2D(outbound.getCenterX(), outbound.getCenterY());
 
-            //TODO: improvement lower max_angle_placement according to distance between vertices
-            double angle = MAX_EDGE_CURVE_ANGLE;
-
             double distance = startpoint.distance(endpoint);
 
-            //TODO: remove "magic number" 1500 and provide a distance function for the 
-            //decreasing angle with distance
-            angle = angle - (distance / 1500 * angle);
+            double angle = linearDecay(MAX_EDGE_CURVE_ANGLE, MIN_EDGE_CURVE_ANGLE, distance, DISTANCE_THRESHOLD);
 
-            midpoint = UtilitiesPoint2D.rotate(midpoint,
-                    startpoint,
-                    (-angle) + randomAngleFactor * (angle - (-angle)));
+            Point2D midpoint = UtilitiesPoint2D.calculateTriangleBetween(startpoint, endpoint,
+                    (-angle) + randomAngleFactor * 2 * angle);
 
             setControlX1(midpoint.getX());
             setControlY1(midpoint.getY());
             setControlX2(midpoint.getX());
             setControlY2(midpoint.getY());
         }
+    }
 
+    /**
+     * Provides the decreasing linear function decay.
+     * @param initialValue initial value
+     * @param finalValue maximum value
+     * @param distance current distance
+     * @param distanceThreshold distance threshold (maximum distance -> maximum value)
+     * @return the decay function value for <code>distance</code>
+     */
+    private static double linearDecay(double initialValue, double finalValue, double distance, double distanceThreshold) {
+        //Args.requireNonNegative(distance, "distance");
+        //Args.requireNonNegative(distanceThreshold, "distanceThreshold");
+        // Parameters are internally guaranteed to be positive. We avoid two method calls.
+
+        if(distance >= distanceThreshold) return finalValue;
+
+        return initialValue + (finalValue - initialValue) * distance / distanceThreshold;
     }
 
-    /*
-    With a curved edge we need to continuously update the control points.
-    TODO: Maybe we can achieve this solely with bindings.
-    */
     private void enableListeners() {
-        this.startXProperty().addListener((ObservableValue<? extends Number> ov, Number t, Number t1) -> {
+        // With a curved edge we need to continuously update the control points.
+        // TODO: Maybe we can achieve this solely with bindings? Maybe there's no performance gain in doing so.
+
+        this.startXProperty().addListener((ov, oldValue, newValue) -> {
             update();
         });
-        this.startYProperty().addListener((ObservableValue<? extends Number> ov, Number t, Number t1) -> {
+        this.startYProperty().addListener((ov, oldValue, newValue) -> {
             update();
         });
-        this.endXProperty().addListener((ObservableValue<? extends Number> ov, Number t, Number t1) -> {
+        this.endXProperty().addListener((ov, oldValue, newValue) -> {
             update();
         });
-        this.endYProperty().addListener((ObservableValue<? extends Number> ov, Number t, Number t1) -> {
+        this.endYProperty().addListener((ov, oldValue, newValue) -> {
             update();
         });
     }

src/main/java/com/brunomnsilva/smartgraph/graphview/UtilitiesPoint2D.java

@@ -36,27 +36,67 @@ public class UtilitiesPoint2D {
      * Rotate a point around a pivot point by a specific degrees amount
      * @param point point to rotate
      * @param pivot pivot point
-     * @param angle_degrees rotation degrees
+     * @param angleDegrees rotation degrees
      * @return rotated point
      */
-    public static Point2D rotate(final Point2D point, final Point2D pivot, double angle_degrees) {
-        double angle = Math.toRadians(angle_degrees); //angle_degrees * (Math.PI/180); //to radians
-        
-        double sin = Math.sin(angle);
-        double cos = Math.cos(angle);
-
-        //translate to origin
-        Point2D result = point.subtract(pivot);
-        
-        // rotate point
-        Point2D rotatedOrigin = new Point2D(
-                result.getX() * cos - result.getY() * sin,
-                result.getX() * sin + result.getY() * cos);
-
-        // translate point back
-        result = rotatedOrigin.add(pivot);
-
-        return result;
+    public static Point2D rotate(final Point2D point, final Point2D pivot, final double angleDegrees) {
+        double angleRadians = Math.toRadians(angleDegrees); // Convert angle to radians
+
+        double sin = Math.sin(angleRadians);
+        double cos = Math.cos(angleRadians);
+
+        // Translate the point relative to the pivot
+        double translatedX = point.getX() - pivot.getX();
+        double translatedY = point.getY() - pivot.getY();
+
+        // Apply rotation using trigonometric functions
+        double rotatedX = translatedX * cos - translatedY * sin;
+        double rotatedY = translatedX * sin + translatedY * cos;
+
+        // Translate the rotated point back to the original position
+        rotatedX += pivot.getX();
+        rotatedY += pivot.getY();
+
+        return new Point2D(rotatedX, rotatedY);
+    }
+
+    /**
+     * Calculates the third vertex point that forms a triangle with segment AB as the base and C equidistant to A and B;
+     * <code>angleDegrees</code> is the angle formed between A and C.
+     *
+     * @param pointA the point a
+     * @param pointB the point b
+     * @param angleDegrees desired angle (in degrees)
+     * @return the point c
+     */
+    public static Point2D calculateTriangleBetween(final Point2D pointA, final Point2D pointB, final double angleDegrees) {
+        // Calculate the midpoint of AB
+        Point2D midpointAB = pointA.midpoint(pointB);
+
+        // Calculate the perpendicular bisector of AB
+        double slopeAB = (pointB.getY() - pointA.getY()) / (pointB.getX() - pointA.getX());
+        double perpendicularSlope = -1 / slopeAB;
+
+        // Handle special cases where the perpendicular bisector is vertical or horizontal
+        if (Double.isInfinite(perpendicularSlope)) {
+            double yC = midpointAB.getY() + Math.tan(Math.toRadians(angleDegrees)) * midpointAB.getX();
+            return new Point2D(midpointAB.getX(), yC);
+        } else if (perpendicularSlope == 0) {
+            return new Point2D(pointA.getX(), midpointAB.getY());
+        }
+
+        // Calculate the angle between AB and the x-axis
+        double angleAB = Math.toDegrees(Math.atan2(pointB.getY() - pointA.getY(), pointB.getX() - pointA.getX()));
+
+        // Calculate the angle between AB and AC
+        double angleAC = angleAB + angleDegrees;
+
+        // Calculate the coordinates of point C
+        double distanceAC = pointA.distance(midpointAB) / Math.cos(Math.toRadians(angleDegrees));
+        double xC = pointA.getX() + distanceAC * Math.cos(Math.toRadians(angleAC));
+        double yC = perpendicularSlope * (xC - midpointAB.getX()) + midpointAB.getY();
+
+        return new Point2D(xC, yC);
     }
 
 }