Feature request: Add function to prune skeleton

Skeletonization algorithms often produce small spurious branches. skan should be able to prune those branches and produce a revised skeleton. Additionally, one might want to prune branches based on other criteria, such as curvature. This can be tricky to do correctly, however. I sketched some possible approaches in an email to @jdhenshaw, which I'll reproduce here for reference:

The short answer is that it should be possible to do some naive pruning (1), but to do it right will require some tricky logic (2).

(1) If you look at the documentation for the Skeleton class, (https://jni.github.io/skan/api/skan.csr.html#skan.csr.Skeleton), you can see that there's a method "path_lengths" to get all the path lengths. You can then do:

my_paths = skel.paths[skel.path_lengths() > min_length]

Possibly you can even do skel.paths = my_paths but I have no idea if other things will break then...!

You can then draw these back on the image with the clunkily-named skan.draw.overlay_skeleton_2d_class (https://jni.github.io/skan/api/skan.draw.html#skan.draw.overlay_skeleton_2d_class).

In all these cases you can look at the source code so you can customise to your heart's content.

But,

(2) this won't take into account some nuances like:

if you remove a branch, then, on each end, its two incident branches merge into a longer branch. So there might be some branches removed by the naive threshold above that shouldn't be.
when you remove a branch, the junction resolution method that was used to center the junction pixel is probably no longer valid, and ideally you should recompute the skeleton and start again. For more on what we do with junctions, see the supplementary PDF for the paper: https://dfzljdn9uc3pi.cloudfront.net/2018/4312/1/supplementary-information-python.pdf

So, ideally, but also expensively, what I would consider the "proper" way to proceed is:

find the shortest branch
black out those pixels in the original skeleton image
skeletonize again (to get rid of any little nubs like you might get in that skeleton file
build a new skeleton
repeat until the shortest branch is above your desired threshold

There's probably a way to make this much faster. In broad strokes, you could build the junction-junction graph in networkx from the table returned by summarize (the American spelling function is the preferred one now, see https://github.com/jni/skan/issues/71 for more details). (nx graphs are much more mutable than the more compact and faster csr matrices used in skan.) Once you have the graph, you can do the procedure above on the graph: remove the shortest edge, fuse any nodes that only have two nodes, and repeat, until you have your final graph. Finally, create a csr graph from the networkx graph and the original skeleton csr graph (which contains the pixel positions). Once you have that, it should be feasible to draw back onto an image.

jni / skan

Feature request: Add function to prune skeleton #97