示例#1
0
def test_2d_linearity():

    a_black = np.ones((3, 3)).astype(np.uint8)
    a_white = invert(a_black)

    assert_allclose(meijering(1 * a_black, black_ridges=True),
                    meijering(10 * a_black, black_ridges=True),
                    atol=1e-3)
    assert_allclose(meijering(1 * a_white, black_ridges=False),
                    meijering(10 * a_white, black_ridges=False),
                    atol=1e-3)

    assert_allclose(sato(1 * a_black, black_ridges=True),
                    sato(10 * a_black, black_ridges=True),
                    atol=1e-3)
    assert_allclose(sato(1 * a_white, black_ridges=False),
                    sato(10 * a_white, black_ridges=False),
                    atol=1e-3)

    assert_allclose(frangi(1 * a_black, black_ridges=True),
                    frangi(10 * a_black, black_ridges=True),
                    atol=1e-3)
    assert_allclose(frangi(1 * a_white, black_ridges=False),
                    frangi(10 * a_white, black_ridges=False),
                    atol=1e-3)

    assert_allclose(hessian(1 * a_black, black_ridges=True),
                    hessian(10 * a_black, black_ridges=True),
                    atol=1e-3)
    assert_allclose(hessian(1 * a_white, black_ridges=False),
                    hessian(10 * a_white, black_ridges=False),
                    atol=1e-3)
示例#2
0
def test_3d_energy_decrease():

    a_black = np.zeros((5, 5, 5)).astype(np.uint8)
    a_black[2, 2, 2] = 255
    a_white = invert(a_black)

    assert_array_less(
        meijering(a_black, black_ridges=True).std(), a_black.std())
    assert_array_less(
        meijering(a_white, black_ridges=False).std(), a_white.std())

    assert_array_less(
        sato(a_black, black_ridges=True, mode='reflect').std(), a_black.std())
    assert_array_less(
        sato(a_white, black_ridges=False, mode='reflect').std(), a_white.std())

    assert_array_less(frangi(a_black, black_ridges=True).std(), a_black.std())
    assert_array_less(frangi(a_white, black_ridges=False).std(), a_white.std())

    assert_array_less(
        hessian(a_black, black_ridges=True, mode='reflect').std(),
        a_black.std())
    assert_array_less(
        hessian(a_white, black_ridges=False, mode='reflect').std(),
        a_white.std())
示例#3
0
def test_3d_linearity():

    # Note: last axis intentionally not size 3 to avoid 2D+RGB autodetection
    #       warning from an internal call to `skimage.filters.gaussian`.
    a_black = np.ones((3, 3, 5)).astype(np.uint8)
    a_white = invert(a_black)

    assert_allclose(meijering(1 * a_black, black_ridges=True),
                    meijering(10 * a_black, black_ridges=True),
                    atol=1e-3)
    assert_allclose(meijering(1 * a_white, black_ridges=False),
                    meijering(10 * a_white, black_ridges=False),
                    atol=1e-3)

    assert_allclose(sato(1 * a_black, black_ridges=True, mode='reflect'),
                    sato(10 * a_black, black_ridges=True, mode='reflect'),
                    atol=1e-3)
    assert_allclose(sato(1 * a_white, black_ridges=False, mode='reflect'),
                    sato(10 * a_white, black_ridges=False, mode='reflect'),
                    atol=1e-3)

    assert_allclose(frangi(1 * a_black, black_ridges=True),
                    frangi(10 * a_black, black_ridges=True),
                    atol=1e-3)
    assert_allclose(frangi(1 * a_white, black_ridges=False),
                    frangi(10 * a_white, black_ridges=False),
                    atol=1e-3)

    assert_allclose(hessian(1 * a_black, black_ridges=True, mode='reflect'),
                    hessian(10 * a_black, black_ridges=True, mode='reflect'),
                    atol=1e-3)
    assert_allclose(hessian(1 * a_white, black_ridges=False, mode='reflect'),
                    hessian(10 * a_white, black_ridges=False, mode='reflect'),
                    atol=1e-3)
示例#4
0
def test_cropped_camera_image():
    image = crop(camera(), ((206, 206), (206, 206)))
    assert_allclose(frangi(image), np.zeros((100, 100)), atol=1e-03)
    assert_allclose(frangi(image, black_ridges=True),
                    np.zeros((100, 100)),
                    atol=1e-03)
    assert_allclose(hessian(image), np.ones((100, 100)), atol=1 - 1e-07)
