Python skimage.filters.median() Examples
The following are 8
code examples of skimage.filters.median().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
skimage.filters
, or try the search function
.
.
Example #1
| Source File: preprocessing.py From bird-species-classification with MIT License | 6 votes |
|
def compute_binary_mask_sprengel(spectrogram, threshold):
""" Computes a binary mask for the spectrogram
# Arguments
spectrogram : a numpy array representation of a spectrogram (2-dim)
threshold : a threshold for times larger than the median
# Returns
binary_mask : the binary mask
"""
# normalize to [0, 1)
norm_spectrogram = normalize(spectrogram)
# median clipping
binary_image = median_clipping(norm_spectrogram, threshold)
# erosion
binary_image = morphology.binary_erosion(binary_image, selem=np.ones((4, 4)))
# dilation
binary_image = morphology.binary_dilation(binary_image, selem=np.ones((4, 4)))
# extract mask
mask = np.array([np.max(col) for col in binary_image.T])
mask = smooth_mask(mask)
return mask
Example #2
| Source File: preprocessing.py From bird-species-classification with MIT License | 6 votes |
|
def median_clipping(spectrogram, number_times_larger):
""" Compute binary image from spectrogram where cells are marked as 1 if
number_times_larger than the row AND column median, otherwise 0
"""
row_medians = np.median(spectrogram, axis=1)
col_medians = np.median(spectrogram, axis=0)
# create 2-d array where each cell contains row median
row_medians_cond = np.tile(row_medians, (spectrogram.shape[1], 1)).transpose()
# create 2-d array where each cell contains column median
col_medians_cond = np.tile(col_medians, (spectrogram.shape[0], 1))
# find cells number_times_larger than row and column median
larger_row_median = spectrogram >= row_medians_cond*number_times_larger
larger_col_median = spectrogram >= col_medians_cond*number_times_larger
# create binary image with cells number_times_larger row AND col median
binary_image = np.logical_and(larger_row_median, larger_col_median)
return binary_image
Example #3
| Source File: expt_utils.py From pyxem with GNU General Public License v3.0 | 6 votes |
|
def subtract_background_median(z, footprint):
"""Remove background using a median filter.
Parameters
----------
footprint : int
size of the window that is convoluted with the array to determine
the median. Should be large enough that it is about 3x as big as the
size of the peaks.
Returns
-------
Pattern with background subtracted as np.array
"""
selem = morphology.square(footprint)
# skimage only accepts input image as uint16
bg_subtracted = z - filters.median(z.astype(np.uint16), selem).astype(z.dtype)
return np.maximum(bg_subtracted, 0)
Example #4
| Source File: preprocessing.py From bird-species-classification with MIT License | 5 votes |
|
def compute_binary_mask_lasseck(spectrogram, threshold):
# normalize to [0, 1)
norm_spectrogram = normalize(spectrogram)
# median clipping
binary_image = median_clipping(norm_spectrogram, threshold)
# closing binary image (dilation followed by erosion)
binary_image = morphology.binary_closing(binary_image, selem=np.ones((4, 4)))
# dialate binary image
binary_image = morphology.binary_dilation(binary_image, selem=np.ones((4, 4)))
# apply median filter
binary_image = filters.median(binary_image, selem=np.ones((2, 2)))
# remove small objects
binary_image = morphology.remove_small_objects(binary_image, min_size=32, connectivity=1)
mask = np.array([np.max(col) for col in binary_image.T])
mask = smooth_mask(mask)
return mask
# TODO: This method needs some real testing
Example #5
| Source File: ClassificationModule.py From HistoQC with BSD 3-Clause Clear License | 5 votes |
|
def compute_median(img, params):
median_disk_size = int(params.get("median_disk_size", 3))
return median(rgb2gray(img), selem=disk(median_disk_size))[:, :, None]
Example #6
| Source File: demo.py From Recursive-Cascaded-Networks with MIT License | 5 votes |
|
def auto_liver_mask(vol, ths = [(80, 140), (110, 160), (70, 90), (60, 80), (50, 70), (40, 60), (30, 50), (20, 40), (10, 30), (140, 180), (160, 200)]):
vol = filters.gaussian(vol, sigma = 2, preserve_range = True)
mask = np.zeros_like(vol, dtype = np.bool)
max_area = 0
for th_lo, th_hi in ths:
print(th_lo, th_hi)
bw = np.ones_like(vol, dtype = np.bool)
bw[vol < th_lo] = 0
bw[vol > th_hi] = 0
if np.sum(bw) <= max_area:
continue
with concurrent.futures.ProcessPoolExecutor(8) as executor:
jobs = list(range(bw.shape[-1]))
args1 = [bw[:, :, z] for z in jobs]
args2 = [morphology.disk(35) for z in jobs]
for idx, ret in tqdm.tqdm(zip(jobs, executor.map(filters.median, args1, args2)), total = len(jobs)):
bw[:, :, jobs[idx]] = ret
# for z in range(bw.shape[-1]):
# bw[:, :, z] = filters.median(bw[:, :, z], morphology.disk(35))
if np.sum(bw) <= max_area:
continue
labeled_seg = measure.label(bw, connectivity=1)
regions = measure.regionprops(labeled_seg)
max_region = max(regions, key = lambda x: x.area)
if max_region.area <= max_area:
continue
max_area = max_region.area
mask = labeled_seg == max_region.label
assert max_area > 0, 'Failed to find the liver area!'
return mask
Example #7
| Source File: image_cropper.py From dsb2018_topcoders with MIT License | 4 votes |
|
def strange_method(self, _idx, img0, msk0, lbl0, x0, y0):
input_shape = self.input_shape
good4copy = self.all_good4copy[_idx]
img = img0[y0:y0 + input_shape[0], x0:x0 + input_shape[1], :]
msk = msk0[y0:y0 + input_shape[0], x0:x0 + input_shape[1], :]
if len(good4copy) > 0 and random.random() > 0.75:
num_copy = random.randrange(1, min(6, len(good4copy) + 1))
lbl_max = lbl0.max()
for i in range(num_copy):
lbl_max += 1
l_id = random.choice(good4copy)
lbl_msk = self.all_labels[_idx] == l_id
row, col = np.where(lbl_msk)
y1, x1 = np.min(np.where(lbl_msk), axis=1)
y2, x2 = np.max(np.where(lbl_msk), axis=1)
lbl_msk = lbl_msk[y1:y2 + 1, x1:x2 + 1]
lbl_img = img0[y1:y2 + 1, x1:x2 + 1, :]
if random.random() > 0.5:
lbl_msk = lbl_msk[:, ::-1, ...]
lbl_img = lbl_img[:, ::-1, ...]
rot = random.randrange(4)
if rot > 0:
lbl_msk = np.rot90(lbl_msk, k=rot)
lbl_img = np.rot90(lbl_img, k=rot)
x1 = random.randint(max(0, x0 - lbl_msk.shape[1] // 2),
min(img0.shape[1] - lbl_msk.shape[1], x0 + input_shape[1] - lbl_msk.shape[1] // 2))
y1 = random.randint(max(0, y0 - lbl_msk.shape[0] // 2),
min(img0.shape[0] - lbl_msk.shape[0], y0 + input_shape[0] - lbl_msk.shape[0] // 2))
tmp = erosion(lbl_msk, square(5))
lbl_msk_dif = lbl_msk ^ tmp
tmp = dilation(lbl_msk, square(5))
lbl_msk_dif = lbl_msk_dif | (tmp ^ lbl_msk)
lbl0[y1:y1 + lbl_msk.shape[0], x1:x1 + lbl_msk.shape[1]][lbl_msk] = lbl_max
img0[y1:y1 + lbl_msk.shape[0], x1:x1 + lbl_msk.shape[1]][lbl_msk] = lbl_img[lbl_msk]
full_diff_mask = np.zeros_like(img0[..., 0], dtype='bool')
full_diff_mask[y1:y1 + lbl_msk.shape[0], x1:x1 + lbl_msk.shape[1]] = lbl_msk_dif
img0[..., 0][full_diff_mask] = median(img0[..., 0], mask=full_diff_mask)[full_diff_mask]
img0[..., 1][full_diff_mask] = median(img0[..., 1], mask=full_diff_mask)[full_diff_mask]
img0[..., 2][full_diff_mask] = median(img0[..., 2], mask=full_diff_mask)[full_diff_mask]
img = img0[y0:y0 + input_shape[0], x0:x0 + input_shape[1], :]
lbl = lbl0[y0:y0 + input_shape[0], x0:x0 + input_shape[1]]
msk = self.create_mask(lbl)
return img, msk
#dbg functions
Example #8
| Source File: dsb_binary.py From dsb2018_topcoders with MIT License | 4 votes |
|
def copy_cells(self, mask, image, label, img_id, input_shape):
img0 = image.copy()
msk0 = mask.copy()
lbl0 = label.copy()
yp = 0
xp = 0
#todo: refactor it, copied from Victor's code as is, random crops should be outside of this method
if img0.shape[0] < input_shape[0]:
yp = input_shape[0] - img0.shape[0]
if img0.shape[1] < input_shape[1]:
xp = input_shape[1] - img0.shape[1]
if xp > 0 or yp > 0:
img0 = np.pad(img0, ((0, yp), (0, xp), (0, 0)), 'constant')
msk0 = np.pad(msk0, ((0, yp), (0, xp), (0, 0)), 'constant')
lbl0 = np.pad(lbl0, ((0, yp), (0, xp)), 'constant')
good4copy = self.all_good4copy[img_id]
x0 = random.randint(0, img0.shape[1] - input_shape[1])
y0 = random.randint(0, img0.shape[0] - input_shape[0])
img = img0[y0:y0 + input_shape[0], x0:x0 + input_shape[1], :]
msk = msk0[y0:y0 + input_shape[0], x0:x0 + input_shape[1], :]
lbl = lbl0[y0:y0 + input_shape[0], x0:x0 + input_shape[1]]
if len(good4copy) > 0 and random.random() < 0.05:
num_copy = random.randrange(1, min(6, len(good4copy) + 1))
lbl_max = lbl0.max()
for i in range(num_copy):
lbl_max += 1
l_id = random.choice(good4copy)
lbl_msk = label == l_id
y1, x1 = np.min(np.where(lbl_msk), axis=1)
y2, x2 = np.max(np.where(lbl_msk), axis=1)
lbl_msk = lbl_msk[y1:y2 + 1, x1:x2 + 1]
lbl_img = img0[y1:y2 + 1, x1:x2 + 1, :]
if random.random() > 0.5:
lbl_msk = lbl_msk[:, ::-1, ...]
lbl_img = lbl_img[:, ::-1, ...]
rot = random.randrange(4)
if rot > 0:
lbl_msk = np.rot90(lbl_msk, k=rot)
lbl_img = np.rot90(lbl_img, k=rot)
x1 = random.randint(max(0, x0 - lbl_msk.shape[1] // 2),
min(img0.shape[1] - lbl_msk.shape[1], x0 + input_shape[1] - lbl_msk.shape[1] // 2))
y1 = random.randint(max(0, y0 - lbl_msk.shape[0] // 2),
min(img0.shape[0] - lbl_msk.shape[0], y0 + input_shape[0] - lbl_msk.shape[0] // 2))
tmp = erosion(lbl_msk, square(5))
lbl_msk_dif = lbl_msk ^ tmp
tmp = dilation(lbl_msk, square(5))
lbl_msk_dif = lbl_msk_dif | (tmp ^ lbl_msk)
lbl0[y1:y1 + lbl_msk.shape[0], x1:x1 + lbl_msk.shape[1]][lbl_msk] = lbl_max
img0[y1:y1 + lbl_msk.shape[0], x1:x1 + lbl_msk.shape[1]][lbl_msk] = lbl_img[lbl_msk]
full_diff_mask = np.zeros_like(img0[..., 0], dtype='bool')
full_diff_mask[y1:y1 + lbl_msk.shape[0], x1:x1 + lbl_msk.shape[1]] = lbl_msk_dif
img0[..., 0][full_diff_mask] = median(img0[..., 0], mask=full_diff_mask)[full_diff_mask]
img0[..., 1][full_diff_mask] = median(img0[..., 1], mask=full_diff_mask)[full_diff_mask]
img0[..., 2][full_diff_mask] = median(img0[..., 2], mask=full_diff_mask)[full_diff_mask]
img = img0[y0:y0 + input_shape[0], x0:x0 + input_shape[1], :]
lbl = lbl0[y0:y0 + input_shape[0], x0:x0 + input_shape[1]]
msk = self.create_mask(lbl)
return msk, img, lbl
