Approximations of points and polygonal chains

1. Approximations of points and polygonal chains • Approximation of points by a line: find a line l (if one exists) such that all points are within distance εfrom l, under some distance metric. • Other definitions possible: find line l that minimizes the maximum distance from the points to l.

2. Distance Metrics • Uniform metric (prev. slide). • yi-f(xi) ≤ ε • Euclidean metric. • L1 and L∞ metrics. • Other measures possible (will be introduced latter).

3. Approx. of points by line • Each vertical line segment maps to a parallel strip in a dual point/line space (duality transform, to be explained shortly). • Can define the strip as intersection of two halfplanes. • Then solve a 2-D linear programming (LP) problem, which takes O(n) time.

4. Approx. points by min-# chain • Would a simple Greedy algorithm work? • Stab as many as possible, discard them and repeat.

5. Greedy vs. Dynamic Programming • If objects are convex and disjoint, O(n) time greedy algorithm is possible (vertices are unrestricted, that is, can lie anywhere). • For intersecting objects, dynamic programming gives O(n2) and O(n2 log n) time, depending on how visiting order of objects is defined.

6. Min-# vs. Min-ε • Min-#: given some error bound, minimize number of vertices of approximating path. • Min-ε: minimize the error of an approximating path that has at most a specified number of vertices, m (m < n). • If finite set of possible approximation errors, and if set can be computed in reasonable time, then can use min-# to solve min-ε.

7. Points vs. Chains • Define a piecewise linear region associated with the input, as in figure. • May ask approximating path stays in that region, for chains. • Chains may be monotone (functions) or not.

8. Min-# for Piecewise Linear Function • Approximation must stay in error region. • Approximation sought: monotone polygonal line with min-# of vertices. • Use “edge visibility” concept. • A point u of polygon P is visible from edge e, if there is point v on e such that line segment uv is contained in P. • An edge e’ is visible from e if there is a point of e’ visible from e. • Visibility polygon VP(P,e): points of P visible from e.

9. Visibility: VP(P,e) • VP(P,e) splits the polygon in a few connected regions: • Visible region/polygon; • Invisible polygons. • Consider the invisible polygon P’ that contains end point of chain. • Common boundary of P and P’ is a line segment called “window”. • Use “convex hull” algorithm to find windows. • Results in O(n) time algorithm.

10. Error criteria for chains • E1: Tolerance zone. • E2: Parallel-strip (also called “infinite beam”). • E3: Parallel rectangle: half of min. width of rectangle containing pk, i≤ k≤ j, with parallel sides orthogonal on line segment pipj. • E4: Rectangle: required only contain pk, i≤ k ≤j.

11. General Approach Using Graphs • Given: C=p1p2…pn, polygonal chain. • Directed graph G(C): • Vertex vi corresponds to point pi. • Edge (vi,vj) has weight = error of segment pipj. • For given error bound ε: G(C,ε): • Subgraph of G with edge weights ≤ ε. • A path in G(C,ε): corresponds to approximating curve with error at most ε. • Approximating curve for min-#: • Shortest path from v1 to vn in G(C,ε) (length is # arcs). • Use BFS to find it. • Min-ε: minimize ε such that in G(C,ε) there is path with at most a specified # of vertices.

12. Complexity • If G(C) can be computed in f(n) time: • Min-# can be solved in O(f(n)+n2) time. • Min-ε can be solved in O(f(n)+n2 log n) time. • If G(C,ε) can be computed in g(n) time: • Min-# can be solved in O(g(n)+n2) time. • Most of known solutions use this approach (see solution on handout paper for some exceptions). • The “closed” min-# and min-ε problems can eventually be solved by solving n “open” problems (better in some cases; depends on restrictions).

13. Complexities • Under error criteria discussed: • e1: O(n2) and O(n2 log n) time, O(n) space. • Constructs G(C,ε). • Makes use of binary search with less space. • e2: O(n2 log n) time, O(n) and O(n2) space. • Constructs G(C). • O(n2) possible if some condition holds. • Even o(n2) possible if that condition holds. • e3: O(n2 log n) time, O(n2) space (O(n) space possible?!). • Constructs G(C). • e4: O(n log n) time, O(mn log n log (n/m)) space.

14. Min-# under E4 • Property: In G(C,ε), if (vi,vj) є G, then (vk,vl) є G, i ≤ k < l ≤ j. • Algorithm 1: • v=1; i(1)=1; • i(v+1)=max{j | (vi,vj) є G(c,ε)}; • if i(v+1)==n then done; else v=v+1; return to 2. • The algorithm is greedy.

15. E4 (cont.) • There is a rectangle of width w that covers a set V of points such that it contains an edge of CH(V). • W(i,j): min. width of rectangle covering V. • For e є CH(V): • Antipodal point: point v of CH(V) farthest from line containing e. • d(e): distance from v to line containing e. • W(i,j)=min{d(e) | e is on CH(i,j)}. • Given CH(V), can find antipodal points of all edges in O(|V|) time.

16. E4 (cont.) • Algorithm 1’: • v=1; i(1)=1; • i(v+1)=max{j | i(v) < j ≤ n, W(i(v),j) ≤ w}; • if i(v+1)==n then done; else v=v+1; go to step 2. • Step 2 is main step. • Will show for v=1 van be executed in O(i* log i*) where i*=i(2).

17. E4 (cont.) • W(1,j) nondecreasing in j: use doublingbinary search to find i*. • Find m, l such that W(1,m) ≤ w, W(1,l) > w and m < l ≤ min{2m,n} • Start with m=1, l=2; double each until holds. • i* lies between m and l-1. • Again binary search to find i*:

18. E4 (cont.) • Algorithm 2: • k=m; l=l-1; Construct and keep CH(1,k); • h=(k+l)/2; Construct CH(k+1,h); Construct CH(1,h) from CH(1,k), CH(k+1,h); Compute wh=W(1,h); • If wh≤ w then k=h; else l=h-1; If k==l then i*=k and done; else keep CH(1,k) and go to step 2.

19. E4 (cont.) • Algorithm 1’+2 takes O(n log n). • Compute W(1,2g), g=1,2,..,M+1, M=log m. • W(1,j) can be found in O(j log j). • O(Σ2glog2g)=O(i*logi*). • Note that m=O(i*). • Step 2 in Alg. 2 takes O(i*logi*) • CH(1,h): O(h) (from CH(1,k) and CH(k+1,h); • W(1,h): O(h) time; • In g-th iteration CH(k+1,h) is on at most m2-g=2M-g points: O(2M-glog2M-g) time. • Executed at most M times (g=1,…M):O(Σ2M-glogM-g)=O(i*logi*).

20. Min-ε under E4 • O(mn(log n)(log n/m) time. (outputsensitive). • Algorithm 3 (compute min. width w*). • M’=m; i=1; w=0; • Find j, by doubling binary search, such that • i < j ≤ n, • pi,…,pn cannot be covered by m’ or fewer rectangles with width less than W(i,j), • pi,…,pn can be covered by m’ or fewer rectangles with width less than W(i,j+1). • i=j; m’=m-1; w=max{w,W(i,j)}; If i=n done; else go to step 2. • Note: in a sequence of rectangles with width w* found by min-#, the first rectangle cover points p1,…,pj, where j is found in first execution of step 2 above (then induction).