feat: add DDA line drawing algorithm

Author: saahilmahato

src/main/java/com/thealgorithms/geometry/DDALine.java

@@ -0,0 +1,54 @@
+package com.thealgorithms.geometry;
+
+import java.awt.Point;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * The {@code DDALine} class implements the Digital Differential Analyzer (DDA)
+ * line drawing algorithm. It computes points along a line between two given
+ * endpoints using floating-point arithmetic.
+ *
+ * The algorithm is straightforward but less efficient compared to
+ * Bresenham’s line algorithm, since it relies on floating-point operations.
+ *
+ * For more information, please visit {@link https://en.wikipedia.org/wiki/Digital_differential_analyzer_(graphics_algorithm)}
+ */
+public final class DDALine {
+
+    private DDALine() {
+        // Prevent instantiation
+    }
+
+    /**
+     * Finds the list of points forming a line between two endpoints using DDA.
+     *
+     * @param x0 the x-coordinate of the starting point
+     * @param y0 the y-coordinate of the starting point
+     * @param x1 the x-coordinate of the ending point
+     * @param y1 the y-coordinate of the ending point
+     * @return an unmodifiable {@code List<Point>} containing all points on the line
+     */
+    public static List<Point> findLine(int x0, int y0, int x1, int y1) {
+        int dx = x1 - x0;
+        int dy = y1 - y0;
+
+        int steps = Math.max(Math.abs(dx), Math.abs(dy)); // number of steps
+
+        double xIncrement = dx / (double) steps;
+        double yIncrement = dy / (double) steps;
+
+        double x = x0;
+        double y = y0;
+
+        List<Point> line = new ArrayList<>(steps + 1);
+
+        for (int i = 0; i <= steps; i++) {
+            line.add(new Point((int) Math.round(x), (int) Math.round(y)));
+            x += xIncrement;
+            y += yIncrement;
+        }
+
+        return line;
+    }
+}

src/test/java/com/thealgorithms/geometry/DDALineTest.java

@@ -0,0 +1,50 @@
+package com.thealgorithms.geometry;
+
+import java.awt.Point;
+import java.util.List;
+import java.util.stream.Stream;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.api.Assertions;
+
+/**
+ * The {@code DDALineTest} class contains unit tests for the
+ * {@code DDALine} class, specifically testing the {@code findLine} method.
+ */
+class DDALineTest {
+
+    static Stream<Arguments> linePointsProvider() {
+        return Stream.of(
+            Arguments.of(0, 0, 5, 5, List.of(
+                new Point(0, 0), new Point(1, 1), new Point(2, 2),
+                new Point(3, 3), new Point(4, 4), new Point(5, 5)
+            )),
+            Arguments.of(0, 0, 5, 0, List.of(
+                new Point(0, 0), new Point(1, 0), new Point(2, 0),
+                new Point(3, 0), new Point(4, 0), new Point(5, 0)
+            )),
+            Arguments.of(0, 0, 0, 5, List.of(
+                new Point(0, 0), new Point(0, 1), new Point(0, 2),
+                new Point(0, 3), new Point(0, 4), new Point(0, 5)
+            )),
+            Arguments.of(-2, -2, -5, -5, List.of(
+                new Point(-2, -2), new Point(-3, -3),
+                new Point(-4, -4), new Point(-5, -5)
+            )),
+            Arguments.of(1, 1, 1, 1, List.of(new Point(1, 1))),
+            Arguments.of(0, 0, 1, 5, List.of(
+                new Point(0, 0), new Point(0, 1), new Point(0, 2),
+                new Point(1, 3), new Point(1, 4), new Point(1, 5)
+            ))
+        );
+    }
+
+    @ParameterizedTest
+    @MethodSource("linePointsProvider")
+    void testFindLine(int x0, int y0, int x1, int y1, List<Point> expected) {
+        List<Point> actual = DDALine.findLine(x0, y0, x1, y1);
+        Assertions.assertEquals(expected, actual,
+            "The DDA algorithm should generate the expected ordered points.");
+    }
+}