HTML & JS
// A C++ program to find convex hull of a set of points. Refer 
// https://www.geeksforgeeks.org/orientation-3-ordered-points/ 
// for explanation of orientation() 
#include <bits/stdc++.h> 
using namespace std; 

struct Point 
{ 
	int x, y; 
}; 

// To find orientation of ordered triplet (p, q, r). 
// The function returns following values 
// 0 --> p, q and r are colinear 
// 1 --> Clockwise 
// 2 --> Counterclockwise 
int orientation(Point p, Point q, Point r) 
{ 
	int val = (q.y - p.y) * (r.x - q.x) - 
			(q.x - p.x) * (r.y - q.y); 

	if (val == 0) return 0; // colinear 
	return (val > 0)? 1: 2; // clock or counterclock wise 
} 


// Given three colinear points p, q, r, the function checks if 
// point q lies on line segment 'pr' 
bool onSegment(Point p, Point q, Point r) 
{ 
    return (q.x <= max(p.x, r.x) && q.x >= min(p.x, r.x) && 
            q.y <= max(p.y, r.y) && q.y >= min(p.y, r.y));
       
} 

// Prints convex hull of a set of n points. 
void convexHull(Point points[], int n) 
{ 
	// There must be at least 3 points 
	if (n < 3) return; 

	// Initialize Result 
	vector<Point> hull; 

	// Find the leftmost and bottom-most point 
	int l = 0; 
	for (int i = 1; i < n; i++) 
	{
		if (points[i].x < points[l].x) 
			l = i;
	
	    // For handling leftmost colinear points.
		else if (points[i].x == points[l].x && 
		         points[i].y < points[l].y)
		    l = i;       
	}
	
	// Start from leftmost point, keep moving counterclockwise 
	// until reach the start point again. This loop runs O(h) 
	// times where h is number of points in result or output. 
	int p = l, q; 
	do
	{ 
		// Add current point to result 
		hull.push_back(points[p]); 

		// Search for a point 'q' such that orientation(p, x, 
		// q) is counterclockwise for all points 'x'. The idea 
		// is to keep track of last visited most counterclock- 
		// wise point in q. If any point 'i' is more counterclock- 
		// wise than q, then update q. 
		q = (p+1)%n; 
		for (int i = 0; i < n; i++) 
		{ 
		    
		// If i is more counterclockwise than current q, then 
		// update q 
		if (orientation(points[p], points[i], points[q]) == 2) 
			q = i; 
		
		// HANDLING COLLINEAR POINTS 
		// If point q lies in the middle, then also update q
		if (p != i && orientation(points[p], points[i], points[q]) == 0 && 
			onSegment(points[p], points[q], points[i]))
			q = i; 
		} 

		// Now q is the most counterclockwise with respect to p 
		// Set p as q for next iteration, so that q is added to 
		// result 'hull' 
		p = q; 

	} while (p != l); // While we don't come to first point 

	// Print Result 
	for (int i = 0; i < hull.size(); i++) 
		cout << "(" << hull[i].x << ", "
			<< hull[i].y << ")\n"; 
} 

// Driver program to test above functions 
int main() 
{ 
	Point points[] = {{2, 2}, {4, 3}, {5, 4}, 
	                {0, 3}, {0, 2}, {0, 0}, {2, 1}, {2, 0}, {4, 0}}; 
	int n = sizeof(points)/sizeof(points[0]); 
	convexHull(points, n); 
	return 0; 
} 

Generated URL:

Output:

(0, 0)
(4, 0)
(5, 4)
(0, 3)
Report Bug