feat: added rotating calipers

Author: yadhu-vipin

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

@@ -0,0 +1,177 @@
+package com.thealgorithms.geometry;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Rotating Calipers algorithm to compute:
+ * - Diameter of a convex polygon
+ * - Width of a convex polygon
+ * - Minimum-area bounding rectangle
+ */
+public final class RotatingCalipers {
+
+    private RotatingCalipers() {
+    }
+
+    // -------------------- Inner Classes --------------------
+    public static record PointPair(Point p1, Point p2, double distance) {
+    }
+
+    public static record Rectangle(PointD[] corners, double width, double height, double area) {
+    }
+
+    // Double-based point for precise rectangle corners
+    public static record PointD(double x, double y) {
+    }
+
+    // -------------------- Diameter --------------------
+    public static PointPair diameter(List<Point> points) {
+        if (points == null || points.size() < 2) {
+            throw new IllegalArgumentException("At least two points required for diameter");
+        }
+
+        List<Point> hull = ConvexHull.convexHullRecursive(points);
+        orderCounterClockwise(hull);
+        int n = hull.size();
+
+        double maxDist = 0;
+        Point bestA = hull.get(0), bestB = hull.get(0);
+
+        int j = 1;
+        for (int i = 0; i < n; i++) {
+            Point a = hull.get(i);
+            while (true) {
+                Point b1 = hull.get(j);
+                Point b2 = hull.get((j + 1) % n);
+                double d1 = distanceSquared(a, b1);
+                double d2 = distanceSquared(a, b2);
+                if (d2 > d1) {
+                    j = (j + 1) % n;
+                } else {
+                    break;
+                }
+            }
+            double d = distanceSquared(a, hull.get(j));
+            if (d > maxDist) {
+                maxDist = d;
+                bestA = a;
+                bestB = hull.get(j);
+            }
+        }
+        return new PointPair(bestA, bestB, Math.sqrt(maxDist));
+    }
+
+    // -------------------- Width --------------------
+    public static double width(List<Point> points) {
+        if (points == null || points.size() < 3) {
+            throw new IllegalArgumentException("At least three points required for width");
+        }
+
+        List<Point> hull = ConvexHull.convexHullRecursive(points);
+        orderCounterClockwise(hull);
+        int n = hull.size();
+
+        double minWidth = Double.MAX_VALUE;
+
+        for (int i = 0; i < n; i++) {
+            Point a = hull.get(i);
+            Point b = hull.get((i + 1) % n);
+
+            double ux = b.x() - a.x();
+            double uy = b.y() - a.y();
+            double len = Math.hypot(ux, uy);
+            ux /= len;
+            uy /= len;
+
+            double vx = -uy;
+            double vy = ux;
+
+            double minProjV = Double.MAX_VALUE;
+            double maxProjV = -Double.MAX_VALUE;
+            for (Point p : hull) {
+                // Project relative to edge starting point 'a'
+                double projV = (p.x() - a.x()) * vx + (p.y() - a.y()) * vy;
+                minProjV = Math.min(minProjV, projV);
+                maxProjV = Math.max(maxProjV, projV);
+            }
+            minWidth = Math.min(minWidth, maxProjV - minProjV);
+        }
+        return minWidth;
+    }
+
+    // -------------------- Minimum-Area Bounding Rectangle --------------------
+    public static Rectangle minAreaBoundingRectangle(List<Point> points) {
+        if (points == null || points.size() < 3) {
+            throw new IllegalArgumentException("At least three points required");
+        }
+
+        List<Point> hull = ConvexHull.convexHullRecursive(points);
+        orderCounterClockwise(hull);
+        int n = hull.size();
+
+        double minArea = Double.MAX_VALUE;
+        PointD[] bestCorners = null;
+        double bestWidth = 0;
+        double bestHeight = 0;
+
+        for (int i = 0; i < n; i++) {
+            Point a = hull.get(i);
+            Point b = hull.get((i + 1) % n);
+
+            double edgeDx = b.x() - a.x();
+            double edgeDy = b.y() - a.y();
+            double edgeLen = Math.hypot(edgeDx, edgeDy);
+            double ux = edgeDx / edgeLen;
+            double uy = edgeDy / edgeLen;
+            double vx = -uy;
+            double vy = ux;
+
+            double minU = Double.MAX_VALUE, maxU = -Double.MAX_VALUE;
+            double minV = Double.MAX_VALUE, maxV = -Double.MAX_VALUE;
+
+            for (Point p : hull) {
+                // Project relative to edge 'a'
+                double projU = (p.x() - a.x()) * ux + (p.y() - a.y()) * uy;
+                double projV = (p.x() - a.x()) * vx + (p.y() - a.y()) * vy;
+                minU = Math.min(minU, projU);
+                maxU = Math.max(maxU, projU);
+                minV = Math.min(minV, projV);
+                maxV = Math.max(maxV, projV);
+            }
+
+            double width = maxU - minU;
+            double height = maxV - minV;
+            double area = width * height;
+
+            if (area < minArea) {
+                minArea = area;
+                bestWidth = width;
+                bestHeight = height;
+
+                bestCorners = new PointD[] {new PointD(a.x() + ux * minU + vx * minV, a.y() + uy * minU + vy * minV), new PointD(a.x() + ux * maxU + vx * minV, a.y() + uy * maxU + vy * minV), new PointD(a.x() + ux * maxU + vx * maxV, a.y() + uy * maxU + vy * maxV),
+                    new PointD(a.x() + ux * minU + vx * maxV, a.y() + uy * minU + vy * maxV)};
+            }
+        }
+
+        return new Rectangle(bestCorners, bestWidth, bestHeight, minArea);
+    }
+
+    // -------------------- Helper Methods --------------------
+    private static void orderCounterClockwise(List<Point> points) {
+        double area = 0.0;
+        for (int i = 0; i < points.size(); i++) {
+            Point a = points.get(i);
+            Point b = points.get((i + 1) % points.size());
+            area += (a.x() * b.y()) - (b.x() * a.y());
+        }
+        if (area < 0) Collections.reverse(points);
+    }
+
+    private static double distanceSquared(Point a, Point b) {
+        double dx = a.x() - b.x();
+        double dy = a.y() - b.y();
+        return dx * dx + dy * dy;
+    }
+}

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

