Editing Convex hull

In [[computational geometry]], the '''convex hull''' of a set of points is the smallest convex set (minimal area, volume, ''etc''.) which contains every point in that set.

==Intuitive interpretations for the planar convex hull==
* If a set of points were given in two dimensions by hammering nails into them on a flat wooden board, the convex hull would be the polygon whose boundary is given by stretching and releasing a rubber band around all of the nails.
* If the points represented the locations of sheep grazing in a field, the convex hull would be the minimal-perimeter fence enclosing all of the sheep. {{SPOJ|BSHEEP|}}
* If the points represented the locations of fence posts, the convex hull would be the fence enclosing the maximum possible area while consisting only of straight segments using those fence posts as endpoints. {{problem|ccc07s2p1|}}
* If the points represented the locations of prize-winning maple trees, the perimeter of the convex hull would be the minimum length of blue ribbon required to enclose all of them. {{problem|ccc99s2p4|}}

==Planar convex hull algorithms==
The problem of finding the convex hull of a set of points in the plane is one of the best-studied in computational geometry and a variety of algorithms exist for solving it. Here are three algorithms introduced in increasing order of conceptual difficulty:

===Gift-wrapping algorithm===
The ''gift-wrapping'' algorithm, also known as the ''Jarvis march'', is one of the simplest and most intuitive planar convex hull algorithms. The name derives from the analogy of the method to walking around the set of points with gift wrapping paper until arriving back at one's starting location.

