UMass Lowell Computer Science Advanced Algorithms Computational Geometry Prof. Karen Daniels Spring, 2001 Lecture 7 Geometric Modeling Approximate Nearest Neighbor Searching Monday, 4/23/01

Part 2 Advanced Topics ApplicationsManufacturingModeling/Graphics Wireless Networks VisualizationTechniques(de)RandomizationApproximationRobustnessRepresentationsEpsilon-net Decomposition tree

Literature for Part II

Geometric Modeling “Triangle: Engineering a 2D Quality Mesh Generator and Delaunay Triangulator” Jonathan Richard Shewchuck

Goals ä Construct 2D mesh of triangles for geometric modeling that: ä avoids small angles ä constrained Delaunay triangulation ä is efficient in time and space ä careful choice of data structures & algorithm ä is robust ä adaptive exact arithmetic C code at

Approach: Overview ä Based on Ruppert’s Delaunay Refinement Algorithm ä Input: Planar Straight Line Graph (PSLG) ä collection of vertices and segments ä Step 1: Construct Delaunay triangulation of point set

Approach: Overview (continued) ä Step 2: ä Start with the Delaunay triangulation of the point set ä Add input segments ä segments become constraints ä constrained Delaunay triangulation some differences

Approach: Overview (continued) ä Step 3: ä Remove triangles from concavities ä “triangle-eating virus” ä Step 4: ä Refine mesh to satisfy additional constraints on triangle’s minimum ä angle size ä area

Step 1: Construct Delaunay Triangulation of Point Set ä Delaunay Triangulation Algorithms: ä O(nlogn) expected time: ä Randomized incremental insertion ä Edge flipping restores empty circle property ä O(nlogn) worst-case time: ä Compute Voronoi diagram, then dualize ä Fortune’s plane sweep (parabolic front) ä O(nlogn) worst-case time: ä Divide-and-Conquer ä alternating cuts Shewchuck experimental comparison [speed, correctness] fastest slowest [point location bottleneck] deBerg handout

Delaunay Triangulation Algorithms: Divide-and-Conquer ä O(nlogn) worst-case time ä Recursively halve input vertex set ä Stop when size = 2 or 3 ä Triangulate small set ä forms edge(s) or triangle ä Merge 2 triangulations ä Ghost triangles allow fast convex hull traversal ä Fit together like gear teeth

Step 2: Constrained Delaunay Triangulation ä Force mesh to conform to input line segments ä User Chooses Approach: ä Recursive segment subdivision ä Insert segment midpoint ä Flip edges to restore Delaunay (empty circle) property ä Constrained Delaunay triangulation (default) ä Insert entire segment ä Delete triangles it overlaps ä Retriangulate regions on each side of segment ä No new vertices are inserted

Step 4: Mesh Refinement ä Refine mesh to satisfy additional constraints on minimum triangle ä angle size ä area ä Insert new vertices ä Flip edges to restore Delaunay (empty circle) property ä Halting Issue: ä Halts for angle constraint <= 27 o ä May not halt for angle constraint >= 33.9 o

Step 4: Mesh Refinement (continued) ä Vertex Insertion Rules: ä Segment’s Diametral Circle ä smallest circle containing segment ä any point in the circle encroaches on segment ä split encroached segment ä insert vertex at midpoint ä Triangle’s Circumcircle ä circle through all 3 vertices ä bad triangle: ä angle too small ä area too large ä split bad triangle ä insert vertex at circumcenter

Step 4: Mesh Refinement (continued)

Implementation Issues: Representation ä Ghost triangles: ä connected in ring about a “vertex at infinity” ä facilitate convex hull traversal + Topologically richer + Elegant - Slower - More memory edge-based representation tradeoffs triangle-based - Topologically less rich - Longer code + Faster + Less memory Shewchuck preference

Implementation Issues: Robustness ä Tests ä Can influence program flow of control ä Can classify entities (e.g. sweep-line events) ä Depend on correctness of geometric predicates ä Orientation (left/right/on) ä In-Circle (in/out/on) ä Each computes sign of a determinant ä Constructions ä Represent geometric objects ä Often determine output incorrectness can be serious some incorrectness can sometimes be tolerated

Implementation Issues: Robustness (continued) ä Ideal Goal: real arithmetic for some operations ä Challenge: compounded roundoff error in floating- point arithmetic calculations: ä Tests: can cause program ä to hang ä to crash ä to produce incorrect output ä wrong topology ä Constructions: ä can cause approximate results What causes incorrectness?

Implementation Issues: Robustness (continued) ä Arithmetic Alternatives to Floating-Point: ä Integer or rational exact arithmetic ä fixed precision ä extended precision ä Floating point +   -testing ä robust topological decisions ä filter: ä identify adequate precision for an operation (bit complexity) ä if expressible as multivariate polynomial, degree gives clue ä floating-point comparisons except when correctness is threatened ä adaptive precision: ä compute quantity (e.g. sign of determinant) via successively more accurate approximations ä stop when uncertainty in result is small No single solution fits all needs. Collection of techniques is needed. slow but sure fast but loose exact floating-pt hybrid time vs. error tradeoff

Implementation Issues: Robustness (continued) ä Shewchuck uses: ä multi-stage adaptive precision for geometric primitives ä Orientation (left/right/on) ä In-Circle (in/out/on) ä Each ä computes sign of a determinant ä takes floating-pt inputs ä stops when uncertainty in result is small ä can reuse previous, less accurate approximations ä fast arbitrary precision arithmetic ä for small (yet extended) precision values For general discussion of robustness issues and alternatives, see Strategic Directions in Computational Geometry Working Group Report

