Add 0.24.x

0.24.x/.buildinfo

@@ -0,0 +1,4 @@
+# Sphinx build info version 1
+# This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
+config: 86dfd7b2b609f4d657e7084b28458fde
+tags: 645f666f9bcd5a90fca523b33c5a78b7

0.24.x/_downloads/00391bbcdb077d3c759f818c6643cee4/plot_circular_elliptical_hough_transform.py

@@ -0,0 +1,140 @@
+"""
+========================================
+Circular and Elliptical Hough Transforms
+========================================
+
+The Hough transform in its simplest form is a `method to detect
+straight lines <https://en.wikipedia.org/wiki/Hough_transform>`__
+but it can also be used to detect circles or ellipses.
+The algorithm assumes that the edge is detected and it is robust against
+noise or missing points.
+
+Circle detection
+================
+
+In the following example, the Hough transform is used to detect
+coin positions and match their edges. We provide a range of
+plausible radii. For each radius, two circles are extracted and
+we finally keep the five most prominent candidates.
+The result shows that coin positions are well-detected.
+
+
+Algorithm overview
+------------------
+
+Given a black circle on a white background, we first guess its
+radius (or a range of radii) to construct a new circle.
+This circle is applied on each black pixel of the original picture
+and the coordinates of this circle are voting in an accumulator.
+From this geometrical construction, the original circle center
+position receives the highest score.
+
+Note that the accumulator size is built to be larger than the
+original picture in order to detect centers outside the frame.
+Its size is extended by two times the larger radius.
+
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+from skimage import data, color
+from skimage.transform import hough_circle, hough_circle_peaks
+from skimage.feature import canny
+from skimage.draw import circle_perimeter
+from skimage.util import img_as_ubyte
+
+
+# Load picture and detect edges
+image = img_as_ubyte(data.coins()[160:230, 70:270])
+edges = canny(image, sigma=3, low_threshold=10, high_threshold=50)
+
+
+# Detect two radii
+hough_radii = np.arange(20, 35, 2)
+hough_res = hough_circle(edges, hough_radii)
+
+# Select the most prominent 3 circles
+accums, cx, cy, radii = hough_circle_peaks(hough_res, hough_radii, total_num_peaks=3)
+
+# Draw them
+fig, ax = plt.subplots(ncols=1, nrows=1, figsize=(10, 4))
+image = color.gray2rgb(image)
+for center_y, center_x, radius in zip(cy, cx, radii):
+    circy, circx = circle_perimeter(center_y, center_x, radius, shape=image.shape)
+    image[circy, circx] = (220, 20, 20)
+
+ax.imshow(image, cmap=plt.cm.gray)
+plt.show()
+
+
+######################################################################
+# Ellipse detection
+# =================
+#
+# In this second example, the aim is to detect the edge of a coffee cup.
+# Basically, this is a projection of a circle, i.e. an ellipse. The problem
+# to solve is much more difficult because five parameters have to be
+# determined, instead of three for circles.
+#
+# Algorithm overview
+# -------------------
+#
+# The algorithm takes two different points belonging to the ellipse. It
+# assumes that these two points form the major axis. A loop on all the
+# other points determines the minor axis length for candidate ellipses.
+# The latter are included in the results if enough 'valid' candidates have
+# similar minor axis lengths. By valid, we mean candidates for which the
+# minor and major axis lengths fall within the prescribed bounds.
+# A full description of the algorithm can be found in reference [1]_.
+#
+# References
+# ----------
+# .. [1] Xie, Yonghong, and Qiang Ji. "A new efficient
+#        ellipse detection method." Pattern Recognition, 2002. Proceedings.
+#        16th International Conference on. Vol. 2. IEEE, 2002
+
+import matplotlib.pyplot as plt
+
+from skimage import data, color, img_as_ubyte
+from skimage.feature import canny
+from skimage.transform import hough_ellipse
+from skimage.draw import ellipse_perimeter
+
+# Load picture, convert to grayscale and detect edges
+image_rgb = data.coffee()[0:220, 160:420]
+image_gray = color.rgb2gray(image_rgb)
+edges = canny(image_gray, sigma=2.0, low_threshold=0.55, high_threshold=0.8)
+
+# Perform a Hough Transform
+# The accuracy corresponds to the bin size of the histogram for minor axis lengths.
+# A higher `accuracy` value will lead to more ellipses being found, at the
+# cost of a lower precision on the minor axis length estimation.
+# A higher `threshold` will lead to less ellipses being found, filtering out those
+# with fewer edge points (as found above by the Canny detector) on their perimeter.
+result = hough_ellipse(edges, accuracy=20, threshold=250, min_size=100, max_size=120)
+result.sort(order='accumulator')
+
+# Estimated parameters for the ellipse
+best = list(result[-1])
+yc, xc, a, b = (int(round(x)) for x in best[1:5])
+orientation = best[5]
+
+# Draw the ellipse on the original image
+cy, cx = ellipse_perimeter(yc, xc, a, b, orientation)
+image_rgb[cy, cx] = (0, 0, 255)
+# Draw the edge (white) and the resulting ellipse (red)
+edges = color.gray2rgb(img_as_ubyte(edges))
+edges[cy, cx] = (250, 0, 0)
+
+fig2, (ax1, ax2) = plt.subplots(
+    ncols=2, nrows=1, figsize=(8, 4), sharex=True, sharey=True
+)
+
+ax1.set_title('Original picture')
+ax1.imshow(image_rgb)
+
+ax2.set_title('Edge (white) and result (red)')
+ax2.imshow(edges)
+
+plt.show()

0.24.x/_downloads/00d929af82f15e4a9e4fa184af4f8bc2/plot_nonlocal_means.py

@@ -0,0 +1,109 @@
+"""
+=================================================
+Non-local means denoising for preserving textures
+=================================================
+
+In this example, we denoise a detail of the astronaut image using the non-local
+means filter. The non-local means algorithm replaces the value of a pixel by an
+average of a selection of other pixels values: small patches centered on the
+other pixels are compared to the patch centered on the pixel of interest, and
+the average is performed only for pixels that have patches close to the current
+patch. As a result, this algorithm can restore well textures, that would be
+blurred by other denoising algorithm.
+
+When the ``fast_mode`` argument is ``False``, a spatial Gaussian weighting is
+applied to the patches when computing patch distances.  When ``fast_mode`` is
+``True`` a faster algorithm employing uniform spatial weighting on the patches
+is applied.
+
+For either of these cases, if the noise standard deviation, ``sigma``, is
+provided, the expected noise variance is subtracted out when computing patch
+distances.  This can lead to a modest improvement in image quality.
+
+The ``estimate_sigma`` function can provide a good starting point for setting
+the ``h`` (and optionally, ``sigma``) parameters for the non-local means algorithm.
+``h`` is a constant that controls the decay in patch weights as a function of the
+distance between patches.  Larger ``h`` allows more smoothing between disimilar
+patches.
+
+In this demo, ``h``, was hand-tuned to give the approximate best-case performance
+of each variant.
+
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+from skimage import data, img_as_float
+from skimage.restoration import denoise_nl_means, estimate_sigma
+from skimage.metrics import peak_signal_noise_ratio
+from skimage.util import random_noise
+
+
+astro = img_as_float(data.astronaut())
+astro = astro[30:180, 150:300]
+
+sigma = 0.08
+noisy = random_noise(astro, var=sigma**2)
+
+# estimate the noise standard deviation from the noisy image
+sigma_est = np.mean(estimate_sigma(noisy, channel_axis=-1))
+print(f'estimated noise standard deviation = {sigma_est}')
+
+patch_kw = dict(
+    patch_size=5, patch_distance=6, channel_axis=-1  # 5x5 patches  # 13x13 search area
+)
+
+# slow algorithm
+denoise = denoise_nl_means(noisy, h=1.15 * sigma_est, fast_mode=False, **patch_kw)
+
+# slow algorithm, sigma provided
+denoise2 = denoise_nl_means(
+    noisy, h=0.8 * sigma_est, sigma=sigma_est, fast_mode=False, **patch_kw
+)
+
+# fast algorithm
+denoise_fast = denoise_nl_means(noisy, h=0.8 * sigma_est, fast_mode=True, **patch_kw)
+
+# fast algorithm, sigma provided
+denoise2_fast = denoise_nl_means(
+    noisy, h=0.6 * sigma_est, sigma=sigma_est, fast_mode=True, **patch_kw
+)
+
+fig, ax = plt.subplots(nrows=2, ncols=3, figsize=(8, 6), sharex=True, sharey=True)
+
+ax[0, 0].imshow(noisy)
+ax[0, 0].axis('off')
+ax[0, 0].set_title('noisy')
+ax[0, 1].imshow(denoise)
+ax[0, 1].axis('off')
+ax[0, 1].set_title('non-local means\n(slow)')
+ax[0, 2].imshow(denoise2)
+ax[0, 2].axis('off')
+ax[0, 2].set_title('non-local means\n(slow, using $\\sigma_{est}$)')
+ax[1, 0].imshow(astro)
+ax[1, 0].axis('off')
+ax[1, 0].set_title('original\n(noise free)')
+ax[1, 1].imshow(denoise_fast)
+ax[1, 1].axis('off')
+ax[1, 1].set_title('non-local means\n(fast)')
+ax[1, 2].imshow(denoise2_fast)
+ax[1, 2].axis('off')
+ax[1, 2].set_title('non-local means\n(fast, using $\\sigma_{est}$)')
+
+fig.tight_layout()
+
+# print PSNR metric for each case
+psnr_noisy = peak_signal_noise_ratio(astro, noisy)
+psnr = peak_signal_noise_ratio(astro, denoise)
+psnr2 = peak_signal_noise_ratio(astro, denoise2)
+psnr_fast = peak_signal_noise_ratio(astro, denoise_fast)
+psnr2_fast = peak_signal_noise_ratio(astro, denoise2_fast)
+
+print(f'PSNR (noisy) = {psnr_noisy:0.2f}')
+print(f'PSNR (slow) = {psnr:0.2f}')
+print(f'PSNR (slow, using sigma) = {psnr2:0.2f}')
+print(f'PSNR (fast) = {psnr_fast:0.2f}')
+print(f'PSNR (fast, using sigma) = {psnr2_fast:0.2f}')
+
+plt.show()