The first step in the algorithm is to select a point which ''must'' be in the convex hull, for example, the point with highest y-coordinate. The wrapping paper will start here, and we will walk around the point set until we arrive back at this point. Initially we will face the right (increasing x-coordinate). At any given time we maintain both a point <math>P</math> (our location) and a [[Computational_geometry#Vectors|vector]] <math>\mathbf{v}</math> (the direction we are facing). The algorithm then proceeds in a series of steps. In each step, we turn clockwise until we are directly facing a point, say, <math>Q</math>. Then, we walk over to that point (bringing the wrapping paper along with us). In doing so, notice that the new value of <math>\mathbf{v}</math> is set to <math>Q-P</math> (since that is the direction we now face) and <math>P</math> is set to <math>Q</math> (that's where we are). This procedure is repeated until <math>P</math> equals its starting value. After the completion of the algorithm we will have visited all of the points of the convex hull in clockwise order.

To determine which point we actually see first as we turn clockwise, we loop through all points <math>R</math> (except for <math>P</math> itself), for each point considering the vector <math>\mathbf{u} = R-P</math>. The <math>\mathbf{u}</math> which makes the smallest angle <math>\theta</math> with <math>\mathbf{v}</math> corresponds to <math>Q</math>, the point we should visit next. (This makes sense; it means we will have to turn through the smallest possible angle to get there). To minimize <math>\theta</math>, we maximize <math>\cos \theta</math>, which can be computed as simply <math>\frac{\mathbf{u}\cdot\mathbf{v}}{\|\mathbf{u}\|\|\mathbf{v}\|}</math>.

Each step of the algorithm (picking the next point) requires considering all the other points in the set, so it takes <math>O(n)</math> time, where <math>n</math> is the total number of points. The number of steps executed equals the number of points that are actually on the hull, denoted <math>h</math>, so the total time taken is <math>O(nh)</math>. In the worst case, in which <math>h=n</math> and all the points in the input already form a convex polygon, the performance is <math>O(n^2)</math>. It is not recommended to use this algorithm when <math>n > 5000</math>.

===Graham scan===
The ''Graham scan'' has much better worst-case performance than the Jarvis march, but is also more complicated. First, some point (not necessarily one of the points in input) is identified which is definitely ''inside'' the convex hull. Averaging the coordinates of all of the points given is the recommended technique for doing so. We place the origin of our coordinate system there, transforming the coordinates of the input points accordingly. We then proceed to sort the points by angle. (That is, for each point <math>P</math> in the input, we consider the directed angle the ray <math>\overrightarrow{OP}</math> makes with the positive x-axis; we sort in increasing order of this angle.) Ties are broken arbitrarily. Initially we don't know any points which might be in the hull, so we set <math>h=0</math>. We then consider all points in order of increasing angle, modifying what we believe to be the hull so far during each step. Denote the current hull <math>H</math>, the point added earliest to <math>H_1</math>, and so on up to <math>H_h</math>, the point most recently added. In each step we do the following:
# Add the current point <math>P</math> to the end of <math>H</math>. That is, increment <math>h</math> and set <math>H_h = P</math>.
# If <math>h < 3</math>, proceed to the next point.
# Consider the points <math>H_h</math>, <math>H_{h-1}</math>, and <math>H_{h-2}</math>. It is possible that after we have added the point <math>H_h</math>, we are now certain that <math>H_{h-1}</math> is not actually part of the hull. Consider the vectors <math>\mathbf{u} = H_{h-1} - H_{h-2}</math> and <math>\mathbf{v} = H_h - H_{h-1}</math>. If <math>\mathbf{v}</math> is a counterclockwise turn from <math>\mathbf{u}</math>, that is, [[Computational_geometry#Determinant|<math>\mathbf{u} \times \mathbf{v} > 0 </math>]], then everything is fine, and we go on to the next point. But if <math>\mathbf{v}</math> is a clockwise turn from <math>\mathbf{u}</math>, that is, <math>\mathbf{u} \times \mathbf{v} < 0</math>, then the angle <math>\angle H_{h-2} H_{h-1} H_h</math> is "concave" and <math>H_{h-1}</math> must be removed. This means that <math>H_{h-1}</math> is set to <math>H_h</math> and <math>h</math> is decremented. Then go back to step 2.

At this point we have a set of points <math>H_1, H_2, ..., H_h</math> sorted in counterclockwise order. The problem is that we do not actually know whether <math>H_1</math> is in the hull or not; notice that it can never be removed during the first phase of the algorithm. Also, since the convex hull is a ring, not a chain, we also have to consider the fact that <math>H_h</math> is not really part of the hull either; note that it also wouldn't have been removed during the first phase of the algorithm. The way we eliminated points before was by considering three consecutive points in the hull and deciding whether to remove the middle one. We must now subject <math>H_1</math> and <math>H_h</math> to this repeatedly until no more changes can be made:
# Consider the three points <math>H_2</math>, <math>H_1</math>, and <math>H_h</math>. Let <math>\mathbf{u} = H_1 - H_h</math> and <math>\mathbf{v} = H_2 - H_1</math>. If <math>\mathbf{u} \times \mathbf{v} < 0</math>, then <math>H_1</math> must be removed from the hull.
# Consider the three points <math>H_1</math>, <math>H_h</math>, and <math>H_{h-1}</math>. Let <math>\mathbf{u} = H_h - H_{h-1}</math> and <math>\mathbf{v} = H_1 - H_h</math>. If <math>\mathbf{u} \times \mathbf{v} < 0</math>, then <math>H_h</math> must be removed from the hull.
# If neither of steps 1 and 2 were executed, we are done; what remains is the true convex hull, given in counterclockwise order. Otherwise, go back to step 1.
In order to ensure that we can delete <math>H_1</math> in constant time (which shifts over all the other elements, so that the new <math>H_1</math> is the old <math>H_2</math>, and so on), we should use a [[deque]] or [[linked list]] to store <math>H</math>.

The initial sort takes <math>O(n \log n)</math> time. In the remainder of the algorithm, each point is added to the hull exactly once, so all the "add" operations take <math>O(n)</math> time in total. Each point can also be removed up to once, so all the "remove" operations take <math>O(n)</math> time total. Finally, in each step, in which we may examine several triples of consecutive points to determine if the middle point should be removed, notice that we stop after we encounter a point which should not be removed. That is, in each step, the number of "consider" operations is at most one more than the number of points removed, and hence in total the number of "consider" operations is at most <math>2n</math>, and take <math>O(n)</math> time in total. Overall, the sort dominates the running time, which is <math>O(n \log n)</math>, suitable for almost any application.

===Monotone chains algorithm===
The ''monotone chains algorithm'' is both easy to code (although arguably conceptually difficult) and the fastest of the three algorithms in this section. It is based on computing two "monotone chains" of the convex hull: the ''upper chain'' and the ''lower chain''. The leftmost and rightmost points of the input set must both be in the convex hull. The part of the hull clockwise from the leftmost point and counterclockwise from the rightmost point is called the ''upper chain''; the rest is the ''lower chain''. We compute the upper and lower chains separately.

The first step is to sort all of the given points in increasing order of x-coordinate. Ties are broken by increasing order of y-coordinate. We then begin to compute the upper chain. The first point in the set is the leftmost point (or the lowest leftmost point, if there are several), and must be on the hull. We then consider the points in order. Again, denote the current hull as <math>H</math> and the size of the hull as <math>h</math>, where <math>H_1</math> is the first point in the hull and <math>H_h</math> is the last. For each point considered:
# Add this point to <math>H</math>.
# If <math>h < 3</math>, continue to the next point.
# Consider the vectors <math>\mathbf{u} = H_{h-1} - H_{h-2}</math> and <math>\mathbf{v} = H_h - H_{h-1}</math>. This time, since we have to travel clockwise to build the upper hull, we check if <math>\mathbf{u} \times \mathbf{v} < 0</math>. If so, we proceed to the next point. Otherwise, we remove <math>H_{h-1}</math> and go back to step 2.

After considering all of the points in this manner, <math>H</math> contains the entire upper chain. We then proceed to compute the lower chain in exactly the same way, except that we consider the points in ''reverse'' order (that is, we start at the rightmost point). (Take care not to add the rightmost point to the hull twice.) On termination of the algorithm, <math>H</math> will contain the entire hull in clockwise order, with the first point repeated at the end.

Again, the running time is <math>O(n \log n)</math>; the sorting cost dominates. The monotone chains algorithm is the algorithm recommended for all applications, being simpler than the Graham scan and a bit faster (since we don't have to compute angles).

===Degenerate input===
Ideally, we would like to have the input points in ''general position'', with no two points coincident nor three points lying on the same line. However, this is not always possible, and coincident and collinear points must be dealt with. To lapse into a full discussion of cases would be tedious and boring. Instead, consider the following:
* Read the problem statement for clarification on what to do with degenerate input. (Note that it will almost surely not refer to it as ''degenerate''.)
* If there are coincident points:
:* the Jarvis march might divide by zero. This '''must''' be avoided to ensure the correctness of the implementation.
:* If we only need to report the perimeter or area of the hull, the other two algorithms have no trouble with handling coincident points (except for the pathological case discussed further below for the Graham scan).
:* If we actually have to report the points, there are three conceivable orders in which we might be asked to do so: clockwise, counterclockwise, or in the same order as in the input file (increasing "ID"). Clearly the first two are meaningless if coincident points are allowed. In the third, we might be asked to report only the first point if several points are coincident, or to report all of them. Read the problem statement carefully. In any case, we can efficiently postprocess the points to make the output conform to specification. This is probably easier than attempting to compute the correct output exactly while running the convex hull algorithm.
* If there are collinear points:
:* We need to know whether the problem statement requires us to output the maximum possible number of points or the minimum possible number of points. That is, should we include points that fall in the interior of an edge in the hull? If there are collinear points but no coincident ones, the Graham scan and the monotone chains algorithm can be used to handle either case gracefully, by using either a <math><</math> or a <math>\le</math> sign in our test. In the Jarvis march, we choose either the closest or the farthest point when there are ties in angle.
:* Ordering is not an issue, unless we're asked to output the maximum possible number of points in increasing order of ID to break ties along edges. In this case, postprocessing is almost certainly the easiest solution.
* The worst pathological cases occur when the area of the hull is zero. There are two ways in which this might happen, but both are trivial to handle: all points might be coincident, or all points might lie on a single line. If such cases are allowed to be given in the input:
:* The monotone chains algorithm will still work properly if only the perimeter or area needs to be reported.
:* If the points themselves need to be reported, it is probably not worth the effort to make the algorithms handle them gracefully; instead, it is trivial to simply compute the hulls separately by sorting the points.

==Applications==
Other than the obvious interpretations:
* [[Farthest pair of points]]
* Consider the following problem <sup>[can someone track down the source, please?]</sup>: you are given several colors of paint. Each one was created by mixing together a certain nonzero amount of each of the three primary subtractive colors (cyan, magenta, and yellow), and is hence given as a triplet in the input. Assume that the color of a given mixture depends only on the ratios of the amounts of the three primary colors present. By mixing paints, can we obtain a target color (also given as a triplet)? The amount is not important. It turns out that this problem may be solved using the two-dimensional convex hull. First of all, we ''normalize'' each paint by dividing each component by the amount of cyan paint present. (This does not actually change the color, as ratios are preserved.) We do the same for the target triplet. Then we discard all the cyan components entirely, since they are all 1, and focus on the other two components. Each color may then be plotted as a point on the plane. The possible target colors are those which lie inside the convex hull of the colors given. This is because when we mix together two paints, each component of the new color is the same linear combination of the components of the two original paints; since ratios are unimportant we can always normalize the result, so that the cyan 1s will always stay as 1s; and the new point obtained will therefore lie on the line segment joining the two original points. The convex hull is the set of all points reachable by executing this procedure an arbitrary number of times.

==Three-dimensional convex hull==
Computing a convex hull in <math>\mathbb{R}^3</math> is significantly more challenging. It is a task which will most likely never be given on competitions such as the [[IOI]], and it is not recommended that high school students learn it. However, there is a fairly simple <math>O(n^2)</math> algorithm, which works as follows: first project all of the points onto the xy-plane, and find an edge that is definitely on the hull by selecting the point with highest y-coordinate and then doing one iteration of gift wrapping to determine the other endpoint of the edge. This is the first part of the incomplete hull. We then build the hull iteratively. Consider this first edge; now find another point in order to form the first triangular face of the hull. We do this by picking the point such that all the other points lie to the right of this triangle, when viewed appropriately (just as in the gift-wrapping algorithm, in which we picked an edge such that all other points lay to the right of that edge). Now there are three edges in the hull; to continue, we pick one of them arbitrarily, and again scan through all the points to find another point to build a new triangle with this edge, and repeat this until there are no edges left. (When we create a new triangular face, we add two edges to the pool; however, we have to first check if they have ''already'' been added to the hull, in which case we ignore them.) There are <math>O(n)</math> faces, and each iteration takes <math>O(n)</math> time since we must scan all of the remaining points, giving <math>O(n^2)</math>. (If you feel like coding this, you might try {{SPOJ|CH3D|CH3D@SPOJ}}.) It is possible to speed up this algorithm significantly by initially discarding a large number of points we know not to be in the hull; one easy way that performs quite well is to find both extremal points with respect to each of the three coordinate axes, and discard all points in the interior of the tetrahedron they form.

It is possible to compute a 3D convex hull in <math>O(n \log n)</math> time using a divide-and-conquer algorithm, but this is extremely difficult.

[[Category:Algorithms]]
[[Category:Geometry]]
[[Category:Pages needing diagrams]]