コード例 #1
0
def test_plot_plugin():
    viewer = ImageViewer(data.moon())
    plugin = PlotPlugin(image_filter=lambda x: x)
    viewer += plugin

    assert_equal(viewer.image, data.moon())
    plugin._update_original_image(data.coins())
    assert_equal(viewer.image, data.coins())
    viewer.close()
コード例 #2
0
ファイル: test_tools.py プロジェクト: SiggyF/scikit-image
def test_paint_tool():
    img = data.moon()
    viewer = ImageViewer(img)

    tool = PaintTool(viewer.ax, img.shape)

    tool.radius = 10
    assert_equal(tool.radius, 10)
    tool.label = 2
    assert_equal(tool.label, 2)
    assert_equal(tool.shape, img.shape)

    start = create_mouse_event(viewer.ax, xdata=100, ydata=100)
    tool.on_mouse_press(start)
    move = create_mouse_event(viewer.ax, xdata=110, ydata=110)
    tool.on_move(move)
    tool.on_mouse_release(move)
    assert_equal(tool.overlay[tool.overlay == 2].size, 761)

    tool.label = 5
    start = create_mouse_event(viewer.ax, xdata=20, ydata=20)
    tool.on_mouse_press(start)
    move = create_mouse_event(viewer.ax, xdata=40, ydata=40)
    tool.on_move(move)
    tool.on_mouse_release(move)
    assert_equal(tool.overlay[tool.overlay == 5].size, 881)
    assert_equal(tool.overlay[tool.overlay == 2].size, 761)

    enter = create_mouse_event(viewer.ax, key='enter')
    tool.on_mouse_press(enter)

    tool.overlay = tool.overlay * 0
    assert_equal(tool.overlay.sum(), 0)
コード例 #3
0
ファイル: test_tools.py プロジェクト: AlexG31/scikit-image
def test_paint_tool():
    img = data.moon()
    viewer = ImageViewer(img)

    tool = PaintTool(viewer, img.shape)

    tool.radius = 10
    assert_equal(tool.radius, 10)
    tool.label = 2
    assert_equal(tool.label, 2)
    assert_equal(tool.shape, img.shape)

    do_event(viewer, 'mouse_press', xdata=100, ydata=100)
    do_event(viewer, 'move', xdata=110, ydata=110)
    do_event(viewer, 'mouse_release')

    assert_equal(tool.overlay[tool.overlay == 2].size, 761)

    tool.label = 5
    do_event(viewer, 'mouse_press', xdata=20, ydata=20)
    do_event(viewer, 'move', xdata=40, ydata=40)
    do_event(viewer, 'mouse_release')

    assert_equal(tool.overlay[tool.overlay == 5].size, 881)
    assert_equal(tool.overlay[tool.overlay == 2].size, 761)

    do_event(viewer, 'key_press', key='enter')

    tool.overlay = tool.overlay * 0
    assert_equal(tool.overlay.sum(), 0)
コード例 #4
0
ファイル: testing.py プロジェクト: JeanKossaifi/scikit-image
def mono_check(plugin, fmt='png'):
    """Check the roundtrip behavior for images that support most types.

    All major input types should be handled.
    """

    img = img_as_ubyte(data.moon())
    r1 = roundtrip(img, plugin, fmt)
    testing.assert_allclose(img, r1)

    img2 = img > 128
    r2 = roundtrip(img2, plugin, fmt)
    testing.assert_allclose(img2.astype(np.uint8), r2)

    img3 = img_as_float(img)
    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)
    if fmt.lower() in (('tif', 'tiff')):
        img4 -= 100
        r4 = roundtrip(img4, plugin, fmt)
        testing.assert_allclose(r4, img4)
    else:
        r4 = roundtrip(img4, plugin, fmt)
        testing.assert_allclose(r4, img_as_uint(img4))

    img5 = img_as_uint(img)
    r5 = roundtrip(img5, plugin, fmt)
    testing.assert_allclose(r5, img5)
コード例 #5
0
def main():
    """Load image, apply filters and plot the results."""
    img = data.moon()
    util.plot_images_grayscale(
        [img, median(img), morphological_edge(img),
         erosion(img), dilation(img),
         opening(img), closing(img)],
        ["Image", "Median", "Morphological Edge", "Erosion", "Dilation", "Opening", "Closing"]
    )
コード例 #6
0
def test_isodata_moon_image_negative_float():
    moon = skimage.img_as_ubyte(data.moon()).astype(np.float64)
    moon -= 100

    assert -14 < threshold_isodata(moon) < -13

    thresholds = threshold_isodata(moon, return_all=True)
    assert_almost_equal(thresholds,
                        [-13.83789062, -12.84179688, -11.84570312, 22.02148438,
                         23.01757812, 24.01367188, 38.95507812, 39.95117188])
