Faster graph structure generation
===

I am starting with an `Nx2` array of unique points, then finding the Delaunay `edges` for those points, an `Mx2` array composed of indices into `points`. There is also an `Mx1` array of weights corresponding to each edge.

I am trying to get the data into the structure described in listing 2.3 of the book "Python Algorithms - Mastering Basic Algorithms in the Python Language" by Hetland. The structure is:

    a, b, c, d, e, f, g, h = range(8)
    G = [
        {b:2, c:1, d:3, e:9, f:4}, # a
        {c:4, e:3}, # b
        {d:8}, # c
        {e:7}, # d
        {f:5}, # e
        {c:2, g:2, h:2}, # f
        {f:1, h:6}, # g
        {f:9, g:8} # h
    ]

where `G[a]` returns edges incident to point `a` and `G[a][b]` returns the weight of the edge between `a` and `b`.

The goal of converting is to be able to use some of the fast traversal, etc. algorightms also described in the book. To convert between my existing data structure and this structure, I do:

    def make_graph(points, edges, weights):
        G = []
        for i in range(len(points)):
    	    w = numpy.where(edges == i)
    	    d = {}
    	    for ind,j in enumerate(edges[w[0],~w[1]]):
                d[j] = weights[w[0][ind]]
            G.append(d)
        return G

which is fairly time-consuming on large sets (i.e. takes about 40 seconds on > 15,000 vertices) and becomes the bottleneck in the code. How can I convert to the data structure `G` faster?