Kinetic convex hull

The dual of a convex hull of a set of points is the upper and lower envelopes of the dual set of lines. Therefore, maintaining the upper and lower envelopes of a set of moving lines is equivalent to maintaining the convex hull of a set of moving points. Computing upper and lower envelopes are equivalent problems, so computing the upper envelope of a set of lines is equivalent to computing the convex hull of a set of moving points. The upper envelope of a set of static lines can be computed using a divide and conquer algorithm which partitions the lines into two sets of equal size, calls itself recursively on the two sets to find their upper envelopes, and then merges the two resulting upper envelopes. The merge step is performed using a vertical line sweep. Call the first set of points blue and the second set of points red.

The standard line sweep algorithm for merging upper envelopes sweeps though all of vertices of the red and blue upper envelopes, from left to right. The most recently encountered red and blue points are maintained as the line sweeps. When a point is encountered, the algorithm checks if the point is above or below the segment following the last encountered point of the opposite color. If it is above, that point is added to the merged upper envelope. If it is of a different color than the last added point, the red and blue envelopes have crossed, so the intersection point is also added to the merged upper envelope.[2]

The sequence of edges and vertices resulting from this algorithm is only dependent on the ordering of points, and the results of the line-point comparisons. Thus, the result can be certified with the following certificates:

• x-certificates (${\displaystyle <_{x}}$) are used to certify the order the vertices of the red and blue envelopes. They are the certificates for a kinetic sorted list on the set of vertices. Since each point involves 2 lines, and the certificate involves 2 points, each certificate involves 4 lines.
• y-certificates (${\displaystyle <_{y}}$) are used to certify that a vertex is above or below an edge. The certificates appear for all comparisons that would occur during the algorithm.

As long as all of these certificates hold, the merge steps will be executed identically, so the resulting upper envelope will be the same. A kinetic data structure for upper envelopes can be created by using these certificates to certify the static upper envelope algorithm. However, this scheme is not local, because one line many be involved in many y-certificates if it remains on top or bottom as many points from the other envelope are encountered.

Thus, it is necessary to introduce a s-certificates (${\displaystyle <_{s}}$) which certifies that the slope of a line is greater than or less than the slope of another line.

Having the following certificates for all points ab is sufficient to certify the sequence of edges and vertices resulting from a merge, with only O(1) certificates per line:[1]

The certificates certify structure of the intersection of the red and blue envelopes by certifying intersections(top left) or the absence of intersections(top right and bottom). The arrows indicate which elements are being compared by the certificate.

1. ${\displaystyle x[ab]}$: ${\displaystyle ab<_{x}ab.next}$. ${\displaystyle ab.next}$ denotes vertex closest to ${\displaystyle ab}$ on its right. This certificate is stored for all points ${\displaystyle ab}$ which have a different color than the point, ${\displaystyle ab.next}$, which follows them.
2. ${\displaystyle yli[ab]}$: ${\displaystyle ab<_{y}ce(ab)}$ or ${\displaystyle ab>_{y}ce(ab)}$. This certificate is stored for all points ${\displaystyle ab}$ such that ${\displaystyle b}$ intersects ${\displaystyle ce(ab)}$. ${\displaystyle ce(ab)}$ denotes the contender edge of ${\displaystyle ab}$, the edge from the other envelope that is above or below ${\displaystyle ab}$.
3. ${\displaystyle yri[ab]}$: ${\displaystyle ab<_{y}ce(ab)}$ or ${\displaystyle ab>_{y}ce(ab)}$. This certificate is stored for all points ${\displaystyle ab}$ such that ${\displaystyle a}$ intersects ${\displaystyle ce(ab)}$.
4. ${\displaystyle yt[ab]}$: ${\displaystyle ce(ab)<_{y}ab}$. This certificate is stored for all points ${\displaystyle ab}$ for which ${\displaystyle a<_{s}ce(ab)<_{s}b}$ and ${\displaystyle ce(ab)<_{y}ab}$.
5. ${\displaystyle srt[ab]}$: ${\displaystyle a<_{s}ce(ab)}$. This certificate is stored for all points ${\displaystyle ab}$ for which ${\displaystyle a<_{s}ce(ab)<_{s}b}$ and ${\displaystyle ce(ab)<_{y}ab}$.
6. ${\displaystyle srt[ab]}$: ${\displaystyle ce(ab)<_{s}b}$. This certificate is stored for all points ${\displaystyle ab}$ for which ${\displaystyle a<_{s}ce(ab)<_{s}b}$ and ${\displaystyle ce(ab)<_{y}ab}$.
7. ${\displaystyle sl[ab]}$: ${\displaystyle b<_{s}ce(ab)}$. This certificate is stored for all points ${\displaystyle ab}$ for which ${\displaystyle b<_{s}ce(ab)}$ and ${\displaystyle ab<_{y}ce(ab)}$.
8. ${\displaystyle sr[ab]}$: ${\displaystyle ce(ab)<_{s}a}$. This certificate is stored for all points ${\displaystyle ab}$ for which ${\displaystyle ce(ab)<_{s}a}$ and ${\displaystyle ab<_{y}ce(ab)}$.