コード例 #7
0
def test_isodata_moon_image():
    moon = skimage.img_as_ubyte(data.moon())

    threshold = threshold_isodata(moon)
    assert np.floor((moon[moon <= threshold].mean() + moon[moon > threshold].mean()) / 2.0) == threshold
    assert threshold == 86

    thresholds = threshold_isodata(moon, return_all=True)
    for threshold in thresholds:
        assert np.floor((moon[moon <= threshold].mean() + moon[moon > threshold].mean()) / 2.0) == threshold
    assert_equal(thresholds, [86, 87, 88, 122, 123, 124, 139, 140])
コード例 #8
0
def test_isodata_moon_image_negative_int():
    moon = skimage.img_as_ubyte(data.moon()).astype(np.int32)
    moon -= 100

    threshold = threshold_isodata(moon)
    assert np.floor((moon[moon <= threshold].mean() + moon[moon > threshold].mean()) / 2.0) == threshold
    assert threshold == -14

    thresholds = threshold_isodata(moon, return_all=True)
    for threshold in thresholds:
        assert np.floor((moon[moon <= threshold].mean() + moon[moon > threshold].mean()) / 2.0) == threshold
    assert_equal(thresholds, [-14, -13, -12, 22, 23, 24, 39, 40])
コード例 #9
0
def test_adapthist_scalar():
    """Test a scalar uint8 image
    """
    img = skimage.img_as_ubyte(data.moon())
    adapted = exposure.equalize_adapthist(img, kernel_size=64, clip_limit=0.02)
    assert adapted.min() == 0.0
    assert adapted.max() == 1.0
    assert img.shape == adapted.shape
    full_scale = skimage.exposure.rescale_intensity(skimage.img_as_float(img))

    assert_almost_equal(peak_snr(full_scale, adapted), 102.066, 3)
    assert_almost_equal(norm_brightness_err(full_scale, adapted),
                        0.038, 3)
コード例 #10
0
def test_adapthist_scalar():
    '''Test a scalar uint8 image
    '''
    img = skimage.img_as_ubyte(data.moon())
    adapted = exposure.equalize_adapthist(img, clip_limit=0.02)
    assert adapted.min() == 0
    assert adapted.max() == (1 << 16) - 1
    assert img.shape == adapted.shape
    full_scale = skimage.exposure.rescale_intensity(skimage.img_as_uint(img))
    assert_almost_equal = np.testing.assert_almost_equal
    assert_almost_equal(peak_snr(full_scale, adapted), 101.231, 3)
    assert_almost_equal(norm_brightness_err(full_scale, adapted),
                        0.041, 3)
    return img, adapted
コード例 #11
0
def test_base_tool():
    img = data.moon()
    viewer = ImageViewer(img)

    tool = CanvasToolBase(viewer)
    tool.set_visible(False)
    tool.set_visible(True)

    do_event(viewer, 'key_press', key='enter')

    tool.redraw()
    tool.remove()

    tool = CanvasToolBase(viewer, useblit=False)
    tool.redraw()
コード例 #12
0
def test_label_painter():
    image = data.camera()
    moon = data.moon()
    viewer = ImageViewer(image)
    lp = LabelPainter()
    viewer += lp

    assert_equal(lp.radius, 5)
    lp.label = 1
    assert_equal(str(lp.label), '1')
    lp.label = 2
    assert_equal(str(lp.paint_tool.label), '2')
    assert_equal(lp.paint_tool.radius, 5)
    lp._on_new_image(moon)
    assert_equal(lp.paint_tool.shape, moon.shape)
コード例 #13
0
ファイル: test_tools.py プロジェクト: SiggyF/scikit-image
def test_base_tool():
    img = data.moon()
    viewer = ImageViewer(img)

    tool = CanvasToolBase(viewer.ax)
    tool.set_visible(False)
    tool.set_visible(True)

    enter = create_mouse_event(viewer.ax, key='enter')
    tool._on_key_press(enter)

    tool.redraw()
    tool.remove()

    tool = CanvasToolBase(viewer.ax, useblit=False)
    tool.redraw()
