def preProcess(img):
    
    img[:,:,0] = mean_bilateral(img[:,:,0], morphology.disk(20), s0=10, s1=10)
    img[:,:,1] = mean_bilateral(img[:,:,1], morphology.disk(20), s0=10, s1=10)
    img[:,:,2] = mean_bilateral(img[:,:,2], morphology.disk(20), s0=10, s1=10)
    
    return img
Beispiel #2
0
def test_bilateral():
    image = np.zeros((21, 21), dtype=np.uint16)
    selem = np.ones((3, 3), dtype=np.uint8)

    image[10, 10] = 1000
    image[10, 11] = 1010
    image[10, 9] = 900

    assert rank.mean_bilateral(image, selem, s0=1, s1=1)[10, 10] == 1000
    assert rank.pop_bilateral(image, selem, s0=1, s1=1)[10, 10] == 1
    assert rank.mean_bilateral(image, selem, s0=11, s1=11)[10, 10] == 1005
    assert rank.pop_bilateral(image, selem, s0=11, s1=11)[10, 10] == 2
Beispiel #3
0
def test_bilateral():
    image = np.zeros((21, 21), dtype=np.uint16)
    selem = np.ones((3, 3), dtype=np.uint8)

    image[10, 10] = 1000
    image[10, 11] = 1010
    image[10, 9] = 900

    assert rank.mean_bilateral(image, selem, s0=1, s1=1)[10, 10] == 1000
    assert rank.pop_bilateral(image, selem, s0=1, s1=1)[10, 10] == 1
    assert rank.mean_bilateral(image, selem, s0=11, s1=11)[10, 10] == 1005
    assert rank.pop_bilateral(image, selem, s0=11, s1=11)[10, 10] == 2
Beispiel #4
0
    def test_bilateral(self):
        image = np.zeros((21, 21), dtype=np.uint16)
        footprint = np.ones((3, 3), dtype=np.uint8)

        image[10, 10] = 1000
        image[10, 11] = 1010
        image[10, 9] = 900

        kwargs = dict(s0=1, s1=1)
        assert rank.mean_bilateral(image, footprint, **kwargs)[10, 10] == 1000
        assert rank.pop_bilateral(image, footprint, **kwargs)[10, 10] == 1
        kwargs = dict(s0=11, s1=11)
        assert rank.mean_bilateral(image, footprint, **kwargs)[10, 10] == 1005
        assert rank.pop_bilateral(image, footprint, **kwargs)[10, 10] == 2
