Also, the default weight of 50 in the denoise_TV_chambolle function is huge. It seemed that a weight < 1 was needed to get reasonable results, but I didn't change the default here.

Regarding the default value of weight, I think this default value was set before img_as_float was used, i.e. it's a reasonable value for images in the range [0, 255]. Changing the default to 1 or 0.5 might be better.

I will take a look at the performance.

Regarding the weight, I am in favor of changing the default. I think we should certainly at least adjust it in the tests. It is still set to very large values there (aside from the couple of tests I just added).

Go for it for weight, better now than later. Or you could also file a separate PR for the weight to be sure that we merge it for 0.12.

@emmanuelle
Good catch on the C vs. Fortran order. The implementation here was about 2 times slower!

Just using order='F' for g and p restored performance (I measured 2-3% slower than the previous 2D only implementation, which seems more acceptable).

I also verified that resulting denoised image is indeed identical to the existing implementation.

I will make a small separate PR for the weight issue.

@grlee77 thanks for checking the performance issue. Creating F-order instead of C-order arrays was a quick and dirty trick that worked, but in fact it would be better if you could have the first dimension corresponding to the dimension of length ndim, and keep C-order arrays. Do you think it would be possible? Then you would also recover the 2-3% that correspond I think to the moment where you add im + d (adding a C-order to a F-order to output an F-order array).

Also, you'll need to rebase on master since your PR on weight has been merged.

okay sure. I will take a look in a few days

Agreed with @emmanuelle about weight - if the default is way off, it should be fixed.

@grlee77 any update on your PR? We shouldn't let this momentum fizzle out :-) !

Yes, I did make some additional commits, but I think they are still on my laptop. I may be able to push them later today.

@grlee77 I'm late to this party but thank you for an awesome contribution! The code looks cleaner in nd than specialised for 2D, as is often the case, and we get the added benefit of nd compatibility!

@emmanuelle
I have switched back to C-ordering as requested. I believe it was a tiny bit faster back when I tested it, but don't have exact benchmark numbers on hand.

Sorry to fiddle with the weights again, but the changes in #dd5a708 are necessary to give a consistent level of denoising regardless of the number of image dimensions.

To demonstrate that the present implementation is correct, see the following example, which I repeated for the _denoise_tv_chambolle_nd code prior to and after #dd5a708

import numpy as np
from skimage import restoration, data, color, img_as_float
from matplotlib import pyplot as plt

np.random.seed(1234)
astro = img_as_float(data.astronaut())  # [:128, :128])
astro_gray = color.rgb2gray(astro)
img = astro_gray.copy()
# add noise to astronaut
sigma = 0.15
img += sigma * np.random.standard_normal(img.shape)
# clip noise so that it does not exceed allowed range for float images.
img = np.clip(img, 0, 1)


# generate 3D, 4D and 8D images by tiling
img3 = np.tile(img[..., None], (1, 1, 16));
img4 = np.tile(img[..., None, None], (1, 1, 4, 4));
img8 = np.tile(img[..., None, None, None, None, None, None], (1, 1, 2, 2, 2, 2));

# denoise all nD images and view a single 2D slice
w = 0.2
denoised_astro2 = _denoise_tv_chambolle_nd(img, weight=w, multichannel=False)
denoised_astro3 = _denoise_tv_chambolle_nd(img3, weight=w, multichannel=False)
denoised_astro4 = _denoise_tv_chambolle_nd(img4, weight=w, multichannel=False)
denoised_astro8 = _denoise_tv_chambolle_nd(img8, weight=w, multichannel=False)


fig, axes = plt.subplots(2, 2)
axes[0, 0].imshow(denoised_astro2, cmap=plt.cm.gray, interpolation='nearest')
axes[0, 0].set_axis_off()
axes[0, 0].set_title('2D')
axes[0, 1].imshow(denoised_astro3[..., 0], cmap=plt.cm.gray, interpolation='nearest')
axes[0, 1].set_axis_off()
axes[0, 1].set_title('3D')
axes[1, 0].imshow(denoised_astro4[..., 0, 0], cmap=plt.cm.gray, interpolation='nearest')
axes[1, 0].set_axis_off()
axes[1, 0].set_title('4D')
axes[1, 1].imshow(denoised_astro8[..., 0, 0, 0, 0, 0, 0], cmap=plt.cm.gray, interpolation='nearest')
axes[1, 1].set_axis_off()
axes[1, 1].set_title('8D')
volshow([denoised_astro2, denoised_astro3[..., 0],  denoised_astro4[..., 0, 0],
         denoised_astro8[..., 0, 0, 0, 0, 0, 0]])

With the old code, the level of denoising decreases as the number of images increases:

The new code, gives much more consistent results:

Is there not a way to set a slightly less strict criterion for Coveralls? -0.007%

I opened an issue about that on Coveralls several months ago, but no response...

@grlee77 Sweet, thank you! =D

Good work!

@stefanv the Guardian of the Dimensions is happy. =P