多边形相交查找的优化

Question

I have ~1 billion 2D polygons, each with between 5 and 2000 vertices, laid out on a geographical map. I want to generate cutout masks of these polygons in the bounded range of a quadrangle which is a square portion of the map. I have a naively-coded solution which collects all the polygons that overlap the quadrangle bounds, then creates a mask and draws each of the polygons which it has found to be overlapping with the quadrangle bounds.

relevant code:

def generate_alteration_layers_by_extent(alterations, poly_locators, extents, output_res=1000):
    left, right, upper, lower = extents
    query_rectangle = pysal.cg.shapes.Rectangle(left, lower, right, upper)
    num_layers = len(shapes_by_alterations)
    boxed_alteration_layers = []
    for i, (alteration, poly_locator) in enumerate(zip(alterations, poly_locators)):
        print "computing overlapping polygons"
        overlapping_polys = poly_locator.overlapping(query_rectangle)
        print "drawing polygons onto mask"
        img = Image.new('L', (output_res, output_res), 0)
        polys = [np.array(map(list, poly.vertices)) for poly in overlapping_polys]
        for poly in polys: 
            # normalize to the dimensions of img
            poly[:,0] -= left;  poly[:,0] *= (right-left); poly[:,0] *= output_res
            poly[:,1] -= lower; poly[:,1] *= (upper-lower); poly[:,1] *= output_res
            ImageDraw.Draw(img).polygon(poly, outline=1, fill=1)
        mask = np.array(img)
        boxed_alteration_layers.append(mask)
    return np.dstack(boxed_alteration_layers)

The problem is that this computation takes too long -- I have run the program for three hours for one mask on a large-memory machine and it has still not finished. The most expensive operation is computing overlapping polygons. I think that the code can by looking over a smaller domain of polygons, excluding searching those that will definitely not overlap. Note that the poly_locator variables are psyal.cg.locators.PolygonLocator s. Any advice would be appreciated. I'm not hell-bent on using Python and think that C++ might have the functionality that I need.

Answer 1

I strongly recommend the BOOST.polygon library by Lucanus Simonson. It handles all sorts of polygon interactions, with a surprising reduction in computational complexity. Simonson's innovative calculus to reduce the dimensionality of the 2-D problems is really neat; it left my jaw hanging open for the last 20 minutes or so of his initial proposal.