Beispiel #5
0
def find_blobs(filename):
    feature = ""
    raw_image = io.imread(filename)
    for channel in range(0, 4):
        if channel < 3:
            image = raw_image[:,:,channel]
        image_gray = rgb2gray(image)

        # Smoothing
        image_gray = img_as_ubyte(image_gray)
        image_gray = mean_bilateral(image_gray.astype(numpy.uint16), disk(20), s0=10, s1=10)

        # Increase contrast
        image_gray = exposure.equalize_adapthist(image_gray, clip_limit=0.03)

        # Find blobs
        blobs_doh = blob_doh(image_gray, min_sigma=1, max_sigma=20, threshold=.005)
        count = 0
        for blob in blobs_doh:
            y, x, r = blob
            if (x-400)**2 + (y-400)**2 > distance:
                continue
            count = count + 1
        feature = feature + " " + str(channel + 1) + ":" + str(count)
    return feature
        def check_all():
            selem = morphology.disk(1)
            refs = np.load(
                os.path.join(skimage.data_dir, "rank_filter_tests.npz"))

            assert_equal(refs["autolevel"], rank.autolevel(self.image, selem))
            assert_equal(refs["autolevel_percentile"],
                         rank.autolevel_percentile(self.image, selem))
            assert_equal(refs["bottomhat"], rank.bottomhat(self.image, selem))
            assert_equal(refs["equalize"], rank.equalize(self.image, selem))
            assert_equal(refs["gradient"], rank.gradient(self.image, selem))
            assert_equal(refs["gradient_percentile"],
                         rank.gradient_percentile(self.image, selem))
            assert_equal(refs["maximum"], rank.maximum(self.image, selem))
            assert_equal(refs["mean"], rank.mean(self.image, selem))
            assert_equal(refs["geometric_mean"],
                         rank.geometric_mean(self.image, selem)),
            assert_equal(refs["mean_percentile"],
                         rank.mean_percentile(self.image, selem))
            assert_equal(refs["mean_bilateral"],
                         rank.mean_bilateral(self.image, selem))
            assert_equal(refs["subtract_mean"],
                         rank.subtract_mean(self.image, selem))
            assert_equal(refs["subtract_mean_percentile"],
                         rank.subtract_mean_percentile(self.image, selem))
            assert_equal(refs["median"], rank.median(self.image, selem))
            assert_equal(refs["minimum"], rank.minimum(self.image, selem))
            assert_equal(refs["modal"], rank.modal(self.image, selem))
            assert_equal(refs["enhance_contrast"],
                         rank.enhance_contrast(self.image, selem))
            assert_equal(refs["enhance_contrast_percentile"],
                         rank.enhance_contrast_percentile(self.image, selem))
            assert_equal(refs["pop"], rank.pop(self.image, selem))
            assert_equal(refs["pop_percentile"],
                         rank.pop_percentile(self.image, selem))
            assert_equal(refs["pop_bilateral"],
                         rank.pop_bilateral(self.image, selem))
            assert_equal(refs["sum"], rank.sum(self.image, selem))
            assert_equal(refs["sum_bilateral"],
                         rank.sum_bilateral(self.image, selem))
            assert_equal(refs["sum_percentile"],
                         rank.sum_percentile(self.image, selem))
            assert_equal(refs["threshold"], rank.threshold(self.image, selem))
            assert_equal(refs["threshold_percentile"],
                         rank.threshold_percentile(self.image, selem))
            assert_equal(refs["tophat"], rank.tophat(self.image, selem))
            assert_equal(refs["noise_filter"],
                         rank.noise_filter(self.image, selem))
            assert_equal(refs["entropy"], rank.entropy(self.image, selem))
            assert_equal(refs["otsu"], rank.otsu(self.image, selem))
            assert_equal(refs["percentile"],
                         rank.percentile(self.image, selem))
            assert_equal(refs["windowed_histogram"],
                         rank.windowed_histogram(self.image, selem))
 def bilateral_filter(self, data, kernel, kern_size, s0, s1):
     from skimage.morphology import disk, square
     from skimage.filters import rank
     import numpy as np
     # https://scikit-image.org/docs/dev/api/skimage.filters.rank.html?highlight=mean_bilateral
     if (kernel == "disk"):
         selem = disk(kern_size)
     if (kernel == "square"):
         selem = square(kern_size)
     data_norm = 1.0 * data / np.max(np.abs(data))
     data_filt = rank.mean_bilateral(data_norm, selem=selem, s0=s0, s1=s1)
     return data_filt
def cal_delta_abs(image, z):
    delta = image - z
    delta = adjust_extreme(image, delta)
    balance = (300 + delta).astype(np.uint16)
    #cv2.imwrite('127.jpg' ,(127 + delta).astype(np.uint8))
    #cv2.imshow('balance', balance)
    #blur = gaussian(balance, 1).astype(np.uint8)
    #g_kernel = cv2.getGaussianKernel(5, 1)
    #blur = cv2.filter2D(balance, 0, g_kernel)
    #blur = cv2.medianBlur(balance, 11)

    blur = median(balance, selem=disk(7))
    blur = mean_bilateral(blur, disk(13))
    abs = np.abs(blur - 300.0).astype(np.uint8)
    #cv2.imshow('abs', abs)
    #cv2.waitKey()
    return abs
Beispiel #9
0
def FilterBilateral(img, stdFilter=False, winh=5, winw=15, S0=20, S1=50):

    if stdFilter == False:

        winsize = (winh, winw)
        win = np.ones(winsize)
        #      win=255*win
        img255 = np.copy(img)
        img = img.astype('uint8')
        #      img=img/255.
        result = mean_bilateral(img,
                                win,
                                shift_x=False,
                                shift_y=False,
                                s0=S0,
                                s1=S1)
        img = img255
        return result
    else:
        prog = 255 * denoise_bilateral(img)
        return prog
