Consolidate summation in _ravel_shape_indices (#72)

Instead of using the Python `sum` function on Dask Arrays, which will
handle the reduction one pair at a time thus generating a large graph,
use `atop` with a special summation kernel. This handles summation of
all of the Dask Arrays in one function and returns the result. Thus
simplifying the addition into one node. To simplify the Dask graph
further, move the creation of singleton axes into the
`_ravel_shape_indices` kernel function as well. This avoids adding these
steps needlessly to the graph of each `arange`. Plus NumPy should be
able to do these for basically free. As a result graph construction by
`_ravel_shape_indices` should be merely using `arange` to construct
indices for each dimensions and combining these into the resultant
raveled indices with `atop` and the custom kernel function.

dask_image/ndmeasure/_utils.py

@@ -50,21 +50,35 @@ def _get_label_matches(labels, index):
     return lbl_mtch
 
 
+def _ravel_shape_indices_kernel(*args):
+    args2 = tuple(
+        a[i * (None,) + (slice(None),) + (len(args) - i - 1) * (None,)]
+        for i, a in enumerate(args)
+    )
+    return sum(args2)
+
+
 def _ravel_shape_indices(dimensions, dtype=int, chunks=None):
     """
     Gets the raveled indices shaped like input.
     """
 
-    indices = sum([
+    indices = [
         dask.array.arange(
             0,
             numpy.prod(dimensions[i:], dtype=dtype),
             numpy.prod(dimensions[i + 1:], dtype=dtype),
             dtype=dtype,
             chunks=c
-        )[i * (None,) + (slice(None),) + (len(dimensions) - i - 1) * (None,)]
+        )
         for i, c in enumerate(chunks)
-    ])
+    ]
+
+    indices = dask.array.atop(
+        _ravel_shape_indices_kernel, tuple(range(len(indices))),
+        *sum([(a, (i,)) for i, a in enumerate(indices)], tuple()),
+        dtype=dtype
+    )
 
     return indices