コード例 #14
0
def test_keypoints_censure_moon_image_octagon():
    """Verify the actual Censure keypoints and their corresponding scale with
    the expected values for Octagon filter."""
    img = moon()
    actual_kp_octagon, actual_scale = keypoints_censure(img, 1, 7, 'Octagon',
                                                        0.15)
    expected_kp_octagon = np.array([[ 21, 496],
                                    [ 35,  46],
                                    [287, 250],
                                    [356, 239],
                                    [463, 116]])

    expected_scale = np.array([3, 4, 2, 2, 2])

    assert_array_equal(expected_kp_octagon, actual_kp_octagon)
    assert_array_equal(expected_scale, actual_scale)
コード例 #15
0
def test_keypoints_censure_moon_image_dob():
    """Verify the actual Censure keypoints and their corresponding scale with
    the expected values for DoB filter."""
    img = moon()
    actual_kp_dob, actual_scale = keypoints_censure(img, 1, 7, 'DoB', 0.15)
    expected_kp_dob = np.array([[ 21, 497],
                                [ 36,  46],
                                [119, 350],
                                [185, 177],
                                [287, 250],
                                [357, 239],
                                [463, 116],
                                [464, 132],
                                [467, 260]])
    expected_scale = np.array([3, 4, 4, 2, 2, 3, 2, 2, 2])

    assert_array_equal(expected_kp_dob, actual_kp_dob)
    assert_array_equal(expected_scale, actual_scale)
コード例 #16
0
def test_keypoints_censure_moon_image_star():
    """Verify the actual Censure keypoints and their corresponding scale with
    the expected values for STAR filter."""
    img = moon()
    actual_kp_star, actual_scale = keypoints_censure(img, 1, 7, 'STAR', 0.15)
    expected_kp_star = np.array([[ 21, 497],
                                 [ 36,  46],
                                 [117, 356],
                                 [185, 177],
                                 [260, 227],
                                 [287, 250],
                                 [357, 239],
                                 [451, 281],
                                 [463, 116],
                                 [467, 260]])

    expected_scale = np.array([3, 3, 6, 2, 3, 2, 3, 5, 2, 2])

    assert_array_equal(expected_kp_star, actual_kp_star)
    assert_array_equal(expected_scale, actual_scale)
コード例 #17
0
def test_plugin():
    img = skimage.img_as_float(data.moon())
    viewer = ImageViewer(img)

    def median_filter(img, radius=3):
        return median(img, selem=disk(radius=radius))

    plugin = Plugin(image_filter=median_filter)
    viewer += plugin

    plugin += Slider('radius', 1, 5)

    assert_almost_equal(np.std(viewer.image), 12.556, 3)

    plugin.filter_image()

    assert_almost_equal(np.std(viewer.image), 12.931, 3)

    plugin.show()
    plugin.close()
    plugin.clean_up()
    img, _ = plugin.output()
    assert_equal(img, viewer.image)
コード例 #18
0
        return UnitMap()
    
    def _plot_data_default(self):
        return ArrayPlotData(
            image=self.image_data,
        )
    
    def _plot_default(self):
        plot = Plot(self.plot_data)
        plot.x_axis = None
        plot.y_axis = None
        plot.padding = 0
        self.tcm = TransformColorMapper.from_color_map(gray)
        self.tcm.unit_func = self.unit_map.function
        self.unit_map.on_trait_change(self.map_changed, 'function')
        plot.img_plot('image', colormap=self.tcm)
        return plot
    
    view = View(
        VGroup(
            Item('plot', editor=ComponentEditor(), springy=True),
            Item('histogram_view', editor=InstanceEditor(), style='custom'),
            show_labels=False
        ),
        resizable=True
    )

if __name__ == '__main__':
    image_view = ImageView(image_data=moon())
    image_view.configure_traits()
コード例 #19
0
    ax_hist.hist(image.ravel(), bins=bins, histtype='step', color='black')
    ax_hist.ticklabel_format(axis='y', style='scientific', scilimits=(0, 0))
    ax_hist.set_xlabel('Pixel intensity')
    ax_hist.set_xlim(0, 1)
    ax_hist.set_yticks([])

    # Display cumulative distribution
    img_cdf, bins = exposure.cumulative_distribution(image, bins)
    ax_cdf.plot(bins, img_cdf, 'r')
    ax_cdf.set_yticks([])

    return ax_img, ax_hist, ax_cdf


# Load an example image
img = data.moon()

# Contrast stretching
p2, p98 = np.percentile(img, (2, 98))
img_rescale = exposure.rescale_intensity(img, in_range=(p2, p98))

# Equalization
img_eq = exposure.equalize_hist(img)

# Adaptive Equalization
img_adapteq = exposure.equalize_adapthist(img, clip_limit=0.03)