示例#5
0
 def run(self, ips, imgs, para=None):
     imgs[:] = hessian(imgs,
                       range(para['start'], para['end'], para['step']),
                       alpha=para['alpha'],
                       beta=para['beta'],
                       gamma=para['gamma'],
                       black_ridges=para['bridges'])
def hessianFiltering(image, fileprefix):
    # img must be read with skimg
    image_f = hessian(image, sigmas=[1, 1.5], black_ridges=False)
    final_image = np.multiply(image_f, image).astype(np.uint8)
    imageio.imwrite(f'{fileprefix}_hessian_filtered.png', final_image)
    image = cv2.imread(f'{fileprefix}_hessian_filtered.png', 0)
    return cv2.imread(f'{fileprefix}_hessian_filtered.png', 0)
示例#7
0
def extract_vessels(img_orig):
    kernel = np.ones((2, 2), np.uint8)  #kernel for erosion and dilation

    image = (hessian(img_orig) * 255).astype('uint8')  #ridge detection

    image = remove_small_objects(image.astype(bool),
                                 min_size=64,
                                 connectivity=0).astype(float)

    image = cv2.dilate(image, kernel, iterations=3)  #to join disconnected
    image = cv2.erode(image, kernel, iterations=3)  #to join disconnected
    image = cv2.dilate(image, kernel, iterations=1)  #to join disconnected
    image = cv2.erode(image, kernel, iterations=1)  #to join disconnected
    image = cv2.dilate(image, kernel, iterations=1)  #to join disconnected

    #Use any one below
    skel = skeletonize(image)
    # skel = thin(image)
    # med, distance = medial_axis(image, return_distance=True)
    # # skel = med*distance

    #To get the circular part
    mask = np.zeros_like(image, np.uint8)
    H, W = image.shape
    mask = cv2.circle(mask, (H // 2, W // 2),
                      H // 2, (255, 255, 255),
                      thickness=-1)
    masked_data = cv2.bitwise_and(skel * 255, skel * 255, mask=mask)
    return masked_data
示例#8
0
 def run(self, ips, snap, img, para=None):
     rst = hessian(snap,
                   range(para['start'], para['end'], para['step']),
                   alpha=para['alpha'],
                   beta=para['beta'],
                   gamma=para['gamma'],
                   black_ridges=para['bridges'])
     img[:] = scale(rst, ips.range[0], ips.range[1])
示例#9
0
 def run(self, ips, imgs, para=None):
     IPy.show_img(
         hessian(imgs,
                 range(para['start'], para['end'], para['step']),
                 alpha=para['alpha'],
                 beta=para['beta'],
                 gamma=para['gamma'],
                 black_ridges=para['bridges']), ips.title + '-hessian')
示例#10
0
 def apply(self, c):
     if self.filter_name == "frangi":
         return frangi(c)
     if self.filter_name == "hessian":
         return hessian(c)
     if self.filter_name == "sato":
         return sato(c)
     raise ValueError("FilterName - {} - not known".format(
         self.filter_name))
示例#11
0
def test_2d_null_matrix():

    a_black = np.zeros((3, 3)).astype(np.uint8)
    a_white = invert(a_black)

    zeros = np.zeros((3, 3))
    ones = np.ones((3, 3))

    assert_equal(meijering(a_black, black_ridges=True), ones)
    assert_equal(meijering(a_white, black_ridges=False), ones)

    assert_equal(sato(a_black, black_ridges=True), zeros)
    assert_equal(sato(a_white, black_ridges=False), zeros)

    assert_allclose(frangi(a_black, black_ridges=True), zeros, atol=1e-3)
    assert_allclose(frangi(a_white, black_ridges=False), zeros, atol=1e-3)

    assert_equal(hessian(a_black, black_ridges=False), ones)
    assert_equal(hessian(a_white, black_ridges=True), ones)
示例#12
0
def test_2d_cropped_camera_image():

    a_black = crop(camera(), ((206, 206), (206, 206)))
    a_white = invert(a_black)

    zeros = np.zeros((100, 100))
    ones = np.ones((100, 100))

    assert_allclose(meijering(a_black, black_ridges=True),
                    meijering(a_white, black_ridges=False))

    assert_allclose(sato(a_black, black_ridges=True),
                    sato(a_white, black_ridges=False))

    assert_allclose(frangi(a_black, black_ridges=True), zeros, atol=1e-3)
    assert_allclose(frangi(a_white, black_ridges=False), zeros, atol=1e-3)

    assert_allclose(hessian(a_black, black_ridges=True), ones, atol=1 - 1e-7)
    assert_allclose(hessian(a_white, black_ridges=False), ones, atol=1 - 1e-7)
示例#13
0
def test_3d_null_matrix():

    # Note: last axis intentionally not size 3 to avoid 2D+RGB autodetection
    #       warning from an internal call to `skimage.filters.gaussian`.
    a_black = np.zeros((3, 3, 5)).astype(np.uint8)
    a_white = invert(a_black)

    zeros = np.zeros((3, 3, 5))
    ones = np.ones((3, 3, 5))

    assert_allclose(meijering(a_black, black_ridges=True), zeros, atol=1e-1)
    assert_allclose(meijering(a_white, black_ridges=False), zeros, atol=1e-1)

    assert_equal(sato(a_black, black_ridges=True, mode='reflect'), zeros)
    assert_equal(sato(a_white, black_ridges=False, mode='reflect'), zeros)

    assert_allclose(frangi(a_black, black_ridges=True), zeros, atol=1e-3)
    assert_allclose(frangi(a_white, black_ridges=False), zeros, atol=1e-3)

    assert_equal(hessian(a_black, black_ridges=False, mode='reflect'), ones)
    assert_equal(hessian(a_white, black_ridges=True, mode='reflect'), ones)
示例#14
0
def test_3d_cropped_camera_image():

    a_black = crop(camera(), ((200, 212), (100, 312)))
    a_black = np.dstack([a_black, a_black, a_black])
    a_white = invert(a_black)

    zeros = np.zeros((100, 100, 3))
    ones = np.ones((100, 100, 3))

    assert_allclose(meijering(a_black, black_ridges=True),
                    meijering(a_white, black_ridges=False))

    assert_allclose(sato(a_black, black_ridges=True, mode='reflect'),
                    sato(a_white, black_ridges=False, mode='reflect'))

    assert_allclose(frangi(a_black, black_ridges=True), zeros, atol=1e-3)
    assert_allclose(frangi(a_white, black_ridges=False), zeros, atol=1e-3)

    assert_allclose(hessian(a_black, black_ridges=True, mode='reflect'),
                    ones, atol=1 - 1e-7)
    assert_allclose(hessian(a_white, black_ridges=False, mode='reflect'),
                    ones, atol=1 - 1e-7)
示例#15
0
文件: HHF.py 项目: ShozenD/AIMirror
def HHF(image):
    horizontal_gradient = sobel_h(image)
    hessian_filter = hessian(horizontal_gradient,
                             scale_range=(1, 10),
                             scale_step=2,
                             beta1=0.5,
                             beta2=10)
    norm_image = cv2.normalize(hessian_filter,
                               None,
                               alpha=0,
                               beta=1,
                               norm_type=cv2.NORM_MINMAX,
                               dtype=cv2.CV_32F)
    return norm_image
def hessianFilter():
    global filterimage
    imgFilter8 = filters.hessian(img,
                                 sigmas=range(1, 10, 2),
                                 scale_range=None,
                                 scale_step=None,
                                 alpha=0.5,
                                 beta=0.5,
                                 gamma=15,
                                 black_ridges=True,
                                 mode=None,
                                 cval=0)
    filterimage = imgFilter8
    io.imshow(imgFilter8)
    io.show()
示例#17
0
def monolayers(original, logger):
    logger.info("Finding edges and groups")
    groups = get_groups(original)

    logger.info("Finding vignetting")
    original = downscale_to(original, area_limit=2e5)
    g = original[:, :, 1]
    vignetting = find_vignetting(g, groups)
    vignetting = np.where(groups <= 0, 0, vignetting)
    g = smooth_with_mask(g - vignetting, mask=groups > 0, sigma=2)

    logger.info("Finding substrate and monolayer colors")
    if np.sum(groups == -2) != 0:
        distance_from_mechanical_vignette = distance_transform_edt(
            groups != -2)
    else:
        distance_from_mechanical_vignette = np.full(groups.shape, np.inf)

    far_from_mechanical_vignette = distance_from_mechanical_vignette > 50
    rng, histogram = get_histogram(g[(groups > 0)
                                     & far_from_mechanical_vignette])
    peaks, valleys = peaks_and_valleys(histogram, {
        "distance": 10,
        "prominence": 1e-3
    })
    substrate_color = rng[peaks[np.argmax(histogram[peaks])]]
    best_monolayer_color = (-0.06 + 1) * substrate_color
    monolayer_peak_index = np.argmin(np.abs(rng[peaks] - best_monolayer_color))
    min_monolayer, max_monolayer = rng[valleys[monolayer_peak_index]], rng[
        valleys[monolayer_peak_index + 1]]
    min_monolayer = 2 * rng[peaks[monolayer_peak_index]] - max_monolayer
    monolayer = (g >= min_monolayer) & (g <= max_monolayer) & (
        groups > 0) & far_from_mechanical_vignette
    monolayer = remove_small_objects(monolayer, np.sum(groups > 0) // 200)
    monolayer = binary_closing(monolayer, disk(5))
    monolayer = binary_dilation(monolayer, disk(1))
    monolayer = fill_shape(monolayer)

    logger.info("Separating overlapping monolayers")
    distance = distance_transform_edt(monolayer)
    ridges = hessian(distance, black_ridges=True) * monolayer
    markers = im_label(ridges == 1)
    monolayer_group = watershed(-distance, markers, mask=monolayer)
    monolayer_group = prune(monolayer_group, rel_threshold=0.05)
    for group in range(1, np.max(monolayer_group) + 1):
        monolayer_group = fill_shape(monolayer_group, group, tol=2)
    return {"original": original, "monolayers": monolayer_group}
示例#18
0
def filter_show(data):
    for k in [12, 3088]:
        img = np.array(data[k]).reshape((28, 28))

        image_scharr = scharr(img)
        image_sobel = sobel(img)
        image_prewitt = prewitt(img)
        image_gabor_real, image_gabor_im = gabor(img, frequency=0.65)
        image_roberts = roberts(img)
        image_roberts_pos = roberts_pos_diag(img)
        image_roberts_neg = roberts_neg_diag(img)
        image_frangi = frangi(img)
        image_laplace = laplace(img)
        image_hessian = hessian(img)
        image_threshold_local_3 = threshold_local(img, 3)
        image_threshold_local_5 = threshold_local(img, 5)
        image_threshold_local_7 = threshold_local(img, 7)
        image_threshold_niblack = threshold_niblack(img, window_size=5, k=0.1)
        image_threshold_sauvola = threshold_sauvola(img)
        image_threshold_triangle = img > threshold_triangle(img)

        fig, axes = plt.subplots(nrows=2,
                                 ncols=2,
                                 sharex=True,
                                 sharey=True,
                                 figsize=(8, 8))
        ax = axes.ravel()

        ax[0].imshow(img, cmap=plt.cm.gray)
        ax[0].set_title('Original image')

        ax[1].imshow(image_threshold_niblack, cmap=plt.cm.gray)
        ax[1].set_title('Niblack')

        ax[2].imshow(image_threshold_sauvola, cmap=plt.cm.gray)
        ax[2].set_title('Sauvola')

        ax[3].imshow(image_threshold_triangle, cmap=plt.cm.gray)
        ax[3].set_title('Triangle')

        for a in ax:
            a.axis('off')

        plt.tight_layout()
        plt.show()
        plt.close()
示例#19
0
def cellMass(img):
    """ Calculating of the center of mass coordinate using threshold mask
    for already detected cell.

    Treshold function use modifyed Hessian filter.
    This method optimysed for confocal image of HEK 293 cells with fluorecent-
    labelled protein who located into the membrane.

    Results of this method for fluorecent microscop images
    or fluorecent-labelled proteins with cytoplasmic localization
    may by unpredictable and incorrect.

    """

    mass_mask = filters.hessian(img, sigmas=range(20, 28, 1))
    mass_cntr = msr.center_of_mass(mass_mask)
    mass_coord = [np.int(mass_cntr[1]), np.int(mass_cntr[0])]

    logging.info("Image center of mass: %s" % mass_coord)

    return mass_coord
def hess(image):
    return hessian(image)
示例#21
0
def hessian_filter(filename):
    img = asarray(Image.open(filename))
    img = rgb2gray(img)
    img = filters.hessian(img, mode="reflect")
    plt.imsave(filename, img, cmap="gray")
    return filename
示例#22
0
def Hessian(image):
    image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
    return fil.hessian(image)
示例#23
0
def test_cropped_camera_image():
    image = crop(camera(), ((206, 206), (206, 206)))
    assert_allclose(frangi(image), np.zeros((100, 100)), atol=1e-03)
    assert_allclose(frangi(image, black_ridges=True),
                    np.zeros((100, 100)), atol=1e-03)
    assert_allclose(hessian(image), np.ones((100, 100)), atol=1-1e-07)
示例#24
0
#from skimage.data import camera
from skimage.filters import frangi, hessian
from skimage.io import imread
from skimage.color import rgb2gray
import matplotlib.pyplot as plt

#image = camera()
image = rgb2gray(imread("lena.png"))
fig, ax = plt.subplots(ncols=3)

ax[0].imshow(image, cmap=plt.cm.gray)
ax[0].set_title('Original image')

ax[1].imshow(frangi(image), cmap=plt.cm.gray)
ax[1].set_title('Frangi filter result')

ax[2].imshow(hessian(image), cmap=plt.cm.gray)
ax[2].set_title('Hybrid Hessian filter result')

for a in ax:
    a.axis('off')

plt.tight_layout()
plt.show()
def hessian_2d_filter(image):
    """ TODO
    """
    return filters.hessian(image)
示例#26
0
文件: eval.py 项目: footh/nuclei
def hessian_filter(img):
    return filters.hessian(img)
示例#27
0
def test_values_decreased():
    a = np.multiply(np.ones((3, 3)), 10)
    assert_equal(frangi(a), np.zeros((3, 3)))
    assert_equal(hessian(a), np.ones((3, 3)))
示例#28
0
def very_abstract():
    from skimage.filters import frangi

    debug = False
    rand_color = randomcolor.RandomColor()

    size_x = 10
    size_y = 10
    upscale_factor = 10
    n_labels = 4
    sigma = 1
    buffer = 0.005
    hsv_index = 1
    segment_spacing = [100, 10]
    image_rgb = np.random.uniform(0, 1, (size_x, size_y, 3))
    labels = np.random.randint(n_labels + 1, size=(
        size_x, size_y)) * np.random.randint(0, 2, size=(size_x, size_y))

    # segment random image
    segments = random_walker(
        image_rgb,
        labels,
        multichannel=True,
        beta=250,
        copy=False,
        spacing=segment_spacing,
    )

    all_colors = np.array(
        rand_color.generate(
            hue="blue",
            # luminosity='bright',
            count=n_labels,
            format_='Array_rgb')) / 256.

    for color_index in np.unique(segments):
        color_hsv = color.rgb2hsv(all_colors[color_index - 1])
        # color_hsv[2] = 0.6 + (color_index - 1) * 0.4 / n_labels
        color_rgb = color.hsv2rgb(color_hsv)
        image_rgb[segments == color_index] = color_rgb

    # transform segmented image so it is large, preserving blobs, and blurry
    image_rgb = rescale(image_rgb,
                        upscale_factor,
                        anti_aliasing=False,
                        multichannel=True)
    image_rgb = gaussian(image_rgb, sigma=sigma, multichannel=True)
    image_hsv = color.rgb2hsv(image_rgb)
    if debug:
        plt.figure()
        plt.imshow(image_rgb)
        plt.show()

    for pix_frac in [0.9]:
        total_pixels_switched = int(image_rgb.shape[0] * image_rgb.shape[0] *
                                    pix_frac)
        print(total_pixels_switched)
        for _ in range(total_pixels_switched):
            rand_x, rand_y = np.random.choice(
                image_hsv.shape[0]), np.random.choice(image_hsv.shape[1])
            orig_rgb = image_rgb[rand_x, rand_y]
            rand_value = image_hsv[rand_x, rand_y, hsv_index]

            x, y = np.where((rand_value *
                             (1 + 0.5 * buffer) >= image_hsv[:, :, hsv_index])
                            & (rand_value *
                               (1 - 2 * buffer) < image_hsv[:, :, hsv_index]))
            if len(x) == 0:
                continue
            idx = np.random.choice(len(x))
            update_rgb = image_rgb[x[idx], y[idx]]

            image_rgb[x[idx], y[idx]] = orig_rgb
            image_rgb[rand_x, rand_y] = update_rgb

        if debug:
            plt.figure()
            plt.title(pix_frac)
            plt.imshow(image_rgb)
            plt.show()

    if debug:
        plt.figure()
        plt.imshow(image_rgb)
        plt.show()

    # filtered_img = prewitt_v(color.rgb2hsv(image_rgb)[:, :, 0])
    # filtered_img = meijering(color.rgb2hsv(image_rgb)[:, :, 0])
    # filtered_img = sato(color.rgb2hsv(image_rgb)[:, :, 0])

    # filtered_details = frangi(color.rgb2hsv(image_rgb)[:, :, 0],
    #                       sigmas=range(3, 8, 10),
    #                       black_ridges=True,
    #                       beta=0.1,
    #                       )

    filtered_img = frangi(
        color.rgb2hsv(image_rgb)[:, :, 0],
        sigmas=range(3, 8, 10),
        black_ridges=False,
        # beta=0.1,
    )

    from skimage.filters.rank import median
    from skimage.morphology import disk, ball

    filtered_img = median(filtered_img / np.max(filtered_img), disk(10))

    filtered_img = filtered_img
    filtered_img = (filtered_img + np.abs(np.min(filtered_img))
                    ) / np.max(filtered_img + np.abs(np.min(filtered_img)))
    filtered_img += 0.8

    if debug:
        plt.figure()
        plt.imshow(filtered_img, cmap='gray')
        plt.colorbar()
        plt.show()

    num_erosions = 5
    eroded_image = hessian(color.rgb2hsv(image_rgb)[:, :, 0])
    eroded_aug = np.zeros_like(eroded_image)
    for n in range(num_erosions):
        eroded_aug += 1 * eroded_image
        eroded_image = erosion(eroded_image)

    if debug:
        plt.figure()
        plt.imshow(image_rgb)
        plt.show()

    image_hsv = color.rgb2hsv(image_rgb)
    image_hsv[:, :, 2] *= filtered_img
    image_hsv[:, :, 2] *= 1 - (0.8 * eroded_aug / np.max(eroded_aug))
    image_rgb_shadow_aug = color.hsv2rgb(image_hsv)
    plt.figure()
    plt.imshow(image_rgb_shadow_aug)
    plt.show()
示例#29
0
 def apply_helper(self, data):
     return filters.hessian(data, sigmas=self.sigmas)
示例#30
0
Frangi filter
=============

The Frangi and hybrid Hessian filters can be used to detect continuous
edges, such as vessels, wrinkles, and rivers.
"""

from skimage.data import camera
from skimage.filters import frangi, hessian

import matplotlib.pyplot as plt

image = camera()

fig, ax = plt.subplots(ncols=3)

ax[0].imshow(image, cmap=plt.cm.gray)
ax[0].set_title('Original image')

ax[1].imshow(frangi(image), cmap=plt.cm.gray)
ax[1].set_title('Frangi filter result')

ax[2].imshow(hessian(image), cmap=plt.cm.gray)
ax[2].set_title('Hybrid Hessian filter result')

for a in ax:
    a.axis('off')

plt.tight_layout()
plt.show()
示例#31
0
def test_null_matrix():
    a = np.zeros((3, 3))
    assert_almost_equal(frangi(a), np.zeros((3, 3)))
    assert_almost_equal(frangi(a, black_ridges=False), np.zeros((3, 3)))
    assert_equal(hessian(a), np.ones((3, 3)))
示例#32
0
# # visualize pickle
# with open('../data/DSA_pkl/' + '30131' + '.pickle', 'rb') as handle:
#     data = pickle.load(handle)
# image_dict = data['image_dict']
# for key in image_dict.keys():
#     print(key)
# image = image_dict[key][:,:,4]
# print(image.shape)

rescaled_image = rescale(image, 1.5, anti_aliasing=True)
print(image.shape, rescaled_image.shape)

fig, ax = plt.subplots(ncols=4)

ax[0].imshow(image, cmap=plt.cm.gray)
ax[0].set_title('Original image')

ax[1].imshow(frangi(image), cmap=plt.cm.gray)
ax[1].set_title('Frangi filter result')

ax[2].imshow(hessian(image, (1, 5), 1), cmap=plt.cm.gray)
ax[2].set_title('Hybrid Hessian filter result')

ax[3].imshow(rescaled_image[:128, :128], cmap=plt.cm.gray)
ax[3].set_title('')

for a in ax:
    a.axis('off')

plt.tight_layout()
plt.show()
#img_fr = myremoveBoundary( img_fr, mask_inv, dilateSize )
#mysaveImg( img_fr, imagePathSave+'frangi_low' + str(scaleLow) + "_high" + str(scaleHigh) + "_step" + str(scaleStep) + "_beta1" + str(beta1) +  '.tif')

normFrangi = cv2.convertScaleAbs(img_fr / img_fr.max() * 255)
#mysaveImg( normFrangi, 'frangiNorm_low' + str(scaleLow) + "_high" + str(scaleHigh) + "_step" + str(scaleStep) + "_beta1_" + str(beta1) + "_beta2_" + str(beta2) + '.tif')
ret, FrangiTH = cv2.threshold(normFrangi, ThFrangi, 255, cv2.THRESH_BINARY)
#mysaveImg( FrangiTH, imagePathSave+'frangiTh_low' + str(scaleLow) + "_high" + str(scaleHigh) + "_step" + str(scaleStep) + "_beta1_" + str(beta1) + "_beta2_" + str(beta2) + '.tif')

im_BP = myBPfilter(img_mask, BPkersize)
#im_BP = myremoveBoundary( im_BP, mask_inv, dilateSize )
ret, BPTH = cv2.threshold(im_BP, ThBP, 255, cv2.THRESH_BINARY)
#mysaveImg( BPTH, imagePathSave+'BPTh_ksize' + str(BPkersize) + '_Th' + str(ThBP) +'.tif' )

start_time1 = time.time()
img_hs = hessian(img_mask,
                 scale_range=(scaleLow, scaleHigh),
                 scale_step=scaleStep,
                 beta1=beta1)
print(time.time() - start_time1)

im_BP = numpy.where(im_BP > 0, 1, 0)
img_fr = numpy.where(img_fr > 0.6, 1, 0)

plt.subplot(1, 3, 1), plt.imshow(img_mask, "gray"), plt.title('img-mask')
plt.xticks([]), plt.yticks([])
plt.subplot(1, 3, 2), plt.imshow(img_fr, "gray"), plt.title('frangi')
plt.xticks([]), plt.yticks([])
plt.subplot(1, 3, 3), plt.imshow(im_BP, "gray"), plt.title('bandpass')
plt.xticks([]), plt.yticks([])
plt.show()
示例#34
0
def mountains_series():
    def format_axes(fig):
        for i, ax in enumerate(fig.axes):
            ax.tick_params(labelbottom=False,
                           labelleft=False,
                           bottom=False,
                           left=False)

    fig = plt.figure(constrained_layout=False, frameon=False)
    ax = fig.add_axes([0, 0, 1, 1])
    ax.set_facecolor((0.88, 0.87, 0.9))

    gs = GridSpec(3, 3, figure=fig, wspace=0, hspace=0.05)
    axes = []
    axes.append(fig.add_subplot(gs[0, :]))
    axes.append(fig.add_subplot(gs[1, :-1]))
    axes.append(fig.add_subplot(gs[1:, -1]))
    axes.append(fig.add_subplot(gs[-1, 0]))
    axes.append(fig.add_subplot(gs[-1, -2]))
    # sizes_y = [15, 10, 5, 5, 5]
    # sizes_x = [5, 5, 10, 5, 5]

    sizes_y = [20, 12, 5, 5, 5]
    sizes_x = [5, 5, 10, 5, 5]

    for i in range(5):
        debug = False
        rand_color = randomcolor.RandomColor()

        size_x = sizes_x[i]
        size_y = sizes_y[i]
        upscale_factor = 10
        n_labels = 5
        sigma = 1
        buffer = 0.005
        hsv_index = 1
        segment_spacing = [10, 10]
        image_rgb = np.random.uniform(0, 1, (size_x, size_y, 3))
        labels = np.random.randint(n_labels + 1, size=(
            size_x, size_y)) * np.random.randint(0, 2, size=(size_x, size_y))

        # segment random image
        segments = random_walker(
            image_rgb,
            labels,
            multichannel=True,
            beta=250,
            copy=False,
            spacing=segment_spacing,
        )

        all_colors = np.array(
            rand_color.generate(
                hue="purple",
                # luminosity='bright',
                count=n_labels,
                format_='Array_rgb')) / 256.

        for color_index in np.unique(segments):
            color_hsv = color.rgb2hsv(all_colors[color_index - 1])
            # color_hsv[2] = 0.6 + (color_index - 1) * 0.4 / n_labels
            color_rgb = color.hsv2rgb(color_hsv)
            image_rgb[segments == color_index] = color_rgb

        # transform segmented image so it is large, preserving blobs, and blurry
        image_rgb = rescale(image_rgb,
                            upscale_factor,
                            anti_aliasing=False,
                            multichannel=True)
        image_rgb = gaussian(image_rgb, sigma=sigma, multichannel=True)
        image_hsv = color.rgb2hsv(image_rgb)
        if debug:
            plt.figure()
            plt.imshow(image_rgb)
            plt.show()

        for pix_frac in [0.9]:
            total_pixels_switched = int(image_rgb.shape[0] *
                                        image_rgb.shape[0] * pix_frac)
            print(total_pixels_switched)
            for _ in range(total_pixels_switched):
                rand_x, rand_y = np.random.choice(
                    image_hsv.shape[0]), np.random.choice(image_hsv.shape[1])
                orig_rgb = image_rgb[rand_x, rand_y]
                rand_value = image_hsv[rand_x, rand_y, hsv_index]

                x, y = np.where(
                    (rand_value *
                     (1 + 0.5 * buffer) >= image_hsv[:, :, hsv_index])
                    & (rand_value *
                       (1 - 2 * buffer) < image_hsv[:, :, hsv_index]))
                if len(x) == 0:
                    continue
                idx = np.random.choice(len(x))
                update_rgb = image_rgb[x[idx], y[idx]]

                image_rgb[x[idx], y[idx]] = orig_rgb
                image_rgb[rand_x, rand_y] = update_rgb

            if debug:
                plt.figure()
                plt.title(pix_frac)
                plt.imshow(image_rgb)
                plt.show()

        if debug:
            plt.figure()
            plt.imshow(image_rgb)
            plt.show()

        # filtered_img = prewitt_v(color.rgb2hsv(image_rgb)[:, :, 0])
        # filtered_img = meijering(color.rgb2hsv(image_rgb)[:, :, 0])
        # filtered_img = sato(color.rgb2hsv(image_rgb)[:, :, 0])

        # filtered_details = frangi(color.rgb2hsv(image_rgb)[:, :, 0],
        #                       sigmas=range(3, 8, 10),
        #                       black_ridges=True,
        #                       beta=0.1,
        #                       )

        filtered_img = frangi(
            color.rgb2hsv(image_rgb)[:, :, 0],
            sigmas=range(3, 8, 10),
            black_ridges=True,
            # beta=0.1,
        )

        from skimage.filters.rank import median
        from skimage.morphology import disk, ball

        filtered_img = median(filtered_img / np.max(filtered_img), disk(10))

        filtered_img = filtered_img
        filtered_img = 1.5 * (filtered_img + np.abs(
            np.min(filtered_img))) / np.max(filtered_img +
                                            np.abs(np.min(filtered_img)))
        filtered_img += 0.6

        if debug:
            plt.figure()
            plt.imshow(filtered_img, cmap='gray')
            plt.colorbar()
            plt.show()

        num_erosions = 5
        eroded_image = hessian(color.rgb2hsv(image_rgb)[:, :, 0])
        eroded_aug = np.zeros_like(eroded_image)
        for n in range(num_erosions):
            eroded_aug += 1 * eroded_image
            eroded_image = erosion(eroded_image)

        if debug:
            plt.figure()
            plt.imshow(image_rgb)
            plt.show()

        image_hsv = color.rgb2hsv(image_rgb)
        image_hsv[:, :, 2] *= filtered_img
        image_hsv[:, :, 2] *= 1 - (0.8 * eroded_aug / np.max(eroded_aug))
        image_rgb_shadow_aug = color.hsv2rgb(image_hsv)
        # plt.figure()
        # plt.imshow(image_rgb_shadow_aug)
        # plt.show()
        axes[i].imshow(image_rgb_shadow_aug)
    format_axes(fig)
    gs.tight_layout(fig, pad=1.2, h_pad=0.5)

    plt.show()
示例#35
0
def test_energy_decrease():
    a = np.zeros((5, 5))
    a[2, 2] = 1.
    assert frangi(a).std() < a.std()
    assert frangi(a, black_ridges=False).std() < a.std()
    assert hessian(a).std() > a.std()