Approximate Nearest Neighbor Searching “An Optimal Algorithm for Approximate Nearest Neighbor Searching in Fixed Dimensions” Arya, Mount, Netanyahu, Silverman, Wu

Goals ä Fast nearest neighbor query in d- dimensional set of n points: ä approximate nearest neighbor  distance within factor of (1+  ) of true closest neighbor ä preprocess using O(dnlogn) time, O(dn) space ä Balanced-Box Decomposition (BDD) tree  note that space, time are indepenent of   query in O(c d,   logn) time C++ code for simplified version is at

Approach: Distance Assumptions ä Use L p (also called Minkowski) metric ä assume it can be computed in O(d) time ä pth root need not be computed when comparing distances ä Approximate nearest neighbor  distance within factor of (1+  ) of true closest neighbor p*  Can change  or metric without rebuilding data structure

Approach: Overview ä Preprocess points: ä Balanced-Box Decomposition (BDD) tree ä Query algorithm: for query point q ä Locate leaf cell containing q in O(log n) time ä Priority search: Enumerate leaf cells in increasing distance order from q ä For each leaf cell, calculate distance from q to cell’s point ä Keep track of closest point p seen so far  Stop when distance from q to leaf > dist(q,p)/(1+  ) ä Return p as approximate nearest neighbor to q.

Balanced Box Decomposition (BBD) Tree ä Similar to kd-tree [Samet handout] ä Binary tree ä Tree structure stored in main memory ä Cutting planes are orthogonal to axes ä Alternating dimensions ä O(log n) height ä Subdivides space into regions of O(d) complexity using d- dimensional rectangles ä Can be built in O(dn log n) time x1x1 x4x4 x3x3 y1y1 x2x2 y2y2 y3y3 One possible kd-like tree for the above points (not a BDD tree, though) y1y1 x1x1 x1x1 2 7 y2y2 1 5 y2y2 y3y3 x2x2 8 9 x3x3 x4x < >=

Balanced Box Decomposition (BBD) Tree (continued) ä Distinguishing features of BBD tree: ä Cell is either ä d-dimensional rectangle or ä difference of 2 d-dimensional nested rectangles ä In this sense, BDD tree is like: ä Optimized kd-tree: partition points into roughly = sized sets ä While descending in tree, number of points on path decreases exponentially ä Specialized Quadtree: aspect ratio of box is bounded by a constant ä While descending in tree, size of region on path decreases exponentially ä Leaf may be associated with more than 1 point in/on cell: O(n) node ä Inner boxes are “sticky”: if it is close to edge, it “sticks” subdivision tree split shrink

Splitting a Box: Midpoint

Splitting a Box: Middle-Interval

Packing Constraint

Priority Search from Query Point

Incremental Distance [Arya, Mount93] ä Incrementally update distance from parent box to each child when split is performed ä Maintain sum of appropriate powers of coordinate differences between query point and nearest point of outer box ä Split: ä Closer child has same distance as parent ä Further child’s distance needs only 1-coordinate update (along splitting dimension) ä Makes a difference in higher dimensions!

Experiments Experiments generated points from a variety of probability distributions: UniformGaussianLaplaceCorrelated Gaussian Correlated LaplacianClustered GaussianClustered Segments

Experiments

Conclusions ä Algorithm is not necessarily practical for large dimensions ä But, for dimensions <= ~20, does well ä Shrinking helps with highly clustered datasets, but was not often needed in their experiments ä Only needed for 5-20% of tree nodes ä BBD tree (in paper’s form) is primarily for static point set ä But, auxiliary data structure could maintain changes

Project Update

Project ProposalMonday, 4/92% Interim ReportMonday, 4/235% Final PresentationMonday, 5/78% Final SubmissionMonday, 5/1410% 25% of course grade DeliverableDue Date Grade %

Guidelines: Final Submission ä Abstract: Concise overview (at most 1 page) ä Introduction: ä Motivation: Why did you choose this project? ä Related Work: Context with respect to CG literature ä Summary of Results ä Main Body of Paper: (one or more sections) ä Conclusion: ä Summary: What did you accomplish? ä Future Work: What would you do if you had more time? ä References: Bibliography (papers, books that you used) Well- written final submissions with research content may be eligible for publishing as UMass Lowell CS technical reports.

Guidelines: Final Submission ä Main Body of Paper: ä If your project involves Theory/ Algorithm: ä Informal algorithm description (& example) ä Pseudocode ä Analysis: ä Correctness ä Solutions generated by algorithm are correct ä account for degenerate/boundary/special cases ä If a correct solution exists, algorithm finds it ä Control structures (loops, recursions,...) terminate correctly ä Asymptotic Running Time and/or Space Usage

Guidelines: Final Submission ä Main Body of Paper: ä If your project involves Implementation: ä Informal description ä Resources & Environment: ä what language did you code in? ä what existing code did you use? (software libraries, etc.) ä what equipment did you use? (machine, OS, compiler) ä Assumptions ä parameter values ä Test cases ä tables, figures ä representative examples

Guidelines: Interim Report ä Structured like Final Submission, except: ä no Abstract or Conclusion ä fill in only what you’ve done so far ä can be revised later ä include a revised proposal if needed ä identify any issues you have encountered and your plan for resolving them