Beispiel #10
0
def check_all():
    np.random.seed(0)
    image = np.random.rand(25, 25)
    selem = morphology.disk(1)
    refs = np.load(os.path.join(skimage.data_dir, "rank_filter_tests.npz"))

    assert_equal(refs["autolevel"], rank.autolevel(image, selem))
    assert_equal(refs["autolevel_percentile"], rank.autolevel_percentile(image, selem))
    assert_equal(refs["bottomhat"], rank.bottomhat(image, selem))
    assert_equal(refs["equalize"], rank.equalize(image, selem))
    assert_equal(refs["gradient"], rank.gradient(image, selem))
    assert_equal(refs["gradient_percentile"], rank.gradient_percentile(image, selem))
    assert_equal(refs["maximum"], rank.maximum(image, selem))
    assert_equal(refs["mean"], rank.mean(image, selem))
    assert_equal(refs["mean_percentile"], rank.mean_percentile(image, selem))
    assert_equal(refs["mean_bilateral"], rank.mean_bilateral(image, selem))
    assert_equal(refs["subtract_mean"], rank.subtract_mean(image, selem))
    assert_equal(refs["subtract_mean_percentile"], rank.subtract_mean_percentile(image, selem))
    assert_equal(refs["median"], rank.median(image, selem))
    assert_equal(refs["minimum"], rank.minimum(image, selem))
    assert_equal(refs["modal"], rank.modal(image, selem))
    assert_equal(refs["enhance_contrast"], rank.enhance_contrast(image, selem))
    assert_equal(refs["enhance_contrast_percentile"], rank.enhance_contrast_percentile(image, selem))
    assert_equal(refs["pop"], rank.pop(image, selem))
    assert_equal(refs["pop_percentile"], rank.pop_percentile(image, selem))
    assert_equal(refs["pop_bilateral"], rank.pop_bilateral(image, selem))
    assert_equal(refs["sum"], rank.sum(image, selem))
    assert_equal(refs["sum_bilateral"], rank.sum_bilateral(image, selem))
    assert_equal(refs["sum_percentile"], rank.sum_percentile(image, selem))
    assert_equal(refs["threshold"], rank.threshold(image, selem))
    assert_equal(refs["threshold_percentile"], rank.threshold_percentile(image, selem))
    assert_equal(refs["tophat"], rank.tophat(image, selem))
    assert_equal(refs["noise_filter"], rank.noise_filter(image, selem))
    assert_equal(refs["entropy"], rank.entropy(image, selem))
    assert_equal(refs["otsu"], rank.otsu(image, selem))
    assert_equal(refs["percentile"], rank.percentile(image, selem))
    assert_equal(refs["windowed_histogram"], rank.windowed_histogram(image, selem))
Beispiel #11
0
img_gauss_filtered = img_as_ubyte(filter.gaussian(img_noisy, 3))

gauss_im_entropy, _, _ = original_im_histogram.information_entropy(
    img_gauss_filtered)
_, gauss_histogram = original_im_histogram.image_histogram(
    img_gauss_filtered, "on")

img_median_filtered = img_as_ubyte(median(img_noisy, disk(1)))
median_im_entropy, _, _ = original_im_histogram.information_entropy(
    img_median_filtered)
_, median_histogram = original_im_histogram.image_histogram(
    img_median_filtered, "on")

img_bilateral_filtered = img_as_ubyte(
    mean_bilateral(img_noisy, disk(5), s0=10, s1=10))
bilateral_im_entropy, _, _ = original_im_histogram.information_entropy(
    img_bilateral_filtered)
_, bilateral_histogram = original_im_histogram.image_histogram(
    img_bilateral_filtered, "on")

information_mutual_original_noisy = np.round(
    drv.information_mutual(original_histogram, noisy_histogram), 2)
information_mutual_original_noisy_filtered_by_gauss = np.round(
    drv.information_mutual(original_histogram, gauss_histogram), 2)
information_mutual_original_noisy_filtered_by_median = np.round(
    drv.information_mutual(original_histogram, median_histogram), 2)
