From 3ed648ea0824ba8eb05a61db7bd12b9c44a17792 Mon Sep 17 00:00:00 2001 From: Stefan van der Walt Date: Tue, 7 Oct 2014 15:16:43 +0200 Subject: [PATCH] Fixes according to PR feedback --- doc/source/api_changes.txt | 2 +- skimage/filter/tests/test_filter_import.py | 1 - skimage/filters/lpi_filter.py | 2 +- skimage/filters/rank/generic.py | 4 +- skimage/filters/tests/test_edges.py | 101 +++++++++++---------- skimage/filters/tests/test_lpi_filter.py | 24 ++--- 6 files changed, 65 insertions(+), 69 deletions(-) diff --git a/doc/source/api_changes.txt b/doc/source/api_changes.txt index 89763732..84625732 100644 --- a/doc/source/api_changes.txt +++ b/doc/source/api_changes.txt @@ -1,6 +1,6 @@ Version 0.11 ------------ -- The ``skimage.filter`` has been renamed to ``skimage.filters``. +- The ``skimage.filter`` subpackage has been renamed to ``skimage.filters``. - Some edge detectors returned values greater than 1--their results are now appropriately scaled with a factor of ``sqrt(2)``. diff --git a/skimage/filter/tests/test_filter_import.py b/skimage/filter/tests/test_filter_import.py index a4ccc240..70841df5 100644 --- a/skimage/filter/tests/test_filter_import.py +++ b/skimage/filter/tests/test_filter_import.py @@ -1,4 +1,3 @@ -from numpy.testing import assert_warns from warnings import catch_warnings, simplefilter def test_import_filter(): diff --git a/skimage/filters/lpi_filter.py b/skimage/filters/lpi_filter.py index b02d4eb1..afc1f003 100644 --- a/skimage/filters/lpi_filter.py +++ b/skimage/filters/lpi_filter.py @@ -66,9 +66,9 @@ class LPIFilter2D(object): Examples -------- - Gaussian filter: Use a 1-D gaussian in each direction without normalization coefficients. + >>> def filt_func(r, c, sigma = 1): ... return np.exp(-np.hypot(r, c)/sigma) >>> filter = LPIFilter2D(filt_func) diff --git a/skimage/filters/rank/generic.py b/skimage/filters/rank/generic.py index e1f6e8e5..7a3be5d7 100644 --- a/skimage/filters/rank/generic.py +++ b/skimage/filters/rank/generic.py @@ -287,7 +287,7 @@ def maximum(image, selem, out=None, mask=None, shift_x=False, shift_y=False): Notes ----- - The lower algorithm complexity makes the `skimage.filters.rank.maximum` + The lower algorithm complexity makes `skimage.filters.rank.maximum` more efficient for larger images and structuring elements. Examples @@ -452,7 +452,7 @@ def minimum(image, selem, out=None, mask=None, shift_x=False, shift_y=False): Notes ----- - The lower algorithm complexity makes the `skimage.filters.rank.minimum` more + The lower algorithm complexity makes `skimage.filters.rank.minimum` more efficient for larger images and structuring elements. Examples diff --git a/skimage/filters/tests/test_edges.py b/skimage/filters/tests/test_edges.py index 9e7a714e..2f8900df 100644 --- a/skimage/filters/tests/test_edges.py +++ b/skimage/filters/tests/test_edges.py @@ -2,13 +2,13 @@ import numpy as np from numpy.testing import (assert_array_almost_equal as assert_close, assert_, assert_allclose) -import skimage.filters as F +from skimage import filters from skimage.filters.edges import _mask_filter_result def test_roberts_zeros(): """Roberts' filter on an array of all zeros.""" - result = F.roberts(np.zeros((10, 10)), np.ones((10, 10), bool)) + result = filters.roberts(np.zeros((10, 10)), np.ones((10, 10), bool)) assert (np.all(result == 0)) @@ -18,7 +18,7 @@ def test_roberts_diagonal1(): expected = ~(np.tri(10, 10, -1).astype(bool) | np.tri(10, 10, -2).astype(bool).transpose()) expected = _mask_filter_result(expected, None) - result = F.roberts(image).astype(bool) + result = filters.roberts(image).astype(bool) assert_close(result, expected) @@ -28,21 +28,21 @@ def test_roberts_diagonal2(): expected = ~np.rot90(np.tri(10, 10, -1).astype(bool) | np.tri(10, 10, -2).astype(bool).transpose()) expected = _mask_filter_result(expected, None) - result = F.roberts(image).astype(bool) + result = filters.roberts(image).astype(bool) assert_close(result, expected) def test_sobel_zeros(): """Sobel on an array of all zeros.""" - result = F.sobel(np.zeros((10, 10)), np.ones((10, 10), bool)) + result = filters.sobel(np.zeros((10, 10)), np.ones((10, 10), bool)) assert (np.all(result == 0)) def test_sobel_mask(): """Sobel on a masked array should be zero.""" np.random.seed(0) - result = F.sobel(np.random.uniform(size=(10, 10)), - np.zeros((10, 10), bool)) + result = filters.sobel(np.random.uniform(size=(10, 10)), + np.zeros((10, 10), bool)) assert (np.all(result == 0)) @@ -50,7 +50,7 @@ def test_sobel_horizontal(): """Sobel on a horizontal edge should be a horizontal line.""" i, j = np.mgrid[-5:6, -5:6] image = (i >= 0).astype(float) - result = F.sobel(image) * np.sqrt(2) + result = filters.sobel(image) * np.sqrt(2) # Fudge the eroded points i[np.abs(j) == 5] = 10000 assert_allclose(result[i == 0], 1) @@ -61,7 +61,7 @@ def test_sobel_vertical(): """Sobel on a vertical edge should be a vertical line.""" i, j = np.mgrid[-5:6, -5:6] image = (j >= 0).astype(float) - result = F.sobel(image) * np.sqrt(2) + result = filters.sobel(image) * np.sqrt(2) j[np.abs(i) == 5] = 10000 assert (np.all(result[j == 0] == 1)) assert (np.all(result[np.abs(j) > 1] == 0)) @@ -69,15 +69,15 @@ def test_sobel_vertical(): def test_hsobel_zeros(): """Horizontal sobel on an array of all zeros.""" - result = F.hsobel(np.zeros((10, 10)), np.ones((10, 10), bool)) + result = filters.hsobel(np.zeros((10, 10)), np.ones((10, 10), bool)) assert (np.all(result == 0)) def test_hsobel_mask(): """Horizontal Sobel on a masked array should be zero.""" np.random.seed(0) - result = F.hsobel(np.random.uniform(size=(10, 10)), - np.zeros((10, 10), bool)) + result = filters.hsobel(np.random.uniform(size=(10, 10)), + np.zeros((10, 10), bool)) assert (np.all(result == 0)) @@ -85,7 +85,7 @@ def test_hsobel_horizontal(): """Horizontal Sobel on an edge should be a horizontal line.""" i, j = np.mgrid[-5:6, -5:6] image = (i >= 0).astype(float) - result = F.hsobel(image) + result = filters.hsobel(image) # Fudge the eroded points i[np.abs(j) == 5] = 10000 assert (np.all(result[i == 0] == 1)) @@ -96,20 +96,20 @@ def test_hsobel_vertical(): """Horizontal Sobel on a vertical edge should be zero.""" i, j = np.mgrid[-5:6, -5:6] image = (j >= 0).astype(float) * np.sqrt(2) - result = F.hsobel(image) + result = filters.hsobel(image) assert_allclose(result, 0, atol=1e-10) def test_vsobel_zeros(): """Vertical sobel on an array of all zeros.""" - result = F.vsobel(np.zeros((10, 10)), np.ones((10, 10), bool)) + result = filters.vsobel(np.zeros((10, 10)), np.ones((10, 10), bool)) assert_allclose(result, 0) def test_vsobel_mask(): """Vertical Sobel on a masked array should be zero.""" np.random.seed(0) - result = F.vsobel(np.random.uniform(size=(10, 10)), + result = filters.vsobel(np.random.uniform(size=(10, 10)), np.zeros((10, 10), bool)) assert_allclose(result, 0) @@ -118,7 +118,7 @@ def test_vsobel_vertical(): """Vertical Sobel on an edge should be a vertical line.""" i, j = np.mgrid[-5:6, -5:6] image = (j >= 0).astype(float) - result = F.vsobel(image) + result = filters.vsobel(image) # Fudge the eroded points j[np.abs(i) == 5] = 10000 assert (np.all(result[j == 0] == 1)) @@ -129,21 +129,21 @@ def test_vsobel_horizontal(): """vertical Sobel on a horizontal edge should be zero.""" i, j = np.mgrid[-5:6, -5:6] image = (i >= 0).astype(float) - result = F.vsobel(image) + result = filters.vsobel(image) assert_allclose(result, 0) def test_scharr_zeros(): """Scharr on an array of all zeros.""" - result = F.scharr(np.zeros((10, 10)), np.ones((10, 10), bool)) + result = filters.scharr(np.zeros((10, 10)), np.ones((10, 10), bool)) assert (np.all(result < 1e-16)) def test_scharr_mask(): """Scharr on a masked array should be zero.""" np.random.seed(0) - result = F.scharr(np.random.uniform(size=(10, 10)), - np.zeros((10, 10), bool)) + result = filters.scharr(np.random.uniform(size=(10, 10)), + np.zeros((10, 10), bool)) assert_allclose(result, 0) @@ -151,7 +151,7 @@ def test_scharr_horizontal(): """Scharr on an edge should be a horizontal line.""" i, j = np.mgrid[-5:6, -5:6] image = (i >= 0).astype(float) - result = F.scharr(image) * np.sqrt(2) + result = filters.scharr(image) * np.sqrt(2) # Fudge the eroded points i[np.abs(j) == 5] = 10000 assert_allclose(result[i == 0], 1) @@ -162,7 +162,7 @@ def test_scharr_vertical(): """Scharr on a vertical edge should be a vertical line.""" i, j = np.mgrid[-5:6, -5:6] image = (j >= 0).astype(float) - result = F.scharr(image) * np.sqrt(2) + result = filters.scharr(image) * np.sqrt(2) j[np.abs(i) == 5] = 10000 assert_allclose(result[j == 0], 1) assert (np.all(result[np.abs(j) > 1] == 0)) @@ -170,15 +170,15 @@ def test_scharr_vertical(): def test_hscharr_zeros(): """Horizontal Scharr on an array of all zeros.""" - result = F.hscharr(np.zeros((10, 10)), np.ones((10, 10), bool)) + result = filters.hscharr(np.zeros((10, 10)), np.ones((10, 10), bool)) assert_allclose(result, 0) def test_hscharr_mask(): """Horizontal Scharr on a masked array should be zero.""" np.random.seed(0) - result = F.hscharr(np.random.uniform(size=(10, 10)), - np.zeros((10, 10), bool)) + result = filters.hscharr(np.random.uniform(size=(10, 10)), + np.zeros((10, 10), bool)) assert_allclose(result, 0) @@ -186,7 +186,7 @@ def test_hscharr_horizontal(): """Horizontal Scharr on an edge should be a horizontal line.""" i, j = np.mgrid[-5:6, -5:6] image = (i >= 0).astype(float) - result = F.hscharr(image) + result = filters.hscharr(image) # Fudge the eroded points i[np.abs(j) == 5] = 10000 assert (np.all(result[i == 0] == 1)) @@ -197,21 +197,21 @@ def test_hscharr_vertical(): """Horizontal Scharr on a vertical edge should be zero.""" i, j = np.mgrid[-5:6, -5:6] image = (j >= 0).astype(float) - result = F.hscharr(image) + result = filters.hscharr(image) assert_allclose(result, 0) def test_vscharr_zeros(): """Vertical Scharr on an array of all zeros.""" - result = F.vscharr(np.zeros((10, 10)), np.ones((10, 10), bool)) + result = filters.vscharr(np.zeros((10, 10)), np.ones((10, 10), bool)) assert_allclose(result, 0) def test_vscharr_mask(): """Vertical Scharr on a masked array should be zero.""" np.random.seed(0) - result = F.vscharr(np.random.uniform(size=(10, 10)), - np.zeros((10, 10), bool)) + result = filters.vscharr(np.random.uniform(size=(10, 10)), + np.zeros((10, 10), bool)) assert_allclose(result, 0) @@ -219,7 +219,7 @@ def test_vscharr_vertical(): """Vertical Scharr on an edge should be a vertical line.""" i, j = np.mgrid[-5:6, -5:6] image = (j >= 0).astype(float) - result = F.vscharr(image) + result = filters.vscharr(image) # Fudge the eroded points j[np.abs(i) == 5] = 10000 assert (np.all(result[j == 0] == 1)) @@ -230,21 +230,21 @@ def test_vscharr_horizontal(): """vertical Scharr on a horizontal edge should be zero.""" i, j = np.mgrid[-5:6, -5:6] image = (i >= 0).astype(float) - result = F.vscharr(image) + result = filters.vscharr(image) assert_allclose(result, 0) def test_prewitt_zeros(): """Prewitt on an array of all zeros.""" - result = F.prewitt(np.zeros((10, 10)), np.ones((10, 10), bool)) + result = filters.prewitt(np.zeros((10, 10)), np.ones((10, 10), bool)) assert_allclose(result, 0) def test_prewitt_mask(): """Prewitt on a masked array should be zero.""" np.random.seed(0) - result = F.prewitt(np.random.uniform(size=(10, 10)), - np.zeros((10, 10), bool)) + result = filters.prewitt(np.random.uniform(size=(10, 10)), + np.zeros((10, 10), bool)) assert_allclose(np.abs(result), 0) @@ -252,7 +252,7 @@ def test_prewitt_horizontal(): """Prewitt on an edge should be a horizontal line.""" i, j = np.mgrid[-5:6, -5:6] image = (i >= 0).astype(float) - result = F.prewitt(image) * np.sqrt(2) + result = filters.prewitt(image) * np.sqrt(2) # Fudge the eroded points i[np.abs(j) == 5] = 10000 assert (np.all(result[i == 0] == 1)) @@ -263,7 +263,7 @@ def test_prewitt_vertical(): """Prewitt on a vertical edge should be a vertical line.""" i, j = np.mgrid[-5:6, -5:6] image = (j >= 0).astype(float) - result = F.prewitt(image) * np.sqrt(2) + result = filters.prewitt(image) * np.sqrt(2) j[np.abs(i) == 5] = 10000 assert_allclose(result[j == 0], 1) assert_allclose(result[np.abs(j) > 1], 0, atol=1e-10) @@ -271,14 +271,14 @@ def test_prewitt_vertical(): def test_hprewitt_zeros(): """Horizontal prewitt on an array of all zeros.""" - result = F.hprewitt(np.zeros((10, 10)), np.ones((10, 10), bool)) + result = filters.hprewitt(np.zeros((10, 10)), np.ones((10, 10), bool)) assert_allclose(result, 0) def test_hprewitt_mask(): """Horizontal prewitt on a masked array should be zero.""" np.random.seed(0) - result = F.hprewitt(np.random.uniform(size=(10, 10)), + result = filters.hprewitt(np.random.uniform(size=(10, 10)), np.zeros((10, 10), bool)) assert_allclose(result, 0) @@ -287,7 +287,7 @@ def test_hprewitt_horizontal(): """Horizontal prewitt on an edge should be a horizontal line.""" i, j = np.mgrid[-5:6, -5:6] image = (i >= 0).astype(float) - result = F.hprewitt(image) + result = filters.hprewitt(image) # Fudge the eroded points i[np.abs(j) == 5] = 10000 assert (np.all(result[i == 0] == 1)) @@ -298,21 +298,21 @@ def test_hprewitt_vertical(): """Horizontal prewitt on a vertical edge should be zero.""" i, j = np.mgrid[-5:6, -5:6] image = (j >= 0).astype(float) - result = F.hprewitt(image) + result = filters.hprewitt(image) assert_allclose(result, 0, atol=1e-10) def test_vprewitt_zeros(): """Vertical prewitt on an array of all zeros.""" - result = F.vprewitt(np.zeros((10, 10)), np.ones((10, 10), bool)) + result = filters.vprewitt(np.zeros((10, 10)), np.ones((10, 10), bool)) assert_allclose(result, 0) def test_vprewitt_mask(): """Vertical prewitt on a masked array should be zero.""" np.random.seed(0) - result = F.vprewitt(np.random.uniform(size=(10, 10)), - np.zeros((10, 10), bool)) + result = filters.vprewitt(np.random.uniform(size=(10, 10)), + np.zeros((10, 10), bool)) assert_allclose(result, 0) @@ -320,7 +320,7 @@ def test_vprewitt_vertical(): """Vertical prewitt on an edge should be a vertical line.""" i, j = np.mgrid[-5:6, -5:6] image = (j >= 0).astype(float) - result = F.vprewitt(image) + result = filters.vprewitt(image) # Fudge the eroded points j[np.abs(i) == 5] = 10000 assert (np.all(result[j == 0] == 1)) @@ -331,7 +331,7 @@ def test_vprewitt_horizontal(): """Vertical prewitt on a horizontal edge should be zero.""" i, j = np.mgrid[-5:6, -5:6] image = (i >= 0).astype(float) - result = F.vprewitt(image) + result = filters.vprewitt(image) assert_allclose(result, 0) @@ -347,7 +347,7 @@ def test_horizontal_mask_line(): expected[1:-1, 1:-1] = 0.2 # constant gradient for most of image, expected[4:7, 1:-1] = 0 # but line and neighbors masked - for grad_func in (F.hprewitt, F.hsobel, F.hscharr): + for grad_func in (filters.hprewitt, filters.hsobel, filters.hscharr): result = grad_func(vgrad, mask) yield assert_close, result, expected @@ -364,7 +364,7 @@ def test_vertical_mask_line(): expected[1:-1, 1:-1] = 0.2 # constant gradient for most of image, expected[1:-1, 4:7] = 0 # but line and neighbors masked - for grad_func in (F.vprewitt, F.vsobel, F.vscharr): + for grad_func in (filters.vprewitt, filters.vsobel, filters.vscharr): result = grad_func(hgrad, mask) yield assert_close, result, expected @@ -372,7 +372,8 @@ def test_vertical_mask_line(): def test_range(): """Output of edge detection should be in [0, 1]""" image = np.random.random((100, 100)) - for detector in (F.sobel, F.scharr, F.prewitt, F.roberts): + for detector in (filters.sobel, filters.scharr, + filters.prewitt, filters.roberts): out = detector(image) assert_(out.min() >= 0, "Minimum of `{0}` is smaller than zero".format( diff --git a/skimage/filters/tests/test_lpi_filter.py b/skimage/filters/tests/test_lpi_filter.py index 12b3ab00..ce952304 100644 --- a/skimage/filters/tests/test_lpi_filter.py +++ b/skimage/filters/tests/test_lpi_filter.py @@ -1,17 +1,13 @@ -import os.path - import numpy as np -from numpy.testing import * +from numpy.testing import (assert_raises, assert_, assert_equal, + run_module_suite) -from skimage import data_dir -from skimage.io import * -from skimage.filters import * +from skimage import data +from skimage.filters import LPIFilter2D, inverse, wiener class TestLPIFilter2D(object): - - img = imread(os.path.join(data_dir, 'camera.png'), - flatten=True)[:50, :50] + img = data.camera()[:50, :50] def filt_func(self, r, c): return np.exp(-np.hypot(r, c) / 1) @@ -36,14 +32,14 @@ class TestLPIFilter2D(object): assert_equal(g.shape, self.img.shape) g1 = inverse(F[::-1, ::-1], predefined_filter=self.f) - assert ((g - g1[::-1, ::-1]).sum() < 55) + assert_((g - g1[::-1, ::-1]).sum() < 55) # test cache g1 = inverse(F[::-1, ::-1], predefined_filter=self.f) - assert ((g - g1[::-1, ::-1]).sum() < 55) + assert_((g - g1[::-1, ::-1]).sum() < 55) g1 = inverse(F[::-1, ::-1], self.filt_func) - assert ((g - g1[::-1, ::-1]).sum() < 55) + assert_((g - g1[::-1, ::-1]).sum() < 55) def test_wiener(self): F = self.f(self.img) @@ -51,10 +47,10 @@ class TestLPIFilter2D(object): assert_equal(g.shape, self.img.shape) g1 = wiener(F[::-1, ::-1], predefined_filter=self.f) - assert ((g - g1[::-1, ::-1]).sum() < 1) + assert_((g - g1[::-1, ::-1]).sum() < 1) g1 = wiener(F[::-1, ::-1], self.filt_func) - assert ((g - g1[::-1, ::-1]).sum() < 1) + assert_((g - g1[::-1, ::-1]).sum() < 1) def test_non_callable(self): assert_raises(ValueError, LPIFilter2D, None)