Quickhull

quickHull.cpp

@@ -0,0 +1,100 @@
+#include "quickHull.hpp"
+#include "utils.hpp"
+#include <cmath>
+#define max_y 1000000000
+#define min_y -1000000000
+// Output hull
+std::vector<Point> convex_hull;
+
+void quickHull(Point p, Point q, std::vector<Point> points)
+{
+    if (points.size() > 0)
+    {
+        Point farthest; 
+        long double max_dist = 0; 
+
+        // Select the point at maximum distance from line
+        for (Point point : points) 
+        {    
+            long double dist = point.findDist(p, q); 
+            if (dist > max_dist) 
+            { 
+                max_dist = dist;
+                farthest = point;
+            } 
+        } 
+        // Select points outside triangle formed by p, q, farthest
+        std::vector<Point> upper, lower;
+        for (Point point : points)
+        {
+            if (signedTriangleArea(farthest, p, point) > 0)
+            {
+                upper.push_back(point);
+            }
+            if (signedTriangleArea(q, farthest, point) > 0)
+            {   
+                lower.push_back(point);
+            }
+        }
+        // Recurse on exterior points afer pruning interior points
+        quickHull(farthest, p, upper);
+        // Add farthest point from line pq to convex hull
+        convex_hull.push_back(farthest);
+        quickHull(q, farthest, lower);
+    }
+}
+
+std::vector<Point> Hull(std::vector<Point> points)
+{
+    if (points.size() <= 2)
+    {
+        return points;
+    }
+
+    // Select top-most and bottom-most point 
+    Point p , q;
+    p.x = q.x = 0;
+    p.y = min_y;
+    q.y = max_y;
+    for (Point point : points)
+    {
+        if (point.y < q.y)
+        {
+            q = point;
+        }
+        else if (point.y == q.y && point.x > q.x)
+        {
+            q = point;
+        }     
+        if (point.y > p.y)
+        {
+            p = point;
+        }
+        else if (point.y == p.y && point.x > p.x)
+        {
+            p = point;
+        }     
+    }
+
+    // Split into two sets, left and right of the line joining q to p.
+    std::vector<Point> left, right;
+    for (Point point : points)
+    {
+        if (signedTriangleArea(p, q, point) < 0)
+        {
+            left.push_back(point);
+        }
+        else if (signedTriangleArea(p, q, point) > 0)
+        {
+            right.push_back(point);
+        }
+    }
+    // Add p to the convex hull
+    convex_hull.push_back(p);
+    quickHull(p, q, left);
+    // Add q to the convex hull
+    convex_hull.push_back(q);
+    quickHull(q, p, right);
+
+    return convex_hull;
+}

quickHull.hpp

@@ -0,0 +1,16 @@
+/** @file */
+
+#pragma once
+#include "utils.hpp"
+#include <vector>
+
+/**
+ * Return the Convex Hull of a set of points using the Quickhull algorithm.
+ * Works in worse case time complexity O(N*N) and space complexity O(N+H) where N is the number of points and H is the number of points in the Convex Hull.
+ * 
+ * @param points A vector of points for which the Convex Hull is to be found
+ * @return A vector of points which contains the points of the Convex Hull
+ * 
+ * @relatesalso Point
+ */
+std::vector<Point> Hull(std::vector<Point> points);

test.cpp

@@ -1,6 +1,7 @@
 #include "utils.hpp"
 #include "grahamScan.hpp"
 #include "jarvisMarch.hpp"
+#include "quickHull.hpp"
 #include <iostream>
 
 int main()
@@ -15,7 +16,7 @@ int main()
         points.push_back(Point(x, y));
     }
 
-    std::vector<Point> ch = jarvisMarch(points);
+    std::vector<Point> ch = Hull(points);
 
     for (Point p : ch)
     {

utils.cpp

@@ -1,6 +1,7 @@
 #include "utils.hpp"
-
+#include <cmath>
 Point::Point(long double x, long double y) : y(y), x(x) {}
+Point::Point() : y(0), x(0) {}
 bool Point::operator==(const Point &point)
 {
     return (x == point.x && y == point.y);
@@ -9,4 +10,10 @@ bool Point::operator==(const Point &point)
 long double signedTriangleArea(Point A, Point B, Point C)
 {
     return 0.5 * ((B.x - A.x) * (C.y - A.y) - (C.x - A.x) * (B.y - A.y));
-}
+}
+
+long double Point::findDist(Point p, Point q) 
+{ 
+    return std :: abs ((y - p.y) * (q.x - p.x) - 
+               (q.y - p.y) * (x - p.x));
+} 

utils.hpp

@@ -30,6 +30,7 @@ class Point
      * Equality operator. Two points are equal if they have the same x and y coordinates
      */
     bool operator==(const Point &point);
+    long double findDist(Point p, Point q);
 };
 
 /**
@@ -42,4 +43,12 @@ class Point
  * 
  * @relatesalso Point 
  */
-long double signedTriangleArea(Point A, Point B, Point C);
+long double signedTriangleArea(Point A, Point B, Point C);
+/**
+ * Find distance of a point from a line joining two points.
+ * @param p 1st Point
+ * @param q 2nd Point
+ * @return The distance of Point from the line joining p and q.
+ * 
+ * @relatesalso Point 
+ */