information_mutual_original_noisy_filtered_by_bilateral = np.round(
    drv.information_mutual(original_histogram, bilateral_histogram), 2)

object_finder.add_image(img)
def transform(image):
    selem = disk(20)
    image = numpy.invert(image)
    changed = rank.mean_bilateral(image, selem=selem, s0=500, s1=500)
    changed = resize(changed, (50, 50))
    return changed
def mean_bilateral_skimage(img):
    img = to_gray(img)
    img = img.astype(np.uint8)
    edges = mean_bilateral(img, disk(20), s0=10, s1=10)

    return edges
    def prefilter(self, img, method='median'):
        
        ps = self.settings.prefilter_settings[method]
        
        print
        print 'prefiltering :', method

        if method=='median':
            radius = ps['median_size']

            # with vigra
            #filtered= vigra.filters.discMedian(img, radius)
            
            # with skimage            
            pref = rank.median(img, disk(radius))
            
        elif method=='avg': 
            # with skimage           
            se = disk(ps['avg_size'])   
            pref = rank.mean(img, se)         
            
        elif method=='bilateral': 
            # with skimage           
            se = disk(ps['bil_radius']) 
            pref = rank.mean_bilateral(img, se,
                                       s0=ps['bil_lower'], 
                                       s1=ps['bil_upper'])
        
        elif method=='denoise_bilateral':
            #skimage.filters.denoise_bilateral(image, win_size=5, sigma_range=None, sigma_spatial=1,

            pref = restoration.denoise_bilateral(img, ps['win_size'], ps['sigma_signal'], ps['sigma_space'], ps['bins'], 
                                                 mode='constant', cval=0, multichannel=False)
                       
        elif method=='close_rec':
            se = disk(ps['close_size'])
            dil = morphology.dilation(img, se)
            rec = morphology.reconstruction(dil, img, method='erosion')
            
            # reconstruction gives back a float image (for whatever reason). 
            pref = rec.astype(dil.dtype)
            
        elif method=='denbi_clorec':
            temp = restoration.denoise_bilateral(img, ps['win_size'], ps['sigma_signal'], ps['sigma_space'], ps['bins'], 
                                                 mode='constant', cval=0, multichannel=False)
            temp = 255 * temp
            temp = temp.astype(img.dtype)
            
            se = disk(ps['close_size'])
            dil = morphology.dilation(temp, se)
            rec = morphology.reconstruction(dil, temp, method='erosion')
            
            # reconstruction gives back a float image (for whatever reason). 
            pref = rec.astype(img.dtype)            

        elif method=='denbi_asfrec':
            temp = restoration.denoise_bilateral(img, ps['win_size'], ps['sigma_signal'], ps['sigma_space'], ps['bins'], 
                                                 mode='constant', cval=0, multichannel=False)
            temp = 255 * temp
            temp = temp.astype(img.dtype)
            
            se = disk(ps['close_size'])
            dil = morphology.dilation(temp, se)
            rec = morphology.reconstruction(dil, temp, method='erosion')

            se = disk(ps['open_size'])
            ero = morphology.erosion(rec, se)
            rec2 = morphology.reconstruction(ero, rec, method='dilation')
            
            # reconstruction gives back a float image (for whatever reason). 
            pref = rec2.astype(img.dtype)            

        elif method=='med_denbi_asfrec':
            if ps['median_size'] > 1:
                radius = ps['median_size']
                pref = rank.median(img, disk(radius))
            else:
                pref = img
 
            temp = restoration.denoise_bilateral(pref, ps['win_size'], ps['sigma_signal'], ps['sigma_space'], ps['bins'], 
                                                 mode='constant', cval=0, multichannel=False)
            temp = 255 * temp
            temp = temp.astype(img.dtype)
            
            if ps['close_size'] > 0 : 
                se = disk(ps['close_size'])
                dil = morphology.dilation(temp, se)
                rec = morphology.reconstruction(dil, temp, method='erosion')
            else:
                rec = temp
                
            if ps['open_size'] > 0:
                se = disk(ps['open_size'])
                ero = morphology.erosion(rec, se)
                rec2 = morphology.reconstruction(ero, rec, method='dilation')
            else:
                rec2 = rec
            
            # reconstruction gives back a float image (for whatever reason). 
            pref = rec2.astype(img.dtype)            
            
        
        return pref