# Display results
fig = plt.figure(figsize=(8, 5))
axes = np.zeros((2, 4), dtype=np.object)
axes[0, 0] = fig.add_subplot(2, 4, 1)
コード例 #20
0
import os
import tensorflow as tf
import numpy as np
import time
import matplotlib.pyplot as plt

from skimage import data as dataExamples
import time
import matplotlib.pyplot as plt

print(dataExamples.moon().shape, dataExamples.camera().shape)
IN_IMGS = np.stack([dataExamples.moon(), dataExamples.camera()])
imgs_size = IN_IMGS[0].shape[1]
print(IN_IMGS.shape)


def correctScale(imgsRaw):
    for i in range(imgsRaw.shape[0]):
        imgsRaw[i] = imgsRaw[i] - np.min(
            imgsRaw[i]) / (np.max(imgsRaw[i]) - np.min(imgsRaw[i]))
    return imgsRaw


IN_IMGS = correctScale(IN_IMGS)
IN_IMGS = IN_IMGS.astype(np.complex64)

#NUMPY VERSION


def npLPFilter(imgs_in):
    stime = time.time()
コード例 #21
0
image represent the maximum and minimum possible values of the reconstructed
image.

We start with an image containing both peaks and holes:

"""
import matplotlib.pyplot as plt
import time
from skimage import io
from skimage import data
from skimage.exposure import rescale_intensity
import Image

t1 = time.time()

image = data.moon()
#image = io.imread("stone.jpg")
# Rescale image intensity so that we can see dim features.
image = rescale_intensity(image, in_range=(50, 200))


# convenience function for plotting images
def imshow(image, **kwargs):
    plt.figure(figsize=(5, 4))
    plt.imshow(image, **kwargs)
    plt.axis('off')


#imshow(image)
#plt.title('original image')
"""
コード例 #22
0
def test_adapthist_ntiles_raises():
    img = skimage.img_as_ubyte(data.moon())
    assert_raises(ValueError, exposure.equalize_adapthist, img, ntiles_x=8)
    assert_raises(ValueError, exposure.equalize_adapthist, img, ntiles_y=8)
    assert_raises(ValueError, exposure.equalize_adapthist, img,
                  ntiles_x=8, ntiles_y=8)
コード例 #23
0
from skimage import data
import napari

##### color maps
# PiYG
# blue
# cyan
# gist_earth
# gray
# green
# hsv
# inferno
# magma
# magenta
# plasma
# red
# turbo
# twilight
# twilight_shifted
# yellow
# viridis

with napari.gui_qt():
    # assigning a color map to a gray image
    # the min and max value of the gray image are mapped to the
    # color map's bounds
    viewer = napari.view_image(data.moon(), colormap='viridis')
コード例 #24
0
ファイル: moon.py プロジェクト: obulpathi/CubeSatCloud
import matplotlib.pyplot as plt

from skimage import data
from skimage.exposure import rescale_intensity

import time

t1 = time.time()
image = data.moon()
# Rescale image intensity so that we can see dim features.
image = rescale_intensity(image, in_range=(50, 200))

t2 = time.time()
print (t2-t1)

# convenience function for plotting images
def imshow(image, **kwargs):
    plt.figure(figsize=(5, 4))
    plt.imshow(image, **kwargs)
    plt.axis('off')

#imshow(image)
#plt.title('original image')
コード例 #25
0
'''
1、gamma调整
原理:I=Ig

对原图像的像素,进行幂运算,得到新的像素值。公式中的g就是gamma值。
如果gamma>1, 新图像比原图像暗
如果gamma<1,新图像比原图像亮
函数格式为:
'''

from skimage import data, exposure, img_as_float
import matplotlib.pyplot as plt

image = img_as_float(data.moon())
gam1 = exposure.adjust_gamma(image, 2)  #调暗
gam2 = exposure.adjust_gamma(image,
                             0.5)  #调亮plt.figure('adjust_gamma',figsize=(8,8))

plt.subplot(131)
plt.title('origin image')
plt.imshow(image, plt.cm.gray)
plt.axis('off')
plt.subplot(132)
plt.title('gamma=2')
plt.imshow(gam1, plt.cm.gray)
plt.axis('off')
plt.subplot(133)
plt.title('gamma=0.5')
plt.imshow(gam2, plt.cm.gray)
plt.axis('off')
plt.show()
コード例 #26
0
    # grab a corner and move it
    do_event(viewer, 'mouse_press', xdata=100, ydata=100)
    do_event(viewer, 'move', xdata=120, ydata=120)
    do_event(viewer, 'mouse_release')
    # assert_equal(tool.geometry, [120, 150, 120, 150])

    # create a new line
    do_event(viewer, 'mouse_press', xdata=10, ydata=10)
    do_event(viewer, 'move', xdata=100, ydata=100)
    do_event(viewer, 'mouse_release')
    assert_equal(tool.geometry, [10, 100,  10, 100])


