From a067485dec1f90225518af72d50e029aedfe2fd9 Mon Sep 17 00:00:00 2001 From: Vighnesh Birodkar Date: Mon, 10 Mar 2014 22:58:37 +0530 Subject: [PATCH 1/8] added blob_log --- skimage/feature/__init__.py | 5 +- skimage/feature/blob.py | 110 +++++++++++++++++++++++++++++++++++- 2 files changed, 112 insertions(+), 3 deletions(-) diff --git a/skimage/feature/__init__.py b/skimage/feature/__init__.py index 3c33ffb2..54b7bac3 100644 --- a/skimage/feature/__init__.py +++ b/skimage/feature/__init__.py @@ -14,7 +14,7 @@ from .censure import CENSURE from .orb import ORB from .match import match_descriptors from .util import plot_matches -from .blob import blob_dog +from .blob import blob_dog, blob_log __all__ = ['daisy', @@ -42,4 +42,5 @@ __all__ = ['daisy', 'ORB', 'match_descriptors', 'plot_matches', - 'blob_dog'] + 'blob_dog', + 'blob_log'] diff --git a/skimage/feature/blob.py b/skimage/feature/blob.py index 2164755b..25085efe 100644 --- a/skimage/feature/blob.py +++ b/skimage/feature/blob.py @@ -1,5 +1,5 @@ import numpy as np -from scipy.ndimage.filters import gaussian_filter +from scipy.ndimage.filters import gaussian_filter, gaussian_laplace import itertools as itt import math from math import sqrt, hypot, log @@ -200,3 +200,111 @@ def blob_dog(image, min_sigma=1, max_sigma=50, sigma_ratio=1.6, threshold=2.0, return ret_val else: return [] + + +def blob_log(image, min_sigma=1, max_sigma=50, num_sigma=10, threshold=.1, + overlap=.5, log_scale=False): + """Finds blobs in the given grayscale image. + + Blobs are found using the Laplacian of Gaussian (DoG) method[1]_. + For each blob found, its coordinates and area are returned. + + Parameters + ---------- + image : ndarray + Input grayscale image, blobs are assumed to be light on dark + background (white on black). + min_sigma : float, optional + The minimum standard deviation for Gaussian Kernel. Keep this low to + detect smaller blobs. + max_sigma : float, optional + The maximum standard deviation for Gaussian Kernel. Keep this high to + detect larger blobs. + num_sigma : int, optional + The number of intermediate values of standard deviations to consider + between `min_sigma` and `max_sigma`. + threshold : float, optional. + The absolute lower bound for scale space maxima. Local maxima smaller + than thresh are ignored. Reduce this to detect blobs with less + intensities. + overlap : float, optional + A value between 0 and 1. If the area of two blobs overlaps by a + fraction greater than `threshold`, the smaller blob is eliminated. + log_scale : bool, optional + If set intermediate values of standard deviations are interpolated + using a logarithmic scale to the base `10`. If not, linear + interpolation is used. + + Returns + ------- + A : (n, 3) ndarray + A 2d array with each row containing the Y-Coordinate , the + X-Coordinate and the estimated area of the blob respectively. + + References + ---------- + .. [1] http://en.wikipedia.org/wiki/Blob_detection#The_Laplacian_of_Gaussian + + Examples + -------- + >>> from skimage import data, feature, exposure + >>> img = data.coins() + >>> img = exposure.equalize_hist(img) # imporves detection + >>> feature.blob_log(img,threshold = .3) + array([[ 107, 333, 6], + [ 107, 337, 25], + [ 108, 329, 6], + [ 113, 323, 6], + [ 114, 322, 6], + [ 121, 273, 1608], + [ 124, 336, 904], + [ 125, 45, 1061], + [ 125, 207, 904], + [ 127, 102, 760], + [ 128, 155, 760], + [ 178, 261, 25], + [ 186, 345, 2268], + [ 193, 276, 1413], + [ 194, 213, 1413], + [ 196, 102, 1061], + [ 197, 43, 904], + [ 198, 155, 904], + [ 198, 255, 56], + [ 214, 282, 25], + [ 260, 174, 1608], + [ 262, 244, 1413], + [ 262, 302, 1413], + [ 266, 114, 1061], + [ 268, 358, 1061]]) + + """ + + if image.ndim != 2: + raise ValueError("'image' must be a grayscale ") + + image = img_as_float(image) + + if log_scale: + sigma_list = np.linspace(min_sigma, max_sigma, num_sigma) + else: + start, stop = log(min_sigma, 10), log(max_sigma, 10) + sigma_list = np.logspace(start, stop) + + gl_images = [-gaussian_laplace(image, s) * s ** 2 for s in sigma_list] + image_cube = np.dstack(gl_images) + + local_maxima = peak_local_max(image_cube, threshold_abs=threshold, + footprint=np.ones((3, 3, 3)), + threshold_rel=0.0, + exclude_border=False) + + # Convert the last index to its corresponding scale value + local_maxima[:, 2] = sigma_list[local_maxima[:, 2]] + ret_val = _prune_blobs(local_maxima, overlap) + + if len(ret_val) > 0: + ret_val[:, 2] = math.pi * \ + ((ret_val[:, 2] * math.sqrt(2)) ** 2).astype(int) + return ret_val + else: + return [] From 47c5f1bda69d9a063482e6b44ef2da5c109bfb53 Mon Sep 17 00:00:00 2001 From: Vighnesh Birodkar Date: Mon, 10 Mar 2014 23:33:33 +0530 Subject: [PATCH 2/8] added test_blob_log --- skimage/feature/blob.py | 52 +++++++++++++----------------- skimage/feature/tests/test_blob.py | 46 +++++++++++++++++++++++++- 2 files changed, 67 insertions(+), 31 deletions(-) diff --git a/skimage/feature/blob.py b/skimage/feature/blob.py index 25085efe..de49dab9 100644 --- a/skimage/feature/blob.py +++ b/skimage/feature/blob.py @@ -202,11 +202,11 @@ def blob_dog(image, min_sigma=1, max_sigma=50, sigma_ratio=1.6, threshold=2.0, return [] -def blob_log(image, min_sigma=1, max_sigma=50, num_sigma=10, threshold=.1, +def blob_log(image, min_sigma=1, max_sigma=50, num_sigma=10, threshold=.2, overlap=.5, log_scale=False): """Finds blobs in the given grayscale image. - Blobs are found using the Laplacian of Gaussian (DoG) method[1]_. + Blobs are found using the Laplacian of Gaussian (LoG) method[1]_. For each blob found, its coordinates and area are returned. Parameters @@ -249,33 +249,25 @@ def blob_log(image, min_sigma=1, max_sigma=50, num_sigma=10, threshold=.1, -------- >>> from skimage import data, feature, exposure >>> img = data.coins() - >>> img = exposure.equalize_hist(img) # imporves detection + >>> img = exposure.equalize_hist(img) # improves detection >>> feature.blob_log(img,threshold = .3) - array([[ 107, 333, 6], - [ 107, 337, 25], - [ 108, 329, 6], - [ 113, 323, 6], - [ 114, 322, 6], - [ 121, 273, 1608], - [ 124, 336, 904], - [ 125, 45, 1061], - [ 125, 207, 904], + array([[ 113, 323, 6], + [ 121, 272, 1815], + [ 124, 336, 760], + [ 126, 46, 760], + [ 126, 208, 760], [ 127, 102, 760], - [ 128, 155, 760], - [ 178, 261, 25], - [ 186, 345, 2268], - [ 193, 276, 1413], - [ 194, 213, 1413], - [ 196, 102, 1061], - [ 197, 43, 904], - [ 198, 155, 904], - [ 198, 255, 56], - [ 214, 282, 25], - [ 260, 174, 1608], - [ 262, 244, 1413], - [ 262, 302, 1413], - [ 266, 114, 1061], - [ 268, 358, 1061]]) + [ 128, 154, 760], + [ 185, 344, 1815], + [ 194, 213, 1815], + [ 194, 276, 1815], + [ 197, 44, 760], + [ 198, 103, 760], + [ 198, 155, 760], + [ 260, 174, 1815], + [ 263, 244, 1815], + [ 263, 302, 1815], + [ 266, 115, 760]]) """ @@ -285,10 +277,10 @@ def blob_log(image, min_sigma=1, max_sigma=50, num_sigma=10, threshold=.1, image = img_as_float(image) if log_scale: - sigma_list = np.linspace(min_sigma, max_sigma, num_sigma) - else: start, stop = log(min_sigma, 10), log(max_sigma, 10) - sigma_list = np.logspace(start, stop) + sigma_list = np.logspace(start, stop, num_sigma) + else: + sigma_list = np.linspace(min_sigma, max_sigma, num_sigma) gl_images = [-gaussian_laplace(image, s) * s ** 2 for s in sigma_list] image_cube = np.dstack(gl_images) diff --git a/skimage/feature/tests/test_blob.py b/skimage/feature/tests/test_blob.py index 54ed38ce..5ba487c8 100644 --- a/skimage/feature/tests/test_blob.py +++ b/skimage/feature/tests/test_blob.py @@ -1,6 +1,6 @@ import numpy as np from skimage.draw import circle -from skimage.feature import blob_dog +from skimage.feature import blob_dog, blob_log import math @@ -36,3 +36,47 @@ def test_blob_dog(): assert abs(b[0] - 200) <= thresh assert abs(b[1] - 350) <= thresh assert abs(radius(b[2]) - 45) <= thresh + + +def test_blob_log(): + + img = np.ones((512, 512)) + + xs, ys = circle(400, 130, 5) + img[xs, ys] = 255 + + xs, ys = circle(160, 50, 15) + img[xs, ys] = 255 + + xs, ys = circle(100, 300, 25) + img[xs, ys] = 255 + + xs, ys = circle(200, 350, 30) + img[xs, ys] = 255 + + blobs = blob_log(img, min_sigma=5, max_sigma=20, threshold=1) + + area = lambda x: x[2] + radius = lambda x: math.sqrt(x / math.pi) + s = sorted(blobs, key=area) + thresh = 3 + + b = s[0] + assert abs(b[0] - 400) <= thresh + assert abs(b[1] - 130) <= thresh + assert abs(radius(b[2]) - 5) <= thresh + + b = s[1] + assert abs(b[0] - 160) <= thresh + assert abs(b[1] - 50) <= thresh + assert abs(radius(b[2]) - 15) <= thresh + + b = s[2] + assert abs(b[0] - 100) <= thresh + assert abs(b[1] - 300) <= thresh + assert abs(radius(b[2]) - 25) <= thresh + + b = s[3] + assert abs(b[0] - 200) <= thresh + assert abs(b[1] - 350) <= thresh + assert abs(radius(b[2]) - 30) <= thresh From a2438b6338f0783590773b657408de7a097a2144 Mon Sep 17 00:00:00 2001 From: Vighnesh Birodkar Date: Mon, 10 Mar 2014 23:56:30 +0530 Subject: [PATCH 3/8] comments --- skimage/feature/blob.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/skimage/feature/blob.py b/skimage/feature/blob.py index de49dab9..d577d878 100644 --- a/skimage/feature/blob.py +++ b/skimage/feature/blob.py @@ -282,6 +282,8 @@ def blob_log(image, min_sigma=1, max_sigma=50, num_sigma=10, threshold=.2, else: sigma_list = np.linspace(min_sigma, max_sigma, num_sigma) + #computing gaussian laplace + #s**2 provides scale invariance gl_images = [-gaussian_laplace(image, s) * s ** 2 for s in sigma_list] image_cube = np.dstack(gl_images) From 806a52edd52fdb5005112bcb2ac823c5bff315c2 Mon Sep 17 00:00:00 2001 From: Vighnesh Birodkar Date: Tue, 11 Mar 2014 21:55:09 +0530 Subject: [PATCH 4/8] migrated from area to sigma --- skimage/feature/blob.py | 122 ++++++++++++++--------------- skimage/feature/tests/test_blob.py | 28 +++---- 2 files changed, 72 insertions(+), 78 deletions(-) diff --git a/skimage/feature/blob.py b/skimage/feature/blob.py index d577d878..5b7175f2 100644 --- a/skimage/feature/blob.py +++ b/skimage/feature/blob.py @@ -67,9 +67,9 @@ def _prune_blobs(blobs_array, overlap): Parameters ---------- blobs_array : ndarray - a 2d array with each row representing 3 values, the ``(y,x,sigma)`` - where ``(y,x)`` are coordinates of the blob and sigma is the standard - deviation of the Gaussian kernel which detected the blob. + A 2d array with each row representing 3 values, ``(y,x,sigma)`` + where ``(y,x)`` are coordinates of the blob and ``sigma`` is the + standard deviation of the Gaussian kernel which detected the blob. overlap : float A value between 0 and 1. If the fraction of area overlapping for 2 blobs is greater than `overlap` the smaller blob is eliminated. @@ -126,8 +126,9 @@ def blob_dog(image, min_sigma=1, max_sigma=50, sigma_ratio=1.6, threshold=2.0, Returns ------- A : (n, 3) ndarray - A 2d array with each row containing the Y-Coordinate , the - X-Coordinate and the estimated area of the blob respectively. + A 2d array with each row representing 3 values, ``(y,x,sigma)`` + where ``(y,x)`` are coordinates of the blob and ``sigma`` is the + standard deviation of the Gaussian kernel which detected the blob. References ---------- @@ -137,31 +138,34 @@ def blob_dog(image, min_sigma=1, max_sigma=50, sigma_ratio=1.6, threshold=2.0, -------- >>> from skimage import data, feature >>> feature.blob_dog(data.coins(),threshold=.5,max_sigma=40) - array([[ 45, 336, 1608], - [ 52, 155, 1608], - [ 52, 216, 1608], - [ 54, 42, 1608], - [ 54, 276, 628], - [ 58, 100, 628], - [ 120, 272, 1608], - [ 124, 337, 628], - [ 125, 45, 1608], - [ 125, 208, 628], - [ 127, 102, 628], - [ 128, 154, 628], - [ 185, 347, 1608], - [ 193, 213, 1608], - [ 194, 277, 1608], - [ 195, 102, 1608], - [ 196, 43, 628], - [ 198, 155, 628], - [ 260, 46, 1608], - [ 261, 173, 1608], - [ 263, 245, 1608], - [ 263, 302, 1608], - [ 267, 115, 628], - [ 267, 359, 1608]]) + array([[ 45, 336, 16], + [ 52, 155, 16], + [ 52, 216, 16], + [ 54, 42, 16], + [ 54, 276, 10], + [ 58, 100, 10], + [120, 272, 16], + [124, 337, 10], + [125, 45, 16], + [125, 208, 10], + [127, 102, 10], + [128, 154, 10], + [185, 347, 16], + [193, 213, 16], + [194, 277, 16], + [195, 102, 16], + [196, 43, 10], + [198, 155, 10], + [260, 46, 16], + [261, 173, 16], + [263, 245, 16], + [263, 302, 16], + [267, 115, 10], + [267, 359, 16]]) + Notes + ----- + The radius of each blob is approximately :math:`\sqrt{2}sigma`. """ if image.ndim != 2: @@ -192,14 +196,7 @@ def blob_dog(image, min_sigma=1, max_sigma=50, sigma_ratio=1.6, threshold=2.0, # Convert the last index to its corresponding scale value local_maxima[:, 2] = sigma_list[local_maxima[:, 2]] - ret_val = _prune_blobs(local_maxima, overlap) - - if len(ret_val) > 0: - ret_val[:, 2] = math.pi * \ - ((ret_val[:, 2] * math.sqrt(2)) ** 2).astype(int) - return ret_val - else: - return [] + return _prune_blobs(local_maxima, overlap) def blob_log(image, min_sigma=1, max_sigma=50, num_sigma=10, threshold=.2, @@ -238,8 +235,9 @@ def blob_log(image, min_sigma=1, max_sigma=50, num_sigma=10, threshold=.2, Returns ------- A : (n, 3) ndarray - A 2d array with each row containing the Y-Coordinate , the - X-Coordinate and the estimated area of the blob respectively. + A 2d array with each row representing 3 values, ``(y,x,sigma)`` + where ``(y,x)`` are coordinates of the blob and ``sigma`` is the + standard deviation of the Gaussian kernel which detected the blob. References ---------- @@ -251,24 +249,27 @@ def blob_log(image, min_sigma=1, max_sigma=50, num_sigma=10, threshold=.2, >>> img = data.coins() >>> img = exposure.equalize_hist(img) # improves detection >>> feature.blob_log(img,threshold = .3) - array([[ 113, 323, 6], - [ 121, 272, 1815], - [ 124, 336, 760], - [ 126, 46, 760], - [ 126, 208, 760], - [ 127, 102, 760], - [ 128, 154, 760], - [ 185, 344, 1815], - [ 194, 213, 1815], - [ 194, 276, 1815], - [ 197, 44, 760], - [ 198, 103, 760], - [ 198, 155, 760], - [ 260, 174, 1815], - [ 263, 244, 1815], - [ 263, 302, 1815], - [ 266, 115, 760]]) + array([[113, 323, 1], + [121, 272, 17], + [124, 336, 11], + [126, 46, 11], + [126, 208, 11], + [127, 102, 11], + [128, 154, 11], + [185, 344, 17], + [194, 213, 17], + [194, 276, 17], + [197, 44, 11], + [198, 103, 11], + [198, 155, 11], + [260, 174, 17], + [263, 244, 17], + [263, 302, 17], + [266, 115, 11]]) + Notes + ----- + The radius of each blob is approximately :math:`\sqrt{2}sigma`. """ if image.ndim != 2: @@ -294,11 +295,4 @@ def blob_log(image, min_sigma=1, max_sigma=50, num_sigma=10, threshold=.2, # Convert the last index to its corresponding scale value local_maxima[:, 2] = sigma_list[local_maxima[:, 2]] - ret_val = _prune_blobs(local_maxima, overlap) - - if len(ret_val) > 0: - ret_val[:, 2] = math.pi * \ - ((ret_val[:, 2] * math.sqrt(2)) ** 2).astype(int) - return ret_val - else: - return [] + return _prune_blobs(local_maxima, overlap) diff --git a/skimage/feature/tests/test_blob.py b/skimage/feature/tests/test_blob.py index 5ba487c8..6c13bd54 100644 --- a/skimage/feature/tests/test_blob.py +++ b/skimage/feature/tests/test_blob.py @@ -5,6 +5,7 @@ import math def test_blob_dog(): + r2 = math.sqrt(2) img = np.ones((512, 512)) xs, ys = circle(400, 130, 5) @@ -17,29 +18,29 @@ def test_blob_dog(): img[xs, ys] = 255 blobs = blob_dog(img, min_sigma=5, max_sigma=50) - area = lambda x: x[2] - radius = lambda x: math.sqrt(x / math.pi) - s = sorted(blobs, key=area) + radius = lambda x: r2*x[2] + s = sorted(blobs, key=radius) thresh = 5 b = s[0] assert abs(b[0] - 400) <= thresh assert abs(b[1] - 130) <= thresh - assert abs(radius(b[2]) - 5) <= thresh + assert abs(radius(b) - 5) <= thresh b = s[1] + print abs(radius(b)) assert abs(b[0] - 100) <= thresh assert abs(b[1] - 300) <= thresh - assert abs(radius(b[2]) - 25) <= thresh + assert abs(radius(b) - 25) <= thresh b = s[2] assert abs(b[0] - 200) <= thresh assert abs(b[1] - 350) <= thresh - assert abs(radius(b[2]) - 45) <= thresh + assert abs(radius(b) - 45) <= thresh def test_blob_log(): - + r2 = math.sqrt(2) img = np.ones((512, 512)) xs, ys = circle(400, 130, 5) @@ -56,27 +57,26 @@ def test_blob_log(): blobs = blob_log(img, min_sigma=5, max_sigma=20, threshold=1) - area = lambda x: x[2] - radius = lambda x: math.sqrt(x / math.pi) - s = sorted(blobs, key=area) + radius = lambda x: r2*x[2] + s = sorted(blobs, key=radius) thresh = 3 b = s[0] assert abs(b[0] - 400) <= thresh assert abs(b[1] - 130) <= thresh - assert abs(radius(b[2]) - 5) <= thresh + assert abs(radius(b) - 5) <= thresh b = s[1] assert abs(b[0] - 160) <= thresh assert abs(b[1] - 50) <= thresh - assert abs(radius(b[2]) - 15) <= thresh + assert abs(radius(b) - 15) <= thresh b = s[2] assert abs(b[0] - 100) <= thresh assert abs(b[1] - 300) <= thresh - assert abs(radius(b[2]) - 25) <= thresh + assert abs(radius(b) - 25) <= thresh b = s[3] assert abs(b[0] - 200) <= thresh assert abs(b[1] - 350) <= thresh - assert abs(radius(b[2]) - 30) <= thresh + assert abs(radius(b) - 30) <= thresh From 815b0226d494001c9759e9b846a165e8cd63660c Mon Sep 17 00:00:00 2001 From: Vighnesh Birodkar Date: Tue, 11 Mar 2014 21:59:51 +0530 Subject: [PATCH 5/8] removed print --- skimage/feature/tests/test_blob.py | 1 - 1 file changed, 1 deletion(-) diff --git a/skimage/feature/tests/test_blob.py b/skimage/feature/tests/test_blob.py index 6c13bd54..3ae949c2 100644 --- a/skimage/feature/tests/test_blob.py +++ b/skimage/feature/tests/test_blob.py @@ -28,7 +28,6 @@ def test_blob_dog(): assert abs(radius(b) - 5) <= thresh b = s[1] - print abs(radius(b)) assert abs(b[0] - 100) <= thresh assert abs(b[1] - 300) <= thresh assert abs(radius(b) - 25) <= thresh From 6e6b27bc86810f58fd002ed97b808d789908a1eb Mon Sep 17 00:00:00 2001 From: Vighnesh Birodkar Date: Tue, 11 Mar 2014 22:24:08 +0530 Subject: [PATCH 6/8] doc changes --- skimage/feature/blob.py | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/skimage/feature/blob.py b/skimage/feature/blob.py index 5b7175f2..dd72beae 100644 --- a/skimage/feature/blob.py +++ b/skimage/feature/blob.py @@ -99,7 +99,8 @@ def blob_dog(image, min_sigma=1, max_sigma=50, sigma_ratio=1.6, threshold=2.0, """Finds blobs in the given grayscale image. Blobs are found using the Difference of Gaussian (DoG) method[1]_. - For each blob found, its coordinates and area are returned. + For each blob found, the method returns its coordinates and the standard + deviation of the Gaussian kernel that detected the blob. Parameters ---------- @@ -137,7 +138,7 @@ def blob_dog(image, min_sigma=1, max_sigma=50, sigma_ratio=1.6, threshold=2.0, Examples -------- >>> from skimage import data, feature - >>> feature.blob_dog(data.coins(),threshold=.5,max_sigma=40) + >>> feature.blob_dog(data.coins(), threshold=.5, max_sigma=40) array([[ 45, 336, 16], [ 52, 155, 16], [ 52, 216, 16], @@ -204,7 +205,8 @@ def blob_log(image, min_sigma=1, max_sigma=50, num_sigma=10, threshold=.2, """Finds blobs in the given grayscale image. Blobs are found using the Laplacian of Gaussian (LoG) method[1]_. - For each blob found, its coordinates and area are returned. + For each blob found, the method returns its coordinates and the standard + deviation of the Gaussian kernel that detected the blob. Parameters ---------- @@ -247,8 +249,8 @@ def blob_log(image, min_sigma=1, max_sigma=50, num_sigma=10, threshold=.2, -------- >>> from skimage import data, feature, exposure >>> img = data.coins() - >>> img = exposure.equalize_hist(img) # improves detection - >>> feature.blob_log(img,threshold = .3) + >>> img = exposure.equalize_hist(img)# improves detection + >>> feature.blob_log(img, threshold = .3) array([[113, 323, 1], [121, 272, 17], [124, 336, 11], From 5255b29f6ef870881f73ab20550f024109f63117 Mon Sep 17 00:00:00 2001 From: Vighnesh Birodkar Date: Tue, 11 Mar 2014 22:29:03 +0530 Subject: [PATCH 7/8] doc rectify --- skimage/feature/blob.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/skimage/feature/blob.py b/skimage/feature/blob.py index dd72beae..acf1bd21 100644 --- a/skimage/feature/blob.py +++ b/skimage/feature/blob.py @@ -249,7 +249,7 @@ def blob_log(image, min_sigma=1, max_sigma=50, num_sigma=10, threshold=.2, -------- >>> from skimage import data, feature, exposure >>> img = data.coins() - >>> img = exposure.equalize_hist(img)# improves detection + >>> img = exposure.equalize_hist(img) # improves detection >>> feature.blob_log(img, threshold = .3) array([[113, 323, 1], [121, 272, 17], From c92358706bfab59632724e81c1bd511f35810bb7 Mon Sep 17 00:00:00 2001 From: Vighnesh Birodkar Date: Thu, 13 Mar 2014 03:22:30 +0530 Subject: [PATCH 8/8] typo --- skimage/feature/blob.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/skimage/feature/blob.py b/skimage/feature/blob.py index acf1bd21..1b465c5f 100644 --- a/skimage/feature/blob.py +++ b/skimage/feature/blob.py @@ -98,7 +98,7 @@ def blob_dog(image, min_sigma=1, max_sigma=50, sigma_ratio=1.6, threshold=2.0, overlap=.5,): """Finds blobs in the given grayscale image. - Blobs are found using the Difference of Gaussian (DoG) method[1]_. + Blobs are found using the Difference of Gaussian (DoG) method [1]_. For each blob found, the method returns its coordinates and the standard deviation of the Gaussian kernel that detected the blob. @@ -204,7 +204,7 @@ def blob_log(image, min_sigma=1, max_sigma=50, num_sigma=10, threshold=.2, overlap=.5, log_scale=False): """Finds blobs in the given grayscale image. - Blobs are found using the Laplacian of Gaussian (LoG) method[1]_. + Blobs are found using the Laplacian of Gaussian (LoG) method [1]_. For each blob found, the method returns its coordinates and the standard deviation of the Gaussian kernel that detected the blob.