From 9e8f91930e9b257f0d538e5543c1c5d9e462b5d3 Mon Sep 17 00:00:00 2001
From: Steven Silvester <steven.silvester@ieee.org>
Date: Tue, 23 Dec 2014 16:46:44 -0600
Subject: [PATCH] Handle warnings in several packages

Start handling warnings in data, exposure, and draw

Add a known_warning decorator and suppress warnings in color pkg

Use the existing all_warnings context manager

Raise warnings in data

Raise warnings in draw

Raise warnings in exposure

Suppress warnings in exposure tests

Add comments about warning suppressions

Raise warnings in feature

Fix warnings in filter package

Add warning handling to graph

Handle warnings in io package
---
 skimage/_shared/testing.py              | 32 ++++++++++++-------
 skimage/feature/tests/__init__.py       |  2 ++
 skimage/filters/rank/tests/__init__.py  |  2 ++
 skimage/filters/rank/tests/test_rank.py | 41 +++++++++++++++++--------
 skimage/filters/tests/__init__.py       |  2 ++
 skimage/filters/tests/test_gaussian.py  |  4 ++-
 skimage/filters/thresholding.py         |  6 ++--
 skimage/graph/tests/__init__.py         |  2 ++
 skimage/io/_plugins/pil_plugin.py       | 10 +++---
 skimage/io/tests/__init__.py            |  2 ++
 skimage/io/tests/test_pil.py            |  7 +++--
 skimage/io/tests/test_plugin_util.py    | 23 +++++++++-----
 12 files changed, 91 insertions(+), 42 deletions(-)
 create mode 100644 skimage/feature/tests/__init__.py
 create mode 100644 skimage/filters/rank/tests/__init__.py
 create mode 100644 skimage/filters/tests/__init__.py
 create mode 100644 skimage/graph/tests/__init__.py
 create mode 100644 skimage/io/tests/__init__.py

diff --git a/skimage/_shared/testing.py b/skimage/_shared/testing.py
index 0cf65cb4..1dae36c3 100644
--- a/skimage/_shared/testing.py
+++ b/skimage/_shared/testing.py
@@ -9,6 +9,7 @@ from skimage import (
     data, io, img_as_uint, img_as_float, img_as_int, img_as_ubyte)
 from numpy import testing
 import numpy as np
+from skimage._shared.utils import all_warnings
 
 
 SKIP_RE = re.compile("(\s*>>>.*?)(\s*)#\s*skip\s+if\s+(.*)$")
@@ -115,20 +116,25 @@ def color_check(plugin, fmt='png'):
     testing.assert_allclose(img2.astype(np.uint8), r2)
 
     img3 = img_as_float(img)
-    r3 = roundtrip(img3, plugin, fmt)
+    with all_warnings():  # precision loss
+        r3 = roundtrip(img3, plugin, fmt)
     testing.assert_allclose(r3, img)
 
-    img4 = img_as_int(img)
+    with all_warnings():  # precision loss
+        img4 = img_as_int(img)
     if fmt.lower() in (('tif', 'tiff')):
         img4 -= 100
-        r4 = roundtrip(img4, plugin, fmt)
+        with all_warnings():  # sign loss
+            r4 = roundtrip(img4, plugin, fmt)
         testing.assert_allclose(r4, img4)
     else:
-        r4 = roundtrip(img4, plugin, fmt)
-        testing.assert_allclose(r4, img_as_ubyte(img4))
+        with all_warnings():  # sign loss
+            r4 = roundtrip(img4, plugin, fmt)
+            testing.assert_allclose(r4, img_as_ubyte(img4))
 
     img5 = img_as_uint(img)
-    r5 = roundtrip(img5, plugin, fmt)
+    with all_warnings():  # precision loss
+        r5 = roundtrip(img5, plugin, fmt)
     testing.assert_allclose(r5, img)
 
 
@@ -147,20 +153,24 @@ def mono_check(plugin, fmt='png'):
     testing.assert_allclose(img2.astype(np.uint8), r2)
 
     img3 = img_as_float(img)
-    r3 = roundtrip(img3, plugin, fmt)
+    with all_warnings():  # precision loss
+        r3 = roundtrip(img3, plugin, fmt)
     if r3.dtype.kind == 'f':
         testing.assert_allclose(img3, r3)
     else:
         testing.assert_allclose(r3, img_as_uint(img))
 
-    img4 = img_as_int(img)
+    with all_warnings():  # precision loss
+        img4 = img_as_int(img)
     if fmt.lower() in (('tif', 'tiff')):
         img4 -= 100
-        r4 = roundtrip(img4, plugin, fmt)
+        with all_warnings():  # sign loss
+            r4 = roundtrip(img4, plugin, fmt)
         testing.assert_allclose(r4, img4)
     else:
-        r4 = roundtrip(img4, plugin, fmt)
-        testing.assert_allclose(r4, img_as_uint(img4))
+        with all_warnings():  # sign loss
+            r4 = roundtrip(img4, plugin, fmt)
+            testing.assert_allclose(r4, img_as_uint(img4))
 
     img5 = img_as_uint(img)
     r5 = roundtrip(img5, plugin, fmt)
diff --git a/skimage/feature/tests/__init__.py b/skimage/feature/tests/__init__.py
new file mode 100644
index 00000000..0922ce59
--- /dev/null
+++ b/skimage/feature/tests/__init__.py
@@ -0,0 +1,2 @@
+import warnings
+warnings.simplefilter('error')
diff --git a/skimage/filters/rank/tests/__init__.py b/skimage/filters/rank/tests/__init__.py
new file mode 100644
index 00000000..0922ce59
--- /dev/null
+++ b/skimage/filters/rank/tests/__init__.py
@@ -0,0 +1,2 @@
+import warnings
+warnings.simplefilter('error')
diff --git a/skimage/filters/rank/tests/test_rank.py b/skimage/filters/rank/tests/test_rank.py
index 23745ebf..f2d91ff0 100644
--- a/skimage/filters/rank/tests/test_rank.py
+++ b/skimage/filters/rank/tests/test_rank.py
@@ -3,15 +3,22 @@ import numpy as np
 from numpy.testing import run_module_suite, assert_equal, assert_raises
 
 import skimage
-from skimage import img_as_ubyte, img_as_uint, img_as_float
+from skimage import img_as_ubyte, img_as_float
 from skimage import data, util, morphology
 from skimage.morphology import cmorph, disk
 from skimage.filters import rank
+from skimage._shared.utils import all_warnings
 
 np.random.seed(0)
 
 
 def test_all():
+
+  with all_warnings():  # precision loss
+    check_all()
+
+
+def check_all():
     image = np.random.rand(25, 25)
     selem = morphology.disk(1)
     refs = np.load(os.path.join(skimage.data_dir, "rank_filter_tests.npz"))
@@ -151,8 +158,9 @@ def test_bitdepth():
 
     for i in range(5):
         image = np.ones((100, 100), dtype=np.uint16) * 255 * 2 ** i
-        r = rank.mean_percentile(image=image, selem=elem, mask=mask,
-                                 out=out, shift_x=0, shift_y=0, p0=.1, p1=.9)
+        with all_warnings():  # bit depth
+          rank.mean_percentile(image=image, selem=elem, mask=mask,
+                               out=out, shift_x=0, shift_y=0, p0=.1, p1=.9)
 
 
 def test_population():
@@ -261,7 +269,8 @@ def test_compare_ubyte_vs_float():
     for method in methods:
         func = getattr(rank, method)
         out_u = func(image_uint, disk(3))
-        out_f = func(image_float, disk(3))
+        with all_warnings():  # precision loss
+          out_f = func(image_float, disk(3))
         assert_equal(out_u, out_f)
 
 
@@ -273,9 +282,10 @@ def test_compare_8bit_unsigned_vs_signed():
     image = img_as_ubyte(data.camera())
     image[image > 127] = 0
     image_s = image.astype(np.int8)
-    image_u = img_as_ubyte(image_s)
+    with all_warnings():  # precision loss
+      image_u = img_as_ubyte(image_s)
 