@cleanup
@pytest.mark.skipif(not has_qt, reason="Qt not installed")
@pytest.mark.parametrize('img', [data.moon(), data.astronaut()])
def test_paint_tool(img):
    viewer = ImageViewer(img)

    tool = PaintTool(viewer, img.shape)

    tool.radius = 10
    assert_equal(tool.radius, 10)
    tool.label = 2
    assert_equal(tool.label, 2)
    assert_equal(tool.shape, img.shape[:2])

    do_event(viewer, 'mouse_press', xdata=100, ydata=100)
    do_event(viewer, 'move', xdata=110, ydata=110)
    do_event(viewer, 'mouse_release')
コード例 #27
0
def test_isodata_moon_image_negative_int():
    moon = skimage.img_as_ubyte(data.moon()).astype(np.int32)
    moon -= 100
    assert threshold_isodata(moon) == -13
コード例 #28
0
def test_isodata_moon_image():
    moon = skimage.img_as_ubyte(data.moon())
    assert threshold_isodata(moon) == 87
コード例 #29
0
ファイル: transport_optimal.py プロジェクト: lgarcin/TIPE
from skimage.data import camera, moon
from skimage.exposure import cumulative_distribution, equalize_hist
from skimage.io import imshow, show
from numpy import vectorize

im_camera = camera()
im_moon = moon()
dist_camera, bins = cumulative_distribution(im_camera)
dist_moon, bins = cumulative_distribution(im_moon)


# def rechercher_transformation(dist_source, dist_target):
#     nb_source = len(dist_source)
#     nb_target = len(dist_target)
#     transformation = [nb_source - 1] * nb_source
#     i, j = 0, 0
#     while j < nb_target:
#         while i < nb_source and dist_source[i] < dist_target[j]:
#             transformation[i] = j
#             i += 1
#         j += 1
#     return transformation


def rechercher_transformation(dist_source, dist_target):
    nb_source = len(dist_source)
    nb_target = len(dist_target)
    transformation = [nb_source - 1] * nb_source
    i, j = 0, 0
    ind0, val0 = 0, 0
    while j < nb_target:
コード例 #30
0
import numpy as np
from numpy.testing import assert_array_equal, assert_raises
from skimage.data import moon
from skimage.feature import CENSURE

img = moon()
np.random.seed(0)


def test_censure_on_rectangular_images():
    """Censure feature detector should work on 2D image of any shape."""
    rect_image = np.random.rand(300, 200)
    square_image = np.random.rand(200, 200)
    CENSURE().detect((square_image))
    CENSURE().detect((rect_image))


def test_keypoints_censure_color_image_unsupported_error():
    """Censure keypoints can be extracted from gray-scale images only."""
    assert_raises(ValueError, CENSURE().detect, np.zeros((20, 20, 3)))


def test_keypoints_censure_mode_validity_error():
    """Mode argument in keypoints_censure can be either DoB, Octagon or
    STAR."""
    assert_raises(ValueError, CENSURE, mode='dummy')


def test_keypoints_censure_scale_range_error():
    """Difference between the the max_scale and min_scale parameters in
    keypoints_censure should be greater than or equal to two."""
コード例 #31
0
 def setup(self):
     self.image = img_as_float(data.moon())
     self.image = rescale(self.image, 2.0, anti_aliasing=False)
コード例 #32
0
ファイル: skimage_test.py プロジェクト: Derryxd/CodeSet
composite_image = np.ones((rows, int(cols + cols/2), 3), dtype=np.double)  #生成背景
composite_image[:rows, :cols, :] = pyramid[0]  #融合原始图像
i_row = 0
for p in pyramid[1:]:
    n_rows, n_cols = p.shape[:2]
    composite_image[i_row:i_row + n_rows, cols:cols + n_cols] = p  #循环融合9幅金字塔图像
    i_row += n_rows
