Avoid accumulative rounding errors when using nested scalable figures

When translating geometric shapes across multiple scalable layers,
rounding errors may occur if each layer is using a fractional scaling
factor. This is because the methods translateToRelative() and
translateToAbsolute() work with integer precision. Given an
integer-based shape, this causes rounding errors after every layer.

To avoid this, an internal useDoublePrecision() method is added to the
Figure, which indicates whether those methods should convert the
integer-precision shape to (intermediate) double-precision shape. The
fractional values are accumulated and only converted back to integer
precision at the end.

Relates to #829

Author: ptziegler

org.eclipse.draw2d.tests/src/org/eclipse/draw2d/test/Draw2dTestSuite.java

@@ -60,7 +60,8 @@
 	InsetsTest.class,
 	DirectedGraphLayoutTest.class,
 	ScrollPaneTests.class,
-	LabelTest.class
+	LabelTest.class,
+	PrecisionTests.class
 })
 public class Draw2dTestSuite {
 }

org.eclipse.draw2d.tests/src/org/eclipse/draw2d/test/PrecisionTests.java

@@ -0,0 +1,89 @@
+/*******************************************************************************
+ * Copyright (c) 2025 Patrick Ziegler and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *     Patrick Ziegler - initial API and implementation
+ *******************************************************************************/
+
+package org.eclipse.draw2d.test;
+
+import org.eclipse.draw2d.Figure;
+import org.eclipse.draw2d.FigureUtilities;
+import org.eclipse.draw2d.IFigure;
+import org.eclipse.draw2d.ScalableLayeredPane;
+import org.eclipse.draw2d.geometry.PrecisionRectangle;
+import org.eclipse.draw2d.geometry.Rectangle;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Test case to ensure rounding errors don't accumulate when translating
+ * coordinates through multiple scalable layers.
+ */
+public class PrecisionTests extends BaseTestCase {
+	private IFigure fig;
+
+	@BeforeEach
+	public void setUp() {
+		fig = new Figure();
+		IFigure layers = createLayers();
+		layers.add(fig);
+		IFigure root = new Figure();
+		root.add(FigureUtilities.getRoot(layers));
+	}
+
+	private static IFigure createLayers() {
+		ScalableLayeredPane f1 = createLayer(1.33);
+		ScalableLayeredPane f2 = createLayer(5.79);
+		ScalableLayeredPane f3 = createLayer(0.87);
+		ScalableLayeredPane f4 = createLayer(3.88);
+		ScalableLayeredPane f5 = createLayer(1.46);
+
+		f1.add(f2);
+		f2.add(f3);
+		f3.add(f4);
+		f4.add(f5);
+
+		return f5;
+	}
+
+	private static ScalableLayeredPane createLayer(double scale) {
+		ScalableLayeredPane figure = new ScalableLayeredPane();
+		figure.setScale(scale);
+		figure.setOpaque(true);
+		return figure;
+	}
+
+	@Test
+	public void testPreciseTranslateToAbsolute() {
+		Rectangle r1 = new Rectangle(13, 37, 163, 377);
+		Rectangle r2 = new PrecisionRectangle(13, 37, 163, 377);
+		fig.translateToAbsolute(r1);
+		fig.translateToAbsolute(r2);
+		assertEquals(493, 1404, 6187, 14309, r1);
+		assertEquals(r1.x, r2.x);
+		assertEquals(r1.y, r2.y);
+		assertEquals(r1.width, r2.width);
+		assertEquals(r1.height, r2.height);
+	}
+
+	@Test
+	public void testPreciseTranslateToRelative() {
+		Rectangle r1 = new Rectangle(753, 891, 353, 564);
+		Rectangle r2 = new PrecisionRectangle(753, 891, 353, 564);
+		fig.translateToRelative(r1);
+		fig.translateToRelative(r2);
+		assertEquals(19, 23, 11, 16, r1);
+		assertEquals(r1.x, r2.x);
+		assertEquals(r1.y, r2.y);
+		assertEquals(r1.width, r2.width);
+		assertEquals(r1.height, r2.height);
+	}
+}

org.eclipse.draw2d/src/org/eclipse/draw2d/Figure.java

@@ -33,6 +33,9 @@
 import org.eclipse.draw2d.geometry.Dimension;
 import org.eclipse.draw2d.geometry.Insets;
 import org.eclipse.draw2d.geometry.Point;
+import org.eclipse.draw2d.geometry.PrecisionDimension;
+import org.eclipse.draw2d.geometry.PrecisionPoint;
+import org.eclipse.draw2d.geometry.PrecisionRectangle;
 import org.eclipse.draw2d.geometry.Rectangle;
 import org.eclipse.draw2d.geometry.Translatable;
 