The first certificate, ${\displaystyle x[ab]}$, certifies the x-ordering of the points in the red and blue envelopes. The second and third certificates, ${\displaystyle yli[ab]}$ and ${\displaystyle yri[ab]}$, certify intersections of the red and blue envelopes. The remaining 5 certificates, ${\displaystyle yt[ab]}$, ${\displaystyle srt[ab]}$, ${\displaystyle srt[ab]}$, ${\displaystyle sl[ab]}$, and ${\displaystyle sr[ab]}$ place edges that are not in the upper envelopes in the sequence of slopes of the edges that are above it. If the slope is at the start or end of the sequence, ${\displaystyle sl}$ or ${\displaystyle sr}$ certify this. If it is in the middle of the sequence ${\displaystyle slt}$, and ${\displaystyle srt}$ certify this, and ${\displaystyle yt}$ certifies that the intersection point of the two lines that the edge's slope is in between, is above it. These one or three certificates suffice to prove that all of the edges are above this line. Unlike the previous scheme all lines are only involved in a constant number of certificates. Whenever of these certificates fail, the merged envelope and certificates can be updated in O(1) time.

The kinetic data structure for convex hull is constructed by using these certificates to certify the recursive merge of the upper envelopes. Whenever certificates fail, their merge is updated, and if the envelope resulting from the merge changes, the changes are propagated up through all merges that depend on the result of the merge.[1]

This data structure is responsive, local, compact, and efficient. This is due to the logarithmic depth of the merges used to certify the upper envelope.[1]

• Responsive: When a certificate fails, it takes O(1) to fix the merge it certifies. If the resulting envelope changes, the change must be propagated up to all merges that depend on the result of the changed merge. There are O(log n) such mergers, so the update can be performed in O(log n) time total.
• Local: Each line is involved in a most O(log n) certificates. This is because each line is involved in a constant number of certificates in each merge, and each line is in O(log n) merges total.
• Compactness: The maximum number of certificates used in this data structure is O(n log n). This is because each merge involves a number of certificates linear to the number of lines merged. Certifying an upper envelope of n lines requires certificates for the merge upper envelope of the two subsets of n/2 lines, and certificates for the merge of the envelopes. Thus the number of certificates, C(n), required to certify the upper envelope of n lines satisfies the recurrence C(n)=2C(n/2)+O(n), with C(1)=O(1). By the master theorem for divide-and-conquer recurrences, C(n)=O(n log n).
• Efficiency: The maximum number of events processed by this algorithm on algebraic or pseudo-algebraic trajectories is near quadratic, ${\displaystyle O(n^{2+\epsilon })}$ for all ${\displaystyle \epsilon >0}$.[3][4] Convex hulls of linearly moving points can change ${\displaystyle \Omega (n^{2})}$ times.[5] Thus this data structure is efficient.