filtering rate for continuous area (i.e. background) while higher image
frequencies remain untouched.

"""
import numpy as np
import matplotlib.pyplot as plt

from skimage import data
from skimage.morphology import disk
from skimage.filters import rank

image = (data.coins()).astype(np.uint16) * 16
selem = disk(20)

percentile_result = rank.mean_percentile(image, selem=selem, p0=.1, p1=.9)
bilateral_result = rank.mean_bilateral(image, selem=selem, s0=500, s1=500)
normal_result = rank.mean(image, selem=selem)

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

titles = ['Original', 'Percentile mean', 'Bilateral mean', 'Local mean']
imgs = [image, percentile_result, bilateral_result, normal_result]
for n in range(0, len(imgs)):
    ax[n].imshow(imgs[n])
    ax[n].set_title(titles[n])
    ax[n].set_adjustable('box-forced')
Beispiel #16
0
def process_image(img, disk_radius=20):
    return sobel(mean_bilateral(img, disk(disk_radius)))
frequencies remain untouched.

"""
import numpy as np
import matplotlib.pyplot as plt

from skimage import data
from skimage.morphology import disk
from skimage.filters import rank


image = (data.coins()).astype(np.uint16) * 16
selem = disk(20)

percentile_result = rank.mean_percentile(image, selem=selem, p0=0.1, p1=0.9)
bilateral_result = rank.mean_bilateral(image, selem=selem, s0=500, s1=500)
normal_result = rank.mean(image, selem=selem)


fig, axes = plt.subplots(nrows=3, figsize=(8, 10))
ax0, ax1, ax2 = axes

ax0.imshow(np.hstack((image, percentile_result)))
ax0.set_title("Percentile mean")
ax0.axis("off")

ax1.imshow(np.hstack((image, bilateral_result)))
ax1.set_title("Bilateral mean")
ax1.axis("off")

ax2.imshow(np.hstack((image, normal_result)))
Beispiel #18
0
from skimage.filters.rank import mean_bilateral
from skimage.morphology import disk

bilat = np.empty_like(img)
for i, aslice in enumerate(img):
    bilat[i] = mean_bilateral(aslice.astype(np.uint8), disk(3), s0=15, s1=15)

slicing(img, 'gray')
Beispiel #19
0
from skimage.morphology import disk
import numpy as np
import res_drawer


def Canny(image, draw=False):
    edge = feature.canny(image,
                         sigma=3,
                         use_quantiles=False,
                         low_threshold=5,
                         high_threshold=25)
    if draw == True:
        res_drawer.binary(image, edge)
    return edge


if __name__ == "__main__":
    img = cv2.imread('E:\\File\\python\\proj2\\pic\\small1.jpg', 0)
    #img = denoise_bilateral(img, win_size=10, multichannel=False)
    g = gabor(img, 50)

    img = mean_bilateral(img, disk(25))
    d1 = sobel(img)

    img1 = feature.canny(img,
                         sigma=3,
                         use_quantiles=False,
                         low_threshold=20,
                         high_threshold=40)
    plt.imshow(img1, cmap=plt.cm.gray)
    plt.show()
