QuickHull_Algorithm.java

// Quickhull is a convex hull algorithm that is used to find the convex hull of a set of points in a two-dimensional space.
// The convex hull of a set of points is the smallest convex polygon that encloses all the points.
// Applications include: collision avoidance, shape analysis, pattern recognition etc, image processing.


// The QuickHull algorithm follows a divide-and-conquer approach and is known for its efficiency. High - level overview of how the algorithm works:

// 1. Find the point with the minimum and maximum x-coordinate values. These points will be part of the convex hull.
// 2. Divide the points into two subsets based on which side of the line formed by the two points each point lies. The points will be partitioned into two groups: 
// those that lie on the "left" side of the line and those that lie on the "right" side.
// 3. For each of the two subsets, find the point that is farthest from the line. These points will also be part of the convex hull.
// 4. Repeat steps 2 and 3 recursively for the subsets formed by the farthest points and the corresponding sides of the line. 
// This recursion continues until no more points are left on one side of a line, at which point the algorithm terminates.
// 5. Combine the convex hulls obtained from the recursive steps to form the final convex hull.

// Worst case time complexity: O(N^2)
// Average case time complexity: O(N log N)
// Best case time complexity: O(N log N)
// Space complexity: O(N)
import java.util.HashSet;
import java.util.Set;

class Point {
 public int x, y;

 // Constructor
 Point(int x, int y) {
 this.x = x;
 this.y = y;
 }

 @Override
 public boolean equals(Object obj) {
 if (this == obj) {
 return true;
 }
 if (obj == null || getClass() != obj.getClass()) {
 return false;
 }
 Point other = (Point) obj;
 return x == other.x && y == other.y;
 }

 @Override
 public int hashCode() {
 return 31 * x + y;
 }
}

class QuickHull_Algorithm {
 // Find the side of a point 'p' with respect to the line segment 'a'-'b'
 private static int findSide(Point a, Point b, Point p) {
 // Computing the cross product of two vectors: the vector from 'a' to 'p' and the vector from 'a' to 'b' which determines which side of the line segment a point lies.
 int val = (p.y - a.y) * (b.x - a.x) - (p.x - a.x) * (b.y - a.y);

 if (val > 0)
 return 1; // Point is on the left side
 else if (val < 0)
 return -1; // Point is on the right side
 else
 return 0; // Point is collinear
 }

 // Returns a value proportional to the distance between the point p and the line joining the points a and b
 private static int lineDist(Point a, Point b, Point p) {
 return Math.abs((p.y - a.y) * (b.x - a.x) - (p.x - a.x) * (b.y - a.y));
 }

 // Recursive function to find the points on the convex hull
 private static void quickHull(Set<Point> points, Point a, Point b, int side, Set<Point> hull) {
 int maxDist = 0;
 Point maxDistPoint = null;

 // Find the point with the maximum distance from the line segment 'a'-'b' and also on the specified side of L
 for (Point p : points) {
 int currSide = findSide(a, b, p);
 int dist = lineDist(a, b, p);
 if (currSide == side && dist > maxDist) {
 maxDist = dist;
 maxDistPoint = p;
 }
 }

 // If no point is found, add the end points of the line segment to the convex hull
 if (maxDistPoint == null) {
 hull.add(a);
 hull.add(b);
 return;
 }

 // Recursively find the points on the convex hull on the two sides of the line segment divided by maxDistPoint
 quickHull(points, maxDistPoint, a, -findSide(maxDistPoint, a, b), hull);
 quickHull(points, maxDistPoint, b, -findSide(maxDistPoint, b, a), hull);
 }

 // Wrapper function to compute the convex hull using QuickHull algorithm
 private static Set<Point> computeConvexHull(Set<Point> points) {
 Set<Point> hull = new HashSet<>();

 // Find the leftmost and rightmost points
 Point minPoint = null;
 Point maxPoint = null;
 for (Point p : points) {
 if (minPoint == null || p.x < minPoint.x) {
 minPoint = p;
 }
 if (maxPoint == null || p.x > maxPoint.x) {
 maxPoint = p;
 }
 }

 // Compute the points on one side of the line segment 'minPoint'-'maxPoint'
 quickHull(points, minPoint, maxPoint, 1, hull);

 // Compute the points on the other side of the line segment 'minPoint'-'maxPoint'
 quickHull(points, minPoint, maxPoint, -1, hull);

 return hull;
 }

 public static void main(String[] args) {
 Set<Point> points = new HashSet<>();
 points.add(new Point(0, 3));
 points.add(new Point(1, 1));
 points.add(new Point(2, 2));
 points.add(new Point(4, 4));
 points.add(new Point(0, 0));
 points.add(new Point(1, 2));
 points.add(new Point(3, 1));
 points.add(new Point(3, 3));

 // numPoints should be >= 3 to form a triangle
 if (points.size() < 3) {
 System.out.println("Convex hull not possible");
 return;
 }

 // Compute the convex hull
 Set<Point> convexHull = computeConvexHull(points);

 // Print the points on the convex hull
 System.out.println("Points on the convex hull:");
 for (Point point : convexHull) {
 System.out.println("(" + point.x + ", " + point.y + ")");
 }
 }
}