@@ -0,0 +1,87 @@
+package com.thealgorithms.geometry;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.Arrays;
+import java.util.List;
+import org.junit.jupiter.api.Test;
+
+public class RotatingCalipersTest {
+
+    @Test
+    void testDiameterSimpleTriangle() {
+        List<Point> convexHull = Arrays.asList(new Point(0, 0), new Point(4, 0), new Point(2, 3));
+        RotatingCalipers.PointPair result = RotatingCalipers.diameter(convexHull);
+
+        assertNotNull(result);
+        assertEquals(4.0, result.distance(), 0.001);
+    }
+
+    @Test
+    void testDiameterSquare() {
+        List<Point> convexHull = Arrays.asList(new Point(0, 0), new Point(3, 0), new Point(3, 3), new Point(0, 3));
+        RotatingCalipers.PointPair result = RotatingCalipers.diameter(convexHull);
+
+        assertNotNull(result);
+        assertEquals(Math.sqrt(18), result.distance(), 0.001);
+    }
+
+    @Test
+    void testWidthSimpleTriangle() {
+        List<Point> convexHull = Arrays.asList(new Point(0, 0), new Point(4, 0), new Point(2, 3));
+        double result = RotatingCalipers.width(convexHull);
+
+        // Updated expected width based on correct projection
+        assertEquals(3, result, 0.1);
+    }
+
+    @Test
+    void testMinAreaBoundingRectangleSquare() {
+        List<Point> convexHull = Arrays.asList(new Point(0, 0), new Point(3, 0), new Point(3, 3), new Point(0, 3));
+        RotatingCalipers.Rectangle result = RotatingCalipers.minAreaBoundingRectangle(convexHull);
+
+        assertNotNull(result);
+        assertEquals(9.0, result.area(), 0.1);
+        assertEquals(3.0, result.width(), 0.1);
+        assertEquals(3.0, result.height(), 0.1);
+
+        // Check corners are PointD and not null
+        for (RotatingCalipers.PointD corner : result.corners()) {
+            assertNotNull(corner);
+        }
+    }
+
+    @Test
+    void testMinAreaBoundingRectangleTriangle() {
+        List<Point> convexHull = Arrays.asList(new Point(0, 0), new Point(4, 0), new Point(2, 3));
+        RotatingCalipers.Rectangle result = RotatingCalipers.minAreaBoundingRectangle(convexHull);
+
+        assertNotNull(result);
+        assertEquals(4, result.corners().length);
+    }
+
+    @Test
+    void testDiameterWithLargeConvexHull() {
+        List<Point> convexHull = Arrays.asList(new Point(0, 0), new Point(3, 0), new Point(3, 3), new Point(0, 3), new Point(2, -4), new Point(1, -3));
+        RotatingCalipers.PointPair result = RotatingCalipers.diameter(convexHull);
+
+        assertNotNull(result);
+    }
+
+    @Test
+    void testWidthWithLargeConvexHull() {
+        List<Point> convexHull = Arrays.asList(new Point(0, 0), new Point(3, 0), new Point(3, 3), new Point(0, 3));
+        double result = RotatingCalipers.width(convexHull);
+
+        assertEquals(3.0, result, 0.001);
+    }
+
+    @Test
+    void testMinAreaBoundingRectangleWithLargeConvexHull() {
+        List<Point> convexHull = Arrays.asList(new Point(0, 0), new Point(10, 0), new Point(10, 5), new Point(0, 5));
+        RotatingCalipers.Rectangle result = RotatingCalipers.minAreaBoundingRectangle(convexHull);
+
+        assertNotNull(result);
+        assertEquals(50.0, result.area(), 0.1);
+    }
+}