plt.figure('pyramid')
plt.imshow(composite_image)
plt.show()
#除了高斯金字塔,还有其他种类的金字塔,如pyramid_laplacian
# =============================================================================
print('''六、对比度与亮度调整''')
# =============================================================================
'''1、gamma调整:I=I**g'''
image = ski.img_as_float(data.moon())
gam1= exposure.adjust_gamma(image, 2)   #调暗
gam2= exposure.adjust_gamma(image, 0.5)  #调亮
plt.figure('adjust_gamma',figsize=(8,8))
plt.subplot(131)
plt.title('origin image')
plt.imshow(image,plt.cm.gray)
plt.axis('off')
plt.subplot(132)
plt.title('gamma=2')
plt.imshow(gam1,plt.cm.gray)
plt.axis('off')
plt.subplot(133)
plt.title('gamma=0.5')
plt.imshow(gam2,plt.cm.gray)
plt.axis('off')
コード例 #33
0
"""
Display multiple image layers using the add_image API and then reorder them
using the layers swap method and remove one
"""

from skimage import data
from skimage.color import rgb2gray
from napari import ViewerApp
from napari.util import app_context


with app_context():
    # create the viewer with several image layers
    viewer = ViewerApp(astronaut=rgb2gray(data.astronaut()),
                       photographer=data.camera(),
                       coins=data.coins(),
                       moon=data.moon())

    # remove the coins layer
    viewer.layers.remove('coins')

    # swap the order of astronaut and moon
    viewer.layers['astronaut', 'moon'] = viewer.layers['moon', 'astronaut']
コード例 #34
0
def test_moon():
    """ Test that "moon" image can be loaded. """
    data.moon()
コード例 #35
0
ファイル: test_data.py プロジェクト: Gildus/scikit-image
def test_moon():
    """ Test that "moon" image can be loaded. """
    data.moon()
コード例 #36
0
 def setup(self):
     self.image = img_as_float(data.moon())
     self.image = rescale(self.image, 2.0, anti_aliasing=False)
     # for Contrast stretching
     self.p2, self.p98 = np.percentile(self.image, (2, 98))
コード例 #37
0
import numpy as np
from skimage import exposure, data


def plot_img_hist(img, img_name='', bins=256):
    '''plot image and its histogram'''
    plt.figure(img_name)
    plt.subplot(1, 2, 1)
    plt.imshow(img, cmap='gray')
    plt.subplot(1, 2, 2)
    plt.hist(img.ravel(), bins)
    plt.show


# Main procedure
img_moon = data.moon()  # Load data

# Low contrast image
plot_img_hist(img_moon, 'Low contrast image')

# Contrast stretching
p1, p2 = np.percentile(img_moon, (2, 98))
img_moon_ctrststre = exposure.rescale_intensity(img_moon, in_range=(p1, p2))
plot_img_hist(img_moon_ctrststre, 'Contrast stretching')

# Histogram equalization
img_moon_eqhist = exposure.equalize_hist(img_moon)
plot_img_hist(img_moon_eqhist, 'Histogram equalization')

# Adaptive Equalization
img_moon_adapteq = exposure.equalize_adapthist(img_moon, clip_limit=0.03)
コード例 #38
0
ファイル: test.py プロジェクト: zac-oar-uq/PatternFlow
    ax_img, ax_hist, ax_cdf = plot_img_and_hist(actual, axes[:, 2])
    ax_img.set_title('Tensorflow CLAHE')

    ax_cdf.set_ylabel('Fraction of total intensity')
    ax_cdf.set_yticks(np.linspace(0, 1, 5))

    # prevent overlap of y-axis labels
    fig.tight_layout()


def compare(expected, actual):
    return (expected == actual).all()


# Load an image to use for testing
test_image = data.moon()
expected_result = exposure.equalize_adapthist(test_image, clip_limit=0.03)

#plot_comparison(test_image, expected_result, expected_result)
print(compare(expected_result, expected_result))
#plt.show()
import equalize_adapthist

a, b = equalize_adapthist.histogram(test_image)

equalize_adapthist.tfhist(test_image)
print(a)
print(b)

# get equalization
コード例 #39
0
    ax_hist.hist(img.ravel(), bins=bins, histtype='step', color='black')
    ax_hist.ticklabel_format(axis='y', style='scientific', scilimits=(0, 0))
    ax_hist.set_xlabel('Pixel intensity')
    ax_hist.set_xlim(0, 1)
    ax_hist.set_yticks([])

    # Display cumulative distribution
    img_cdf, bins = exposure.cumulative_distribution(img, bins)
    ax_cdf.plot(bins, img_cdf, 'r')
    ax_cdf.set_yticks([])

    return ax_img, ax_hist, ax_cdf


# Load an example image
img = data.moon()

# Contrast stretching
p2, p98 = np.percentile(img, (2, 98))
img_rescale = exposure.rescale_intensity(img, in_range=(p2, p98))

# Equalization
img_eq = exposure.equalize_hist(img)

# Adaptive Equalization
img_adapteq = exposure.equalize_adapthist(img, clip_limit=0.03)

