From dd34097fe4d65b24a83fafa7c8348672a688f474 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Johannes=20Sch=C3=B6nberger?= Date: Fri, 2 Nov 2012 20:18:28 +0100 Subject: [PATCH] Remove old implementation if TV filter --- skimage/filter/__init__.py | 3 +- skimage/filter/_denoise.pyx | 3 + skimage/filter/denoise.py | 245 ------------------------------------ 3 files changed, 4 insertions(+), 247 deletions(-) delete mode 100644 skimage/filter/denoise.py diff --git a/skimage/filter/__init__.py b/skimage/filter/__init__.py index 8894ff1a..4f8b129a 100644 --- a/skimage/filter/__init__.py +++ b/skimage/filter/__init__.py @@ -3,7 +3,6 @@ from .ctmf import median_filter from ._canny import canny from .edges import (sobel, hsobel, vsobel, scharr, hscharr, vscharr, prewitt, hprewitt, vprewitt) -from .denoise import tv_denoise -from ._denoise import denoise_bilateral, denoise_tv +from ._denoise import denoise_bilateral, denoise_tv, tv_denoise from ._rank_order import rank_order from .thresholding import threshold_otsu, threshold_adaptive diff --git a/skimage/filter/_denoise.pyx b/skimage/filter/_denoise.pyx index ca75ab4f..2e519b8f 100644 --- a/skimage/filter/_denoise.pyx +++ b/skimage/filter/_denoise.pyx @@ -10,6 +10,7 @@ from libc.stdlib cimport malloc, free from libc.float cimport DBL_MAX from skimage._shared.interpolation cimport get_pixel3d from skimage.util import img_as_float +from skimage._shared.utils import deprecated cdef inline double _gaussian_weight(double sigma, double value): @@ -342,3 +343,5 @@ def denoise_tv(image, double weight, int max_iter=100, double eps=1e-3): i += 1 return np.squeeze(u[1:-1, 1:-1]) + +tv_denoise = deprecated('skimage.filter.denoise_tv')(denoise_tv) diff --git a/skimage/filter/denoise.py b/skimage/filter/denoise.py deleted file mode 100644 index 351b2482..00000000 --- a/skimage/filter/denoise.py +++ /dev/null @@ -1,245 +0,0 @@ -import numpy as np -from skimage import img_as_float -from skimage._shared.utils import deprecated - - -def _denoise_tv_3d(im, weight=100, eps=2.e-4, n_iter_max=200): - """Perform total-variation denoising on 3-D arrays. - - Parameters - ---------- - im: ndarray - 3-D input data to be denoised. - weight: float, optional - Denoising weight. The greater ``weight``, the more denoising (at - the expense of fidelity to ``input``). - eps: float, optional - Relative difference of the value of the cost function that determines - the stop criterion. The algorithm stops when: - - (E_(n-1) - E_n) < eps * E_0 - - n_iter_max: int, optional - Maximal number of iterations used for the optimization. - - Returns - ------- - out: ndarray - Denoised array of floats. - - Notes - ----- - Rudin, Osher and Fatemi algorithm. - - Examples - --------- - First build synthetic noisy data - >>> x, y, z = np.ogrid[0:40, 0:40, 0:40] - >>> mask = (x -22)**2 + (y - 20)**2 + (z - 17)**2 < 8**2 - >>> mask = mask.astype(np.float) - >>> mask += 0.2*np.random.randn(*mask.shape) - >>> res = denoise_tv_3d(mask, weight=100) - """ - px = np.zeros_like(im) - py = np.zeros_like(im) - pz = np.zeros_like(im) - gx = np.zeros_like(im) - gy = np.zeros_like(im) - gz = np.zeros_like(im) - d = np.zeros_like(im) - i = 0 - while i < n_iter_max: - d = - px - py - pz - d[1:] += px[:-1] - d[:, 1:] += py[:, :-1] - d[:, :, 1:] += pz[:, :, :-1] - - out = im + d - E = (d**2).sum() - - gx[:-1] = np.diff(out, axis=0) - gy[:, :-1] = np.diff(out, axis=1) - gz[:, :, :-1] = np.diff(out, axis=2) - norm = np.sqrt(gx**2 + gy**2 + gz**2) - E += weight * norm.sum() - norm *= 0.5 / weight - norm += 1. - px -= 1. / 6. * gx - px /= norm - py -= 1. / 6. * gy - py /= norm - pz -= 1 / 6. * gz - pz /= norm - E /= float(im.size) - if i == 0: - E_init = E - E_previous = E - else: - if np.abs(E_previous - E) < eps * E_init: - break - else: - E_previous = E - i += 1 - return out - - -def _denoise_tv_2d(im, weight=50, eps=2.e-4, n_iter_max=200): - """Perform total-variation denoising. - - Parameters - ---------- - im: ndarray - Input data to be denoised. - weight: float, optional - Denoising weight. The greater ``weight``, the more denoising (at - the expense of fidelity to ``input``) - eps: float, optional - Relative difference of the value of the cost function that determines - the stop criterion. The algorithm stops when: - - (E_(n-1) - E_n) < eps * E_0 - - n_iter_max: int, optional - Maximal number of iterations used for the optimization. - - Returns - ------- - out: ndarray - Denoised array of floats. - - Notes - ----- - The principle of total variation denoising is explained in - http://en.wikipedia.org/wiki/Total_variation_denoising. - - This code is an implementation of the algorithm of Rudin, Fatemi and Osher - that was proposed by Chambolle in [1]_. - - References - ---------- - .. [1] A. Chambolle, An algorithm for total variation minimization and - applications, Journal of Mathematical Imaging and Vision, - Springer, 2004, 20, 89-97. - - Examples - --------- - >>> import scipy - >>> lena = scipy.lena() - >>> import scipy - >>> lena = scipy.lena().astype(np.float) - >>> lena += 0.5 * lena.std()*np.random.randn(*lena.shape) - >>> denoised_lena = denoise_tv(lena, weight=60.0) - """ - px = np.zeros_like(im) - py = np.zeros_like(im) - gx = np.zeros_like(im) - gy = np.zeros_like(im) - d = np.zeros_like(im) - i = 0 - while i < n_iter_max: - d = -px - py - d[1:] += px[:-1] - d[:, 1:] += py[:, :-1] - - out = im + d - E = (d**2).sum() - gx[:-1] = np.diff(out, axis=0) - gy[:, :-1] = np.diff(out, axis=1) - norm = np.sqrt(gx**2 + gy**2) - E += weight * norm.sum() - norm *= 0.5 / weight - norm += 1 - px -= 0.25 * gx - px /= norm - py -= 0.25 * gy - py /= norm - E /= float(im.size) - if i == 0: - E_init = E - E_previous = E - else: - if np.abs(E_previous - E) < eps * E_init: - break - else: - E_previous = E - i += 1 - return out - - -def denoise_tv(im, weight=50, eps=2.e-4, n_iter_max=200): - """Perform total-variation denoising on 2-d and 3-d images. - - Parameters - ---------- - im: ndarray (2d or 3d) of ints, uints or floats - Input data to be denoised. `im` can be of any numeric type, - but it is cast into an ndarray of floats for the computation - of the denoised image. - weight: float, optional - Denoising weight. The greater ``weight``, the more denoising (at - the expense of fidelity to ``input``). - eps: float, optional - Relative difference of the value of the cost function that - determines the stop criterion. The algorithm stops when: - - (E_(n-1) - E_n) < eps * E_0 - - n_iter_max: int, optional - Maximal number of iterations used for the optimization. - - Returns - ------- - out: ndarray - Denoised array of floats. - - Notes - ----- - The principle of total variation denoising is explained in - http://en.wikipedia.org/wiki/Total_variation_denoising - - The principle of total variation denoising is to minimize the - total variation of the image, which can be roughly described as - the integral of the norm of the image gradient. Total variation - denoising tends to produce "cartoon-like" images, that is, - piecewise-constant images. - - This code is an implementation of the algorithm of Rudin, Fatemi and Osher - that was proposed by Chambolle in [1]_. - - References - ---------- - .. [1] A. Chambolle, An algorithm for total variation minimization and - applications, Journal of Mathematical Imaging and Vision, - Springer, 2004, 20, 89-97. - - Examples - --------- - >>> import scipy - >>> # 2D example using lena - >>> lena = scipy.lena() - >>> import scipy - >>> lena = scipy.lena().astype(np.float) - >>> lena += 0.5 * lena.std()*np.random.randn(*lena.shape) - >>> denoised_lena = denoise_tv(lena, weight=60) - >>> # 3D example on synthetic data - >>> x, y, z = np.ogrid[0:40, 0:40, 0:40] - >>> mask = (x -22)**2 + (y - 20)**2 + (z - 17)**2 < 8**2 - >>> mask = mask.astype(np.float) - >>> mask += 0.2*np.random.randn(*mask.shape) - >>> res = denoise_tv_3d(mask, weight=100) - """ - im_type = im.dtype - if not im_type.kind == 'f': - im = img_as_float(im) - - if im.ndim == 2: - out = _denoise_tv_2d(im, weight, eps, n_iter_max) - elif im.ndim == 3: - out = _denoise_tv_3d(im, weight, eps, n_iter_max) - else: - raise ValueError('only 2-d and 3-d images may be denoised with this ' - 'function') - return out - - -tv_denoise = deprecated('skimage.filter.denoise_tv')(denoise_tv)