Beispiel #20
0
def find_boards(img):
    boards = []
    debug_img = ski.img_as_ubyte(img)

    img = ski.img_as_ubyte(img)
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

    edges = cv2.Canny(gray, 40, 70)

    boards_img = ski.img_as_bool(edges)
    boards_img = mp.remove_small_holes(boards_img, 250)
    boards_img = mp.dilation(boards_img, mp.disk(1))
    boards_img = mp.thin(boards_img)
    boards_img = ndi.binary_fill_holes(boards_img)

    squares = mp.erosion(boards_img, mp.disk(3))
    squares = mp.remove_small_objects(squares, 45)
    squares = ski.img_as_ubyte(squares)

    contours, hierarchy = cv2.findContours(squares, cv2.RETR_TREE,
                                           cv2.CHAIN_APPROX_SIMPLE)

    potential_boards = []
    for c in contours:
        peri = cv2.arcLength(c, True)
        approx = cv2.approxPolyDP(c, 0.05 * peri, True)

        if len(approx) == 4:
            potential_boards.append(approx)
            # cv2.drawContours(img, approx, -1, (0, 0, 255), 5)

    for b in potential_boards:
        M = cv2.moments(b)
        cx = int(M['m10'] / M['m00'])
        cy = int(M['m01'] / M['m00'])

        rotated_rect = cv2.minAreaRect(b)
        (x, y), (w, h), angle = rotated_rect

        box = cv2.boxPoints(rotated_rect)
        box = np.int0(box)

        src_pts = box.astype("float32")
        src_pts = transform_src_pts(src_pts)

        dst_pts = np.array([[0, h], [0, 0], [w, 0], [w, h]], dtype="float32")

        dst_pts *= 3

        M = cv2.getPerspectiveTransform(src_pts, dst_pts)

        bg_color = np.mean(img)

        warped = cv2.warpPerspective(img,
                                     M, (int(w * 1.8 * 3), int(h * 1.8 * 3)),
                                     borderMode=cv2.BORDER_CONSTANT,
                                     borderValue=(bg_color, bg_color,
                                                  bg_color))

        gray = cv2.cvtColor(warped, cv2.COLOR_RGB2GRAY)
        gray = mean_bilateral(ski.img_as_ubyte(gray), mp.disk(5), s0=10, s1=10)
        gray = ski.img_as_float(gray)
        gray = 1 - gray

        gray = cv2.resize(gray, (100, 100))
        boards.append(ski.img_as_float(gray))

    cv2.destroyAllWindows()

    # show_boards(boards)
    return boards
Beispiel #21
0
def smooth(img):
    image= img_as_ubyte(img)
    image = mean_bilateral(image.astype(numpy.uint16), disk(20), s0=10, s1=10)
    return image
Beispiel #22
0
import matplotlib.pyplot as plt

from skimage import data
from skimage.morphology import disk
from skimage.filters import rank


image = data.coins()
footprint = disk(20)

percentile_result = rank.mean_percentile(
    image, footprint=footprint, p0=.1, p1=.9
)
bilateral_result = rank.mean_bilateral(
    image, footprint=footprint, s0=500, s1=500
)
normal_result = rank.mean(image, footprint=footprint)

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

titles = ['Original', 'Percentile mean', 'Bilateral mean', 'Local mean']
imgs = [image, percentile_result, bilateral_result, normal_result]
for n in range(0, len(imgs)):
    ax[n].imshow(imgs[n], cmap=plt.cm.gray)
    ax[n].set_title(titles[n])
    ax[n].axis('off')

plt.tight_layout()
#
# One may be interested in smoothing an image while preserving important
# borders (median filters already achieved this), here we use the
# **bilateral** filter that restricts the local neighborhood to pixel having
# a gray-level similar to the central one.
#
# .. note::
#
#     A different implementation is available for color images in
#     `skimage.filters.denoise_bilateral`.

from skimage.filters.rank import mean_bilateral

noisy_image = img_as_ubyte(data.camera())

bilat = mean_bilateral(noisy_image.astype(np.uint16), disk(20), s0=10, s1=10)

fig, ax = plt.subplots(2, 2, figsize=(10, 7), sharex='row', sharey='row')
ax1, ax2, ax3, ax4 = ax.ravel()

ax1.imshow(noisy_image, cmap=plt.cm.gray)
ax1.set_title('Original')
ax1.axis('off')
ax1.set_adjustable('box-forced')

ax2.imshow(bilat, cmap=plt.cm.gray)
ax2.set_title('Bilateral mean')
ax2.axis('off')
ax2.set_adjustable('box-forced')

ax3.imshow(noisy_image[200:350, 350:450], cmap=plt.cm.gray)
Beispiel #24
0
def color_enhancement(noisy_image):
	bilat = mean_bilateral(noisy_image.astype(np.uint16), disk(20), s0=10, s1=10)
	return bilat