# Display results
fig = plt.figure(figsize=(8, 5))
axes = np.zeros((2,4), dtype=np.object)
axes[0,0] = fig.add_subplot(2, 4, 1)
    ax_hist.hist(image.ravel(), bins=bins)
    ax_hist.ticklabel_format(axis='y', style='scientific', scilimits=(0, 0))
    ax_hist.set_xlabel('Pixel intensity')

    xmin, xmax = dtype_range[image.dtype.type]
    ax_hist.set_xlim(xmin, xmax)

    # Display cumulative distribution
    img_cdf, bins = exposure.cumulative_distribution(image, bins)
    ax_cdf.plot(bins, img_cdf, 'r')

    return ax_img, ax_hist, ax_cdf


# Load an example image
img = img_as_ubyte(data.moon())

# Global equalize
img_rescale = exposure.equalize_hist(img)

# Equalization
selem = disk(30)
img_eq = rank.equalize(img, selem=selem)

# Display results
fig = plt.figure(figsize=(8, 5))
axes = np.zeros((2, 3), dtype=np.object)
axes[0, 0] = plt.subplot(2, 3, 1)
axes[0, 1] = plt.subplot(2, 3, 2, sharex=axes[0, 0], sharey=axes[0, 0])
axes[0, 2] = plt.subplot(2, 3, 3, sharex=axes[0, 0], sharey=axes[0, 0])
axes[1, 0] = plt.subplot(2, 3, 4)
コード例 #41
0
    # grab a corner and move it
    do_event(viewer, 'mouse_press', xdata=100, ydata=100)
    do_event(viewer, 'move', xdata=120, ydata=120)
    do_event(viewer, 'mouse_release')
    # assert_equal(tool.geometry, [120, 150, 120, 150])

    # create a new line
    do_event(viewer, 'mouse_press', xdata=10, ydata=10)
    do_event(viewer, 'move', xdata=100, ydata=100)
    do_event(viewer, 'mouse_release')
    assert_equal(tool.geometry, [10, 100,  10, 100])


@cleanup
@testing.skipif(not has_qt, reason="Qt not installed")
@parametrize('img', [data.moon(), data.astronaut()])
def test_paint_tool(img):
    viewer = ImageViewer(img)

    tool = PaintTool(viewer, img.shape)

    tool.radius = 10
    assert_equal(tool.radius, 10)
    tool.label = 2
    assert_equal(tool.label, 2)
    assert_equal(tool.shape, img.shape[:2])

    do_event(viewer, 'mouse_press', xdata=100, ydata=100)
    do_event(viewer, 'move', xdata=110, ydata=110)
    do_event(viewer, 'mouse_release')
コード例 #42
0
ファイル: vision_fixed.py プロジェクト: VisIR/VisionCode
def find_bounding_box(Array):
	a = np.zeros(4).reshape((2,2))
	a[0] = Array[0]
	for x in range(0, array.shape[0]): 
		if(a[0][0] > array[x][0]):
			a[0][0] = array[x][0]

		if(a[0][1] > array[x][1]):
			a[0][1] = array[x][1]

		if(a[1][0] < array[x][0]):
			a[1][0] = array[x][0]

		elif(a[1][1] < array[x][1]):
			a[1][1] = array[x][1]
	return a

def fault_detector(image):
	fault_sercher = image_search()
	bounding_box = find_bounding_box(fault_sercher)
	bound_image = image_cut(image,bounding_box[0][0],bounding_box[0][1],(bounding_box[1][0] - bounding_box[0][0]), (bounding_box[1][1]-bounding_box[0][1]))
	
	return bound_image

#===============================================================================
#MAIN PROGRAM
#test_image = data.load("/home/lapowell/Downloads/asteroids.jpg")
image1 = data.moon()
l = image_search(image1,78)
print l
コード例 #43
0
from skimage import data
import napari

with napari.gui_qt():
    viewer = napari.Viewer()

    # each image is stacked on a layer list (it should be a layer stack =D)
    # we assign a label to each layer so that we can recover it easily later
    viewer.add_image(data.astronaut(), name='astronaut')
    viewer.add_image(data.moon(), name='moon')
    viewer.add_image(data.camera(), name='camera')

    # we can access the layers
    #
    #  viewer.layers[key]
    #
    # key can be the key/label assigned to the layer or
    # an index (integer value)
    #
    # `viewer.layers` has type LayerList, which is a list-like layer collection
    # with built-in reordering and callback hooks.

    # A layer with an image has the type: napari.layers.image.image.Image
    # or 'Image layer'

    # To remove a layer, just use:
    # viewer.layers.pop(i)

    # All these codes can be used in the built-in interactive terminal
    # of Napari, which already has all loaded data on memory