@@ -2046,8 +2049,10 @@ public void translateFromParent(Translatable t) {
 	@Override
 	public final void translateToAbsolute(Translatable t) {
 		if (getParent() != null) {
-			getParent().translateToParent(t);
-			getParent().translateToAbsolute(t);
+			Translatable tPrecise = toPreciseShape(t);
+			getParent().translateToParent(tPrecise);
+			getParent().translateToAbsolute(tPrecise);
+			fromPreciseShape(tPrecise, t);
 		}
 	}
 
@@ -2067,8 +2072,55 @@ public void translateToParent(Translatable t) {
 	@Override
 	public final void translateToRelative(Translatable t) {
 		if (getParent() != null) {
-			getParent().translateToRelative(t);
-			getParent().translateFromParent(t);
+			Translatable tPrecise = toPreciseShape(t);
+			getParent().translateToRelative(tPrecise);
+			getParent().translateFromParent(tPrecise);
+			fromPreciseShape(tPrecise, t);
+		}
+	}
+
+	/**
+	 * Converts the given shape using integer-precision into a compatible shape
+	 * using double-precision. Does nothing if the conversion to double-precision is
+	 * disabled via {@link #useDoublePrecision()} or if the given
+	 * {@link Translatable} is already using double-precision.
+	 *
+	 * @param source integer-precision shape
+	 * @return double-precision geometry
+	 */
+	private Translatable toPreciseShape(Translatable source) {
+		if (getParent() instanceof Figure parentFigure && parentFigure.useDoublePrecision()) {
+			if (source instanceof Point p && !(source instanceof PrecisionPoint)) {
+				return new PrecisionPoint(p);
+			} else if (source instanceof Dimension d && !(source instanceof PrecisionDimension)) {
+				return new PrecisionDimension(d);
+			} else if (source instanceof Rectangle r && !(source instanceof PrecisionRectangle)) {
+				return new PrecisionRectangle(r);
+			}
+		}
+		// is already precise or doesn't have a precise variant
+		return source;
+	}
+
+	/**
+	 * Converts the double-precision values of {@code source} into integer-precision
+	 * values and stores them in {@code target}. Does nothing if the conversion to
+	 * double-precision is disabled via {@link #useDoublePrecision()}, if
+	 * {@code source == target} or if {@code source} is not a double-precision
+	 * shape.
+	 *
+	 * @param source double-precision shape
+	 * @param target integer-precision shape
+	 */
+	private void fromPreciseShape(Translatable source, Translatable target) {
+		if (source != target && getParent() instanceof Figure parentFigure && parentFigure.useDoublePrecision()) {
+			if (source instanceof PrecisionPoint p1 && target instanceof Point p2) {
+				p2.setLocation(p1.x, p1.y);
+			} else if (source instanceof PrecisionDimension d1 && target instanceof Dimension d2) {
+				d2.setSize(d1.width, d1.height);
+			} else if (source instanceof PrecisionRectangle r1 && target instanceof Rectangle r2) {
+				r2.setBounds(r1.x, r1.y, r1.width, r1.height);
+			}
 		}
 	}
 
@@ -2084,6 +2136,24 @@ protected boolean useLocalCoordinates() {
 		return false;
 	}
 
+	/**
+	 * Returns {@code true} if this Figure should use double-precision arithmetic
+	 * when translating a {@link Translatable}. This method should not be called or
+	 * overridden by clients. This method is overridden by classes dealing with
+	 * (fractional) scaling (implementing the {@link ScalableFigure}).
+	 *
+	 * @return {@code false}.
+	 * @since 3.21
+	 * @noreference This method is not intended to be referenced by clients.
+	 * @nooverride This method is not intended to be re-implemented or extended by
+	 *             clients.
+	 */
+	@SuppressWarnings("static-method")
+	protected boolean useDoublePrecision() {
+		// This method should only be used internally and is not part of the interface
+		return false;
+	}
+
 	/**
 	 * @see IFigure#validate()
 	 */

org.eclipse.draw2d/src/org/eclipse/draw2d/ScalableFreeformLayeredPane.java

@@ -114,4 +114,12 @@ public void translateFromParent(Translatable t) {
 		IScalablePaneHelper.translateFromParent(this, t);
 	}
 
+	/**
+	 * @since 3.21
+	 * @see org.eclipse.draw2d.Figure#useDoublePrecision()
+	 */
+	@Override
+	protected boolean useDoublePrecision() {
+		return true;
+	}
 }

org.eclipse.draw2d/src/org/eclipse/draw2d/ScalableLayeredPane.java

@@ -127,4 +127,13 @@ public boolean isCoordinateSystem() {
 		return true;
 	}
 
+	/**
+	 * @since 3.21
+	 * @see org.eclipse.draw2d.Figure#useDoublePrecision()
+	 */
+	@Override
+	protected boolean useDoublePrecision() {
+		return true;
+	}
+
 }

org.eclipse.draw2d/src/org/eclipse/draw2d/ScalableLightweightSystem.java

@@ -116,5 +116,10 @@ public void translateToParent(Translatable t) {
 		public void translateFromParent(Translatable t) {
 			IScalablePaneHelper.translateFromParent(this, t);
 		}
+
+		@Override
+		protected boolean useDoublePrecision() {
+			return true;
+		}
 	}
 }