Possible Projects

Implement the test for castability discussed in the text and extend it to rotational removal from the mold (see exercise).
Compare the geometric and set versions of the D&C 2D convex hull algorithms.
Implement the linear-time convex hull alg. for simple polygons and compare it to the standard D&C or randomized incremental algorithms.
Compare the regular 2D range search method (running in O(log² n + k) time) with its accelerated cascading version (running in O(log n + k) time) and attempt to code the accelerated cascading version to minimize its overhead.
Code the randomized incremental Delaunay triangulation algorithm (the one that uses the "edge flip") and compare it to the library routine in LEDA for Delaunay triangulation (which uses another incremental approach).
Implement kd trees and (non-cascading) range search trees in 2d and 3d and test their running times for different types of point distributions.
Implement the randomized algorithm for 3D convex hulls that we discussed in class, then use it to compute 2D Voronoi diagrams (with the unit paraboloid trick) and compare with the LEDA library Voronoi diagram computation (which uses Fortune's algorithm).
Implement the trapezoidal decomposition algorithm discussed in class (which uses conflict lists and allows the input to be arbitrary segments and runs in expected time O(nlogn + k) ) to find all intersections between the input segments in expected time O(nlogn + k); test its running time behavior for a variety of segment distributions.
Use geowin (the LEDA animation system used in all class demos) to construct a new demo -- suggestions are: polygon kernel (easy), add Gabriel graph to existing Delaunay triangulation demo (easy), polygon skeleton (internal Voronoi diagram -- medium), 3D Voronoi diagram (harder), trapezoidal decomposition (harder)
Design, implement, and test an algorithm that find the smallest number of edge flips needed to transform one triangulation into another.
Use range trees and interval trees to set up a data structure for 2D boxes (axis-aligned rectangles) that will enable you to list all boxes intersected by a query box in time O(log n + k).
Compare the interval tree + priority search tree approach described in class and in the text (10.1 + 10.2) to the range tree + interval tree approach described in Exercise 10.1. That is, implement both versions, then test them on various distributions of segments for various types of rectangular queries. Use a brute-force linear-time algorithm for comparison and for testing correctness.
Implement two different approaches to solving the problem of: given a collection of axis-parallel rectangles in the plane, report all of those that are completely contained within a query axis-parallel rectangle. One approach is suggested in Exercise 5.13a (homework #5); another is to use a 2D range tree to list all rectangles that have one corner in the query rectangle, then test the other corner for each candidate; the result is not good from a theoretical point of view (it could take linear time and fail to report anything), but may prove faster in practice. Use a brute-force linear-time algorithm for comparison and for testing correctness.
Design an implement a O(n²) algorithm that, given a collection of segments in the plane, returns a stabbing line (a line that intersects every segment) if it exists and prints "no" otherwise. (Look at Chapter 8 and Exercise 8.10.) Test its actual running time as a function of the input -- what if all input segments are parallel? axis-aligned? collinear? isothetic (i.e., limited to some small constant number of slopes)?
Almost anything involving 4 or more dimensions (but keep it simple). For instance, box intersection in d dimensions, convex hull in d dimensions, etc.