コード例 #44
0
ファイル: test_censure.py プロジェクト: A-0-/scikit-image
import numpy as np
from numpy.testing import assert_array_equal, assert_raises
from skimage.data import moon
from skimage.feature import CENSURE


img = moon()


def test_censure_on_rectangular_images():
    """Censure feature detector should work on 2D image of any shape."""
    rect_image = np.random.random((300, 200))
    square_image = np.random.random((200, 200))
    CENSURE().detect((square_image))
    CENSURE().detect((rect_image))


def test_keypoints_censure_color_image_unsupported_error():
    """Censure keypoints can be extracted from gray-scale images only."""
    assert_raises(ValueError, CENSURE().detect, np.zeros((20, 20, 3)))


def test_keypoints_censure_mode_validity_error():
    """Mode argument in keypoints_censure can be either DoB, Octagon or
    STAR."""
    assert_raises(ValueError, CENSURE, mode='dummy')


def test_keypoints_censure_scale_range_error():
    """Difference between the the max_scale and min_scale parameters in
    keypoints_censure should be greater than or equal to two."""
コード例 #45
0
def test_isodata_moon_image_negative_float():
    moon = skimage.img_as_ubyte(data.moon()).astype(np.float64)
    moon -= 100
    assert -13 < threshold_isodata(moon) < -12
コード例 #46
0
    # try_all_threshold,
    # _mean_std,
    _cross_entropy,
)

# from skimage.filters._multiotsu import (_get_multiotsu_thresh_indices_lut,
#                                         _get_multiotsu_thresh_indices)
from skimage._shared import testing
from cupy.testing import assert_array_equal, assert_array_almost_equal

# transfer images to GPU
astronautd = cp.asarray(data.astronaut())
camerad = cp.asarray(data.camera())
celld = cp.asarray(data.cell())
coinsd = cp.asarray(data.coins())
moond = cp.asarray(data.moon())


class TestSimpleImage:
    def setup(self):
        # fmt: off
        self.image = cp.asarray(
            [[0, 0, 1, 3, 5], [0, 1, 4, 3, 4], [1, 2, 5, 4, 1],
             [2, 4, 5, 2, 1], [4, 5, 1, 0, 0]],
            dtype=int)
        # fmt: on

    def test_minimum(self):
        with pytest.raises(RuntimeError):
            threshold_minimum(self.image)
コード例 #47
0
    ax_hist.hist(img.ravel(), bins=bins)
    ax_hist.ticklabel_format(axis="y", style="scientific", scilimits=(0, 0))
    ax_hist.set_xlabel("Pixel intensity")

    xmin, xmax = dtype_range[img.dtype.type]
    ax_hist.set_xlim(xmin, xmax)

    # Display cumulative distribution
    img_cdf, bins = exposure.cumulative_distribution(img, bins)
    ax_cdf.plot(bins, img_cdf, "r")

    return ax_img, ax_hist, ax_cdf


# Load an example image
img = img_as_ubyte(data.moon())

# Global equalize
img_rescale = exposure.equalize_hist(img)

# Equalization
selem = disk(30)
img_eq = rank.equalize(img, selem=selem)


# Display results
f, axes = plt.subplots(2, 3, figsize=(8, 5))

ax_img, ax_hist, ax_cdf = plot_img_and_hist(img, axes[:, 0])
ax_img.set_title("Low contrast image")
ax_hist.set_ylabel("Number of pixels")
コード例 #48
0
ファイル: clipboard.py プロジェクト: tlambert03/napari
"""Copy screenshot of the canvas or the whole viewer to clipboard."""
from skimage import data

from qtpy.QtWidgets import QVBoxLayout, QPushButton, QWidget

import napari

# create the viewer with an image
viewer = napari.view_image(data.moon())


class Grabber(QWidget):
    def __init__(self):
        super().__init__()

        self.copy_canvas_btn = QPushButton("Copy Canvas to Clipboard", self)
        self.copy_canvas_btn.setToolTip(
            "Copy screenshot of the canvas to clipboard.")
        self.copy_viewer_btn = QPushButton("Copy Viewer to Clipboard", self)
        self.copy_viewer_btn.setToolTip(
            "Copy screenshot of the entire viewer to clipboard.")

        layout = QVBoxLayout(self)
        layout.addWidget(self.copy_canvas_btn)
        layout.addWidget(self.copy_viewer_btn)


def create_grabber_widget():
    """Create widget"""
    widget = Grabber()