-    assert_equal(image_u, img_as_ubyte(image_s))
+      assert_equal(image_u, img_as_ubyte(image_s))
 
     methods = ['autolevel', 'bottomhat', 'equalize', 'gradient', 'maximum',
                'mean', 'subtract_mean', 'median', 'minimum', 'modal',
@@ -283,8 +293,10 @@ def test_compare_8bit_unsigned_vs_signed():
 
     for method in methods:
         func = getattr(rank, method)
-        out_u = func(image_u, disk(3))
-        out_s = func(image_s, disk(3))
+
+        with all_warnings():  # sign loss
+          out_u = func(image_u, disk(3))
+          out_s = func(image_s, disk(3))
         assert_equal(out_u, out_s)
 
 
@@ -474,10 +486,12 @@ def test_entropy():
     selem = np.ones((64, 64), dtype=np.uint8)
     data = np.tile(
         np.reshape(np.arange(4096), (64, 64)), (2, 2)).astype(np.uint16)
-    assert(np.max(rank.entropy(data, selem)) == 12)
+    with all_warnings():  # bitdepth
+      assert(np.max(rank.entropy(data, selem)) == 12)
 
     # make sure output is of dtype double
-    out = rank.entropy(data, np.ones((16, 16), dtype=np.uint8))
+    with all_warnings():  # bitdepth
+      out = rank.entropy(data, np.ones((16, 16), dtype=np.uint8))
     assert out.dtype == np.double
 
 
@@ -508,9 +522,10 @@ def test_16bit():
     for bitdepth in range(17):
         value = 2 ** bitdepth - 1
         image[10, 10] = value
-        assert rank.minimum(image, selem)[10, 10] == 0
-        assert rank.maximum(image, selem)[10, 10] == value
-        assert rank.mean(image, selem)[10, 10] == int(value / selem.size)
+        with all_warnings():  # bitdepth
+          assert rank.minimum(image, selem)[10, 10] == 0
+          assert rank.maximum(image, selem)[10, 10] == value
+          assert rank.mean(image, selem)[10, 10] == int(value / selem.size)
 
 
 def test_bilateral():
diff --git a/skimage/filters/tests/__init__.py b/skimage/filters/tests/__init__.py
new file mode 100644
index 00000000..0922ce59
--- /dev/null
+++ b/skimage/filters/tests/__init__.py
@@ -0,0 +1,2 @@
+import warnings
+warnings.simplefilter('error')
diff --git a/skimage/filters/tests/test_gaussian.py b/skimage/filters/tests/test_gaussian.py
index 612dd9e4..01e1c12e 100644
--- a/skimage/filters/tests/test_gaussian.py
+++ b/skimage/filters/tests/test_gaussian.py
@@ -1,5 +1,6 @@
 import numpy as np
 from skimage.filters._gaussian import gaussian_filter
+from skimage._shared.utils import all_warnings
 
 
 def test_null_sigma():
@@ -25,7 +26,8 @@ def test_multichannel():
     assert np.allclose([a[..., i].mean() for i in range(3)],
                         [gaussian_rgb_a[..., i].mean() for i in range(3)])
     # Test multichannel = None
-    gaussian_rgb_a = gaussian_filter(a, sigma=1, mode='reflect')
+    with all_warnings():  # multichannel
+        gaussian_rgb_a = gaussian_filter(a, sigma=1, mode='reflect')
     # Check that the mean value is conserved in each channel
     # (color channels are not mixed together)
     assert np.allclose([a[..., i].mean() for i in range(3)],
diff --git a/skimage/filters/thresholding.py b/skimage/filters/thresholding.py
index 5a737293..76a725a7 100644
--- a/skimage/filters/thresholding.py
+++ b/skimage/filters/thresholding.py
@@ -121,7 +121,7 @@ def threshold_otsu(image, nbins=256):
     >>> thresh = threshold_otsu(image)
     >>> binary = image <= thresh
     """
-    hist, bin_centers = histogram(image, nbins)
+    hist, bin_centers = histogram(image.flatten(), nbins)
     hist = hist.astype(float)
 
     # class probabilities for all possible thresholds
@@ -176,7 +176,7 @@ def threshold_yen(image, nbins=256):
     >>> thresh = threshold_yen(image)
     >>> binary = image <= thresh
     """
-    hist, bin_centers = histogram(image, nbins)
+    hist, bin_centers = histogram(image.flatten(), nbins)
     # On blank images (e.g. filled with 0) with int dtype, `histogram()`
     # returns `bin_centers` containing only one value. Speed up with it.
     if bin_centers.size == 1:
@@ -246,7 +246,7 @@ def threshold_isodata(image, nbins=256, return_all=False):
     >>> binary = image > thresh
     """
 
-    hist, bin_centers = histogram(image, nbins)
+    hist, bin_centers = histogram(image.flatten(), nbins)
 
     # image only contains one unique value
     if len(bin_centers) == 1:
diff --git a/skimage/graph/tests/__init__.py b/skimage/graph/tests/__init__.py
new file mode 100644
index 00000000..0922ce59
--- /dev/null
+++ b/skimage/graph/tests/__init__.py
@@ -0,0 +1,2 @@
+import warnings
+warnings.simplefilter('error')
diff --git a/skimage/io/_plugins/pil_plugin.py b/skimage/io/_plugins/pil_plugin.py
index 1b0d9efd..f8414283 100644
--- a/skimage/io/_plugins/pil_plugin.py
+++ b/skimage/io/_plugins/pil_plugin.py
@@ -102,7 +102,7 @@ def pil_to_ndarray(im, dtype=None, img_num=None):
             dtype = '>u2' if im.mode.endswith('B') else '<u2'
             if 'S' in im.mode:
                 dtype = dtype.replace('u', 'i')
-            frame = np.fromstring(frame.tostring(), dtype)
+            frame = np.fromstring(frame.tobytes(), dtype)
             frame.shape = shape[::-1]
 
         else:
@@ -179,15 +179,15 @@ def ndarray_to_pil(arr, format_str=None):
 
     if arr.ndim == 2:
         im = Image.new(mode_base, arr.T.shape)
-        im.fromstring(arr.tostring(), 'raw', mode)
+        im.frombytes(arr.tobytes(), 'raw', mode)
 
     else:
         try:
             im = Image.frombytes(mode, (arr.shape[1], arr.shape[0]),
-                                 arr.tostring())
+                                 arr.tobytes())
         except AttributeError:
-            im = Image.fromstring(mode, (arr.shape[1], arr.shape[0]),
-                                  arr.tostring())
+            im = Image.frombytes(mode, (arr.shape[1], arr.shape[0]),
+                                  arr.tobytes())
     return im
 
 
diff --git a/skimage/io/tests/__init__.py b/skimage/io/tests/__init__.py
new file mode 100644
index 00000000..0922ce59
--- /dev/null
+++ b/skimage/io/tests/__init__.py
@@ -0,0 +1,2 @@
+import warnings
+warnings.simplefilter('error')
diff --git a/skimage/io/tests/test_pil.py b/skimage/io/tests/test_pil.py
index cd9cbd21..832ea13e 100644
--- a/skimage/io/tests/test_pil.py
+++ b/skimage/io/tests/test_pil.py
@@ -10,6 +10,7 @@ from skimage import data_dir
 from skimage.io import (imread, imsave, use_plugin, reset_plugins,
                         Image as ioImage)
 from skimage._shared.testing import mono_check, color_check
+from skimage._shared.utils import all_warnings
 
 from six import BytesIO
 
@@ -143,7 +144,8 @@ def test_imsave_filelike():
     s = BytesIO()
 
     # save to file-like object
-    imsave(s, image)
+    with all_warnings():  # precision loss
+        imsave(s, image)
 
     # read from file-like object
     s.seek(0)
@@ -155,7 +157,8 @@ def test_imsave_filelike():
 def test_imexport_imimport():
     shape = (2, 2)
     image = np.zeros(shape)
-    pil_image = ndarray_to_pil(image)
+    with all_warnings():  # precision loss
+        pil_image = ndarray_to_pil(image)
     out = pil_to_ndarray(pil_image)
     assert out.shape == shape
 
diff --git a/skimage/io/tests/test_plugin_util.py b/skimage/io/tests/test_plugin_util.py
index 30f67018..38e795f3 100644
--- a/skimage/io/tests/test_plugin_util.py
+++ b/skimage/io/tests/test_plugin_util.py
@@ -1,4 +1,5 @@
 from skimage.io._plugins.util import prepare_for_display, WindowManager
+from skimage._shared.utils import all_warnings
 
 from numpy.testing import *
 import numpy as np
@@ -8,31 +9,39 @@ np.random.seed(0)
 
 class TestPrepareForDisplay:
     def test_basic(self):
-        prepare_for_display(np.random.rand(10, 10))
+        with all_warnings():  # precision loss
+            prepare_for_display(np.random.rand(10, 10))
 
     def test_dtype(self):
-        x = prepare_for_display(np.random.rand(10, 15))
+        with all_warnings():  # precision loss
+            x = prepare_for_display(np.random.rand(10, 15))
         assert x.dtype == np.dtype(np.uint8)
 
     def test_grey(self):
-        x = prepare_for_display(np.arange(12, dtype=float).reshape((4, 3)) / 11)
+        with all_warnings():  # precision loss
+            tmp = np.arange(12, dtype=float).reshape((4, 3)) / 11
+            x = prepare_for_display(tmp)
         assert_array_equal(x[..., 0], x[..., 2])
         assert x[0, 0, 0] == 0
         assert x[3, 2, 0] == 255
 
     def test_colour(self):
-        prepare_for_display(np.random.rand(10, 10, 3))
+        with all_warnings():  # precision loss
+            prepare_for_display(np.random.rand(10, 10, 3))
 
     def test_alpha(self):
-        prepare_for_display(np.random.rand(10, 10, 4))
+        with all_warnings():  # precision loss
+            prepare_for_display(np.random.rand(10, 10, 4))
 
     @raises(ValueError)
     def test_wrong_dimensionality(self):
-        prepare_for_display(np.random.rand(10, 10, 1, 1))
+        with all_warnings():  # precision loss
+            prepare_for_display(np.random.rand(10, 10, 1, 1))
 
     @raises(ValueError)
     def test_wrong_depth(self):
-        prepare_for_display(np.random.rand(10, 10, 5))
+        with all_warnings():  # precision loss
+            prepare_for_display(np.random.rand(10, 10, 5))
 
 
 class TestWindowManager: