def adaptive_none(self, grid_number): # First divide the image into number of grid. # Total, grid_number^2 number of grids. # 7, 5 are not working x, y = 0, 0 img = deepcopy(self.img) while(True): # Find left upper corner only. if x + grid_number >= self.col and y + grid_number >= self.row: # at last grid. subimg = self.img[y: , x: ] opt = threshold_otsu(subimg) img[y:, x:] = self.img[y:, x:] > opt break elif x + grid_number >= self.col and y + grid_number < self.row: # at the right edge. subimg = self.img[y : y + grid_number, x :] opt = threshold_otsu(subimg) img[y : y + grid_number, x :] = self.img[y : y + grid_number, x :] > opt y = y+grid_number x = 0 elif x + grid_number < self.col and y + grid_number >= self.row: subimg = self.img[y : , x : x + grid_number] opt = threshold_otsu(subimg) img[y : , x : x + grid_number] = self.img[y : , x : x + grid_number] > opt # print self.img[y : , x : x + width] x = x + grid_number else: subimg = self.img[y : y + grid_number, x : x + grid_number] opt = threshold_otsu(subimg) img[y : y + grid_number, x : x + grid_number] = self.img[y : y + grid_number, x : x + grid_number] > opt # print self.img[y : y + height, x : x + width] x = x+grid_number return img
def main():
parser = OptionParser()
(options, args) = parser.parse_args()
# reading input files
path = args[0]
# ref is the image that is used as a reference to subtract the background.
roi = [125,125,1050,1250]
roi_minx = roi[0]
roi_miny = roi[1]
roi_maxx = roi[2]
roi_maxy = roi[3]
template = io.imread(args[1])
template = template[:,:,0]
#ref = ref[roi_minx:roi_maxx, roi_miny:roi_maxy]
# otsu threshold the ref
thresh = filter.threshold_otsu(template)
template = template < thresh
#plt.imshow(ref)
#plt.show()
ref = io.imread(args[2])
ref = ref[:,:,0]
ref = ref[roi_minx:roi_maxx, roi_miny:roi_maxy]
thresh = filter.threshold_otsu(ref)
ref= ref < thresh
#plt.imshow(ref)
#plt.show()
output = []
for subdir, dirs, files in os.walk(path):
for file in files:
fn = os.path.join(subdir, file)
img = io.imread(fn)
img = img[:,:,0]
img = img[roi_minx:roi_maxx, roi_miny:roi_maxy]
# do otsu thresholding
thresh = filter.threshold_otsu(img)
img = img < thresh
#img = abs(img-ref)
#plt.imshow(img)
#plt.show()
centers = find_centers(img,template)
# get the image number from the file
n = int(re.search(r'\d+', file).group())
output.append((n, centers))
output = sorted(output, key=lambda x:x[0])
# now post process the output
post_process(output,roi)
def generate_template(digit_dir_path): template = zeros((42, 42)) for filename in iglob(digit_dir_path + '/*.bmp'): img = imread(filename) img = resize(img, [44, 44]) img = img[1:43,1:43] img = (img > (threshold_otsu(img, nbins=256))) template += img template = (template < (threshold_otsu(template, nbins=256)-5)) return template
def scikit_otsu(img): rows,cols,depth=img.shape from skimage.filter import threshold_otsu print "threshold using scikit" , np.floor(threshold_otsu(img)) threshold=np.floor(threshold_otsu(img)) imgO=np.zeros((rows,cols),int) for i in range(cols): for j in range(rows): if img[i,j,0]>=threshold: imgO[i,j]=255 elif img[i,j,0]<threshold: imgO[i,j]=0 return imgO
def percent_vert_horiz_lines(FilledBlobImg, props_area):
v = filter.vsobel(FilledBlobImg)
v_floor = filter.threshold_otsu(v)
ind_v = np.where(v > v_floor)
h = filter.hsobel(FilledBlobImg)
h_floor = filter.threshold_otsu(h)
ind_h = np.where(h > h_floor)
vert_and_horiz = np.zeros(v.shape).astype("bool")
vert_and_horiz[ind_v] = True
vert_and_horiz[ind_h] = True
ind = np.where(vert_and_horiz)[0]
return float(ind.size) / props_area
def robertCross(A): robert_minus=np.array([[1,0],[0,-1]]) robert_plus=np.array([[0,1],[-1,0]]) result1=convolution(A,robert_minus); result1=np.abs(result1) thresh1=np.floor(threshold_otsu(result1)) result1=np.logical_or(result1<0,result1>thresh1) result2=convolution(A,robert_plus); result2=np.abs(result2) thresh2=np.floor(threshold_otsu(result2)) result2=np.logical_or(result2<0,result2>thresh2) result=np.logical_or(result1,result2); return result
def ifcb_segment(img):
Y = img_as_float(img)
# step 1. local variance
Yv = rescale_intensity(generic_filter(Y, np.var, footprint=disk(3)))
# step 2. threshold local variance, aggressively
Ye = Yv > (threshold_otsu(Yv) / 2.)
# step 3. dark areas
Yt = Y < threshold_otsu(Y)
thin_blob = Ye | Yt
# step 4. morphological reconstruction
seed = np.copy(thin_blob)
seed[1:-1,1:-1] = 1
four=np.disk(1).astype(np.bool)
return reconstruction(seed,thin_blob,method='erosion',selem=four)
def variance_otsu(image, labels):
"""
Read pixel intensities from 'image' for each class given in 'labels' (a corresponding cluster
label array), and use Otsu's binarisation to threshold the image.
:param image: Pre-processed input image
:param labels: Array with same shape as input image, containing cluster labels
"""
img = image.ravel()
shadow_seg = img.copy()
hist, _ = np.histogram(labels)
n_clusters = hist.shape[0]
for i in range(0, n_clusters):
# set up mask of pixel indices matching cluster
mask = np.nonzero((labels.ravel() == i) == True)[0]
if len(mask) > 0:
if img[mask].var() > 0.005:
thresh = threshold_otsu(img[mask])
shadow_seg[mask] = shadow_seg[mask] < thresh
else:
shadow_seg[mask] = 0
shadow_seg = shadow_seg.reshape(*image.shape)
return shadow_seg
def find_letters(self, image, show=True):
image = restoration.denoise_tv_chambolle(image, weight=0.1)
try:
thresh = threshold_otsu(image)
except Exception:
print("Could not treshold")
result = []
return result
bw = closing(image > thresh, square(2))
cleared = bw.copy()
label_image = measure.label(cleared)
borders = np.logical_xor(bw, cleared)
label_image[borders] = -1
# image_label_overlay = label2rgb(label_image, image=image)
# fig, ax = plt.subplots(ncols=1, nrows=1, figsize=(12, 12))
# ax.imshow(image_label_overlay)
result = []
for region in regionprops(label_image):
minr, minc, maxr, maxc = region.bbox
result.append(Letter(minc, minr, maxc, maxr))
# rect = mpatches.Rectangle((minc, minr), maxc - minc, maxr - minr, fill=False, edgecolor='red', linewidth=2)
# ax.add_patch(rect)
# if show:
# plt.show()
return result
def threshold(data):
thresh1 = threshold_otsu(data)
thresh2 = thresh1 * 2
print "ndi thresh", thresh1, thresh2
data[data < thresh2] = 0
data[data >= thresh2] = 255
return data
def binarizeImage(RGBimage):
image = rgb2gray(RGBimage)
threshold = filter.threshold_otsu(image)
binarizedImage = image < threshold
return binarizedImage
def max_mask_iter(fns, offset=0, close_radius=0, erode_radius=0):
"""Find masks for a set of images having brightness artifacts.
Parameters
----------
fns : list of string
The images being examined.
offset : int, optional
Offset the threshold automatically found.
close_radius : int, optional
Perform a morphological closing of the mask of this radius.
erode_radius : int, optional
Perform a morphological erosion of the mask, after any closing,
of this radius.
Returns
-------
maxes : iterator of bool array
The max mask image corresponding to each input image.
"""
ms = maxes(fns)
t = imfilter.threshold_otsu(ms)
ims = it.imap(io.imread, fns)
masks = ((im < t + offset) for im in ims)
if close_radius > 0:
masks = (morphop(mask, 'close', close_radius) for mask in masks)
if erode_radius > 0:
masks = (morphop(mask, 'erode', erode_radius) for mask in masks)
return masks
def max_mask_iter(fns, offset=0, close_radius=0, erode_radius=0):
"""Find masks for a set of images having brightness artifacts.
Parameters
----------
fns : list of string
The images being examined.
offset : int, optional
Offset the threshold automatically found.
close_radius : int, optional
Perform a morphological closing of the mask of this radius.
erode_radius : int, optional
Perform a morphological erosion of the mask, after any closing,
of this radius.
Returns
-------
maxes : iterator of bool array
The max mask image corresponding to each input image.
"""
ms = maxes(fns)
t = imfilter.threshold_otsu(ms)
ims = it.imap(io.imread, fns)
masks = ((im < t + offset) for im in ims)
if close_radius > 0:
masks = (morphop(mask, 'close', close_radius) for mask in masks)
if erode_radius > 0:
masks = (morphop(mask, 'erode', erode_radius) for mask in masks)
return masks
def getRegions():
"""Geocode address and retreive image centered
around lat/long"""
address = request.args.get('address')
results = Geocoder.geocode(address)
lat, lng = results[0].coordinates
zip_code = results[0].postal_code
map_url = 'https://maps.googleapis.com/maps/api/staticmap?center={0},{1}&size=640x640&zoom=19&sensor=false&maptype=roadmap&&style=visibility:simplified|gamma:0.1'
request_url = map_url.format(lat, lng)
req = urllib.urlopen(request_url)
img = io.imread(req.geturl(),flatten=True)
labels, numobjects = ndimage.label(img)
image = filter.canny(img, sigma=3)
thresh = threshold_otsu(image)
bw = closing(image > thresh, square(3))
# remove artifacts connected to image border
cleared = bw.copy()
clear_border(cleared)
# label image regions
label_image = label(cleared)
borders = np.logical_xor(bw, cleared)
label_image[borders] = -1
image_label_overlay = label2rgb(label_image, image=image)
fig, ax = plt.subplots(ncols=1, nrows=1, figsize=(6, 6))
ax.imshow(image_label_overlay)
def getRegions():
"""Geocode address and retreive image centered
around lat/long"""
address = request.args.get('address')
results = Geocoder.geocode(address)
lat, lng = results[0].coordinates
zip_code = results[0].postal_code
map_url = 'https://maps.googleapis.com/maps/api/staticmap?center={0},{1}&size=640x640&zoom=19&sensor=false&maptype=roadmap&&style=visibility:simplified|gamma:0.1'
request_url = map_url.format(lat, lng)
req = urllib.urlopen(request_url)
img = io.imread(req.geturl(), flatten=True)
labels, numobjects = ndimage.label(img)
image = filter.canny(img, sigma=3)
thresh = threshold_otsu(image)
bw = closing(image > thresh, square(3))
# remove artifacts connected to image border
cleared = bw.copy()
clear_border(cleared)
# label image regions
label_image = label(cleared)
borders = np.logical_xor(bw, cleared)
label_image[borders] = -1
image_label_overlay = label2rgb(label_image, image=image)
fig, ax = plt.subplots(ncols=1, nrows=1, figsize=(6, 6))
ax.imshow(image_label_overlay)
def scikit_example_plot_label():
image = data.coins()[50:-50, 50:-50]
# apply threshold
thresh = threshold_otsu(image)
bw = closing(image > thresh, square(3))
# remove artifacts connected to image border
cleared = bw.copy()
clear_border(cleared)
# label image regions
label_image = label(cleared)
borders = np.logical_xor(bw, cleared)
label_image[borders] = -1
fig, ax = plt.subplots(ncols=1, nrows=1, figsize=(6, 6))
ax.imshow(label_image, cmap='jet')
for region in regionprops(label_image, ['Area', 'BoundingBox']):
# skip small images
if region['Area'] < 100:
continue
# draw rectangle around segmented coins
minr, minc, maxr, maxc = region['BoundingBox']
rect = mpatches.Rectangle((minc, minr), maxc - minc, maxr - minr,
fill=False, edgecolor='red', linewidth=2)
ax.add_patch(rect)
plt.show()
def threshold(data): thresh1 = threshold_otsu(data) thresh2 = thresh1*2 print "ndi thresh", thresh1, thresh2 data[data<thresh2] = 0 data[data>=thresh2] = 255 return data
def intensity_object_features(im, adaptive_t_radius=51, sample_size=None):
"""Segment objects based on intensity threshold and compute properties.
Parameters
----------
im : 2D np.ndarray of float or uint8.
The input image.
adaptive_t_radius : int, optional
The radius to calculate background with adaptive threshold.
sample_size : int, optional
Sample this many objects randomly, rather than measuring all
objects.
Returns
-------
f : 1D np.ndarray of float
The feature vector.
names : list of string
The list of feature names.
"""
tim1 = im > imfilter.threshold_otsu(im)
f1, names1 = object_features(tim1, im, sample_size=sample_size)
names1 = ['otsu-threshold-' + name for name in names1]
tim2 = imfilter.threshold_adaptive(im, adaptive_t_radius)
f2, names2 = object_features(tim2, im, sample_size=sample_size)
names2 = ['adaptive-threshold-' + name for name in names2]
f = np.concatenate([f1, f2])
return f, names1 + names2
def get_cells(image):
'''
Get cellls from the polygon.
'''
# apply threshold
thresh = threshold_otsu(image)
binary = image > thresh
bw=binary
plt.imshow(bw)
# Remove connected to image border
cleared = bw.copy()
clear_border(cleared)
# label image regions
label_image = skimage.measure.label(cleared)
#find_contours
borders = np.logical_xor(bw, cleared)
label_image[borders] = -1
image_label_overlay = label2rgb(label_image, image=image)
#extract the regions and get a polygon per region
polygons=[]
for i,region in enumerate(regionprops(label_image)):
# skip small images
if region.area < 100:
continue
a=np.zeros([len(region.coords),2])
#a=np.zeros(
plt.imshow(bw)
for i in range(len(region.coords)):
a[i,:]=[region.coords[i][0],region.coords[i][1]]
polygons.append(a)
return polygons
def _test_binary_image(self): #binary does not rotate axis.
# apply threshold
img = self.phase_data.copy()
print "min,max:",np.amin(img),np.amax(img)
thresh = threshold_otsu(img)
print "threshold",thresh
binary = self.phase_data > thresh
print "min,max:",np.amin(binary),np.amax(binary)
bw=binary
# Remove connected to image border
cleared = bw.copy()
skimage.segmentation.clear_border(cleared)
#up to now nothing is rotated.
# label image regions
label_image = skimage.measure.label(cleared)
skimage.io.imsave("phase_binary.tif",label_image*255)
#find_contours
borders = np.logical_xor(bw, cleared)
label_image[borders] = -1
image_label_overlay = skimage.color.label2rgb(label_image, image=img)
skimage.io.imsave("phase_binary2.tif",image_label_overlay*255)
def threshold_img(img, method='global_otsu', radius=50):
""" Given a gray scale image return a thresholded binary image using Otsu's thresholding method.
img: A gray scale numpy array.
method:
- 'global_otsu' computes a global threshold value for the whole image and uses this to binarize the
input image. (default)
- 'local_otsu' computes a local threshols value for each pixel (threshold is computed within a neighborhood of a radius).
radius: The 2D neighborhood to compute local thresholds in local_otsu method
Returns:
img_binary: A binary image (same size as input img).
threshold: Threshold value used to binarize the image.
"""
if len(img.shape) > 2:
img = rgb2gray(img)
if method == 'global_otsu':
threshold = threshold_otsu(img)
img_binary = img >= threshold
elif method == 'local_otsu':
selem = disk(radius)
threshold = rank.otsu(img, selem)
img_binary = img >= threshold
return img_binary, threshold
def watershed_slicing(image):
"""
Does the watershed algorithm slice by slice.
Then use the labeled image to calculate the centres of
mass for each slice.
"""
image = median_filter(image, 3)
thresh = threshold_otsu(image)
image = (image > thresh) * 1
N = len(image)
slice_centroids = []
slice_radius = []
for i in range(N):
slice = image[:, :, i]
labels_slice = watershed_segmentation(slice)
centroids, areas, bords, radius = centres_of_mass_2D(labels_slice)
slice_centroids.append(centroids)
slice_radius.append(radius)
# if i > 49:
# print centroids
# pl.imshow(labels_slice)
# pl.show()
return slice_centroids, slice_radius
def intensity_object_features(im, adaptive_t_radius=51, sample_size=None):
"""Segment objects based on intensity threshold and compute properties.
Parameters
----------
im : 2D np.ndarray of float or uint8.
The input image.
adaptive_t_radius : int, optional
The radius to calculate background with adaptive threshold.
sample_size : int, optional
Sample this many objects randomly, rather than measuring all
objects.
Returns
-------
f : 1D np.ndarray of float
The feature vector.
names : list of string
The list of feature names.
"""
tim1 = im > imfilter.threshold_otsu(im)
f1, names1 = object_features(tim1, im, sample_size=sample_size)
names1 = ['otsu-threshold-' + name for name in names1]
tim2 = imfilter.threshold_adaptive(im, adaptive_t_radius)
f2, names2 = object_features(tim2, im, sample_size=sample_size)
names2 = ['adaptive-threshold-' + name for name in names2]
f = np.concatenate([f1, f2])
return f, names1 + names2
def plot_preprocessed_image(self):
"""
plots pre-processed image. The plotted image is the same as obtained at the end
of the get_text_candidates method.
"""
image = restoration.denoise_tv_chambolle(self.image, weight=0.1)
thresh = threshold_otsu(image)
bw = closing(image > thresh, square(2))
cleared = bw.copy()
label_image = measure.label(cleared)
borders = np.logical_xor(bw, cleared)
label_image[borders] = -1
image_label_overlay = label2rgb(label_image, image=image)
fig, ax = plt.subplots(ncols=1, nrows=1, figsize=(12, 12))
ax.imshow(image_label_overlay)
for region in regionprops(label_image):
if region.area < 10:
continue
minr, minc, maxr, maxc = region.bbox
rect = mpatches.Rectangle((minc, minr), maxc - minc, maxr - minr,
fill=False, edgecolor='red', linewidth=2)
ax.add_patch(rect)
plt.show()
def watershed_3d(sphere):
"""
Markers should be int8
Image should be uint8
"""
sphere = median_filter(sphere, 3)
thresh = threshold_otsu(sphere)
sphere = (sphere >= thresh) * 1
sphere = sobel(sphere)
size = (sphere.shape[0], sphere.shape[1], sphere.shape[2])
marker = np.zeros(size, dtype=np.int16)
pl.imshow(sphere[:, :, 50])
pl.show()
# mark everything outside as background
marker[5, :, :] = -1
marker[size[0] - 5, :, :] = -1
marker[:, :, 5] = -1
marker[:, :, size[2] - 5] = -1
marker[:, 5, :] = -1
marker[:, size[1] - 5, :] = -1
marker[:, 0, 0] = -1
# mark everything inside as a sphere
marker[size[0] / 2., size[1] / 2., size[2] / 2.] = 5
result = measurements.watershed_ift(sphere.astype(dtype=np.uint16), marker)
pl.imshow(result[:, :, 50])
pl.show()
return result
def one_file_features(self, im, demo=False):
"""
Zde je kontruován vektor pÅ™Ãznaků pro klasfikátor
"""
fd = np.array([])
import skimage.transform
import skimage
# Zmena velikosti obrazku
image = skimage.transform.resize(im, [50, 50])
#%% Vyriznuti objektu kolem stredu obrazu
image = image[int(image.shape[0]/2)-20:int(image.shape[0]/2)+20, int(image.shape[1]/2)-20:int(image.shape[1]/2)+20]
fd = np.append(fd, image.reshape(-1))
# Vyuziti Otsuova filtru
from skimage import filter
threshold = filter.threshold_otsu(image)
image =image < threshold
fd = np.append(fd, image.reshape(-1))
#%% Změna velikosti
#fd.append(hsvft[:])
# if self.colorFeatures:
# fd = np.append(fd, self.colorFeatures)
# pass
return fd
def watershed_slicing(image):
"""
Does the watershed algorithm slice by slice.
Then use the labeled image to calculate the centres of
mass for each slice.
"""
image = median_filter(image, 3)
thresh = threshold_otsu(image)
image = (image > thresh) * 1
N = len(image)
slice_centroids = []
slice_radius = []
for i in range(N):
slice = image[:, :, i]
labels_slice = watershed_segmentation(slice)
centroids, areas, bords, radius = centres_of_mass_2D(labels_slice)
slice_centroids.append(centroids)
slice_radius.append(radius)
# if i > 49:
# print centroids
# pl.imshow(labels_slice)
# pl.show()
return slice_centroids, slice_radius
def label_stack(z_stack, parameters):
'''
Apply an automated threshold and a watershed algorithm to
label cells in each planes of the stack
Parameters:
-----------
z_stack: 3d array of shape (nz, nx, ny)
Returns:
--------
labeled_stack: 3d array of the same shape as z_stack,
with each detected region labeled
'''
segment_method = parameters['segment_method']
correction = parameters['correction']
labeled_stack = np.zeros(z_stack.shape, dtype=np.uint8)
max_int_proj = z_stack.max(axis=0)
thresh = None
if segment_method == 'otsu':
thresh = threshold_otsu(max_int_proj) * correction
elif segment_method == 'naive':
thresh = max_int_proj.max() * correction
else:
err_string = ('Segmentation method {}'
'is not implemented'.format(segment_method))
raise NotImplementedError(err_string)
while thresh > z_stack.max():
log.warning('''Reducing threshold''')
thresh *= 0.9
for n, frame in enumerate(z_stack):
labeled_stack[n] = label_from_thresh(frame, thresh, parameters)
return labeled_stack
def one_file_features(self, im, demo=False):
"""
Zde je kontruován vektor pÅ™Ãznaků pro klasfikátor
"""
fd = np.array([])
import skimage.transform
import skimage
# Zmena velikosti obrazku
image = skimage.transform.resize(im, [50, 50])
#%% Vyriznuti objektu kolem stredu obrazu
image = image[int(image.shape[0] / 2) - 20:int(image.shape[0] / 2) +
20,
int(image.shape[1] / 2) - 20:int(image.shape[1] / 2) +
20]
fd = np.append(fd, image.reshape(-1))
# Vyuziti Otsuova filtru
from skimage import filter
threshold = filter.threshold_otsu(image)
image = image < threshold
fd = np.append(fd, image.reshape(-1))
#%% Změna velikosti
#fd.append(hsvft[:])
# if self.colorFeatures:
# fd = np.append(fd, self.colorFeatures)
# pass
return fd
def roofRegion(edge):
"""Estimate region based on edges of roofRegion
"""
# apply threshold
thresh = threshold_otsu(image)
bw = closing(image > thresh, square(3))
# remove artifacts connected to image border
cleared = bw.copy()
clear_border(cleared)
# label image regions
label_image = label(cleared)
borders = np.logical_xor(bw, cleared)
label_image[borders] = -1
image_label_overlay = label2rgb(label_image, image=image)
fig, ax = plt.subplots(ncols=1, nrows=1, figsize=(6, 6))
ax.imshow(image_label_overlay)
for region in regionprops(label_image):
# skip small images
if region.area < 100:
continue
# draw rectangle around segmented coins
minr, minc, maxr, maxc = region.bbox
rect = mpatches.Rectangle((minc, minr), maxc - minc, maxr - minr,
fill=False, edgecolor='red', linewidth=2)
ax.add_patch(rect)
plt.show()
def count_cell(img, edge_pixels, erosion_iterations):
img_no_edge = remove_edge(img, edge_pixels)
threshold = threshold_otsu(img_no_edge)
img_thr = threshold_image(img_no_edge, threshold)
eroded_img = ndimage.morphology.binary_erosion(img_thr, iterations = erosion_iterations)
labels, number_labels = ndimage.label(eroded_img)
return number_labels
def threshold_image(image, threshold=0): """ This function takes out any values in an image's RGB matrix that are below the threshold value. Inputs: - image: a matrix describing an image with only one channel represented. - threshold: a value, between 0 and 1, for which if an image matrix's value is below, will be set to 0, and if above, will be set to 1. If the threshold is set to 0, then an Otsu thresholding will be returned. Outputs: - thresholded_image: a matrix representation of the thresholded image. this is essentially a black and white image. - thresh: the threshold value To screen: the black-and-white image representation. - """ if threshold == 0: thresh = threshold_otsu(image) if threshold != 0: thresh = threshold thresholded_image = closing(image > thresh, square(3), out=None) imshow(thresholded_image) return thresholded_image, thresh
def test():
from skimage.filter import threshold_otsu
img = imread('lena.bmp')
grey = greyscale(img)
sk_thres = np.floor(threshold_otsu(grey))
my_thres = otsu_thresh(grey)
assert sk_thres == my_thres
def demoOtsuThresholding(self):
img = data.camera()
thresh = filter.threshold_otsu(img)
mask = img > thresh
fig, (ax1, ax2, ax3) = plt.subplots(1,
3,
figsize=(8, 2.5),
facecolor='w')
ax1.imshow(img, cmap='gray')
ax1.set_title('Original')
ax1.axis('off')
ax2.hist(img)
ax2.set_title('Histogram')
ax2.axvline(thresh, color='r')
ax3.imshow(mask, cmap='gray')
ax3.set_title('Thresholded')
ax3.axis('off')
fname = '/Users/mangotee/Dropbox/Teaching/CDTM ARdrones Lecture/imgDemoOtsuThresholding.png'
plt.savefig(fname)
plt.show()
def plot_preprocessed_image(self):
"""
plots pre-processed image. The plotted image is the same as obtained at the end
of the get_text_candidates method.
"""
image = restoration.denoise_tv_chambolle(self.image, weight=0.1)
thresh = threshold_otsu(image)
bw = closing(image > thresh, square(2))
cleared = bw.copy()
label_image = measure.label(cleared)
borders = np.logical_xor(bw, cleared)
label_image[borders] = -1
image_label_overlay = label2rgb(label_image, image=image)
fig, ax = plt.subplots(ncols=1, nrows=1, figsize=(12, 12))
ax.imshow(image_label_overlay)
for region in regionprops(label_image):
if region.area < 10:
continue
minr, minc, maxr, maxc = region.bbox
rect = mpatches.Rectangle((minc, minr), maxc - minc, maxr - minr,
fill=False, edgecolor='red', linewidth=2)
ax.add_patch(rect)
plt.show()
def __transform(self):
self.__img_gray = io.imread(self.__img_path, True)
self.__otsu = filter.threshold_otsu(self.__img_gray) #Aplicar otsu para binarizar a imagem
self.__img_gray = self.__img_gray < self.__otsu
# Find contours at a constant value of 0.5
self.__contours = measure.find_contours(self.__img_gray, 0.5)
self.__arclen = 0.0
for n, contour in enumerate(self.__contours):
arclenTemp=0.0
for indice, valor in enumerate(contour):
if indice > 0:
d1 = math.fabs(round(valor[0]) - round(contour[indice-1,0]))
d2 = math.fabs(round(valor[1]) - round(contour[indice-1,1]))
if d1+d2>1.0:
arclenTemp+=math.sqrt(2)
elif d1+d2 == 1:
arclenTemp+=1
if arclenTemp > self.__arclen:
self.__arclen = arclenTemp
self.__bestn = n
#self.__bestn = 0
print self.__contours[0]
def watershed_3d(sphere):
"""
Markers should be int8
Image should be uint8
"""
sphere = median_filter(sphere, 3)
thresh = threshold_otsu(sphere)
sphere = (sphere >= thresh) * 1
sphere = sobel(sphere)
size = (sphere.shape[0], sphere.shape[1], sphere.shape[2])
marker = np.zeros(size, dtype=np.int16)
pl.imshow(sphere[:,:,50])
pl.show()
# mark everything outside as background
marker[5, :, :] = -1
marker[size[0] - 5, :, :] = -1
marker[:, :, 5] = -1
marker[:, :, size[2] - 5] = -1
marker[:, 5, :] = -1
marker[:, size[1] - 5, :] = -1
marker[:,0,0] = -1
# mark everything inside as a sphere
marker[size[0] / 2., size[1] / 2., size[2] / 2.] = 5
result = measurements.watershed_ift(sphere.astype(dtype=np.uint16), marker)
pl.imshow(result[:,:,50])
pl.show()
return result
def run_cmd(method, block_size=40):
stdin = sys.stdin.read()
if stdin == '\n':
exit()
img = Image.open(StringIO.StringIO(stdin)).convert('L')
imgc = np.array(img)
imggray = rgb2gray(imgc)
if method is None or method == '':
imgthresh = threshold_adaptive(imggray, block_size, 'gaussian', offset=10)
elif method == 'gaussian':
imgthresh = threshold_adaptive(imggray, block_size, 'gaussian', offset=10)
elif method == 'median':
imgthresh = threshold_adaptive(imggray, block_size, 'median', offset=10)
elif method == 'mean':
imgthresh = threshold_adaptive(imggray, block_size, 'mean', offset=10)
elif method == 'otsu':
thresh = threshold_otsu(imggray)
imgthresh = imggray > thresh
elif method == 'yen':
thresh = threshold_yen(imggray)
imgthresh = imggray > thresh
elif method == 'iso':
thresh = threshold_isodata(imggray)
imgthresh = imggray > thresh
rescaled = (255.0 / imgthresh.max() * (imgthresh - imgthresh.min())).astype(np.uint8)
out = Image.fromarray(rescaled)
out.save(sys.stdout, format='PNG')
def test_3d():
import h5py
from skimage.filter import threshold_otsu
from imseg.image_tools import imclip, normalize
# from imseg.imtools.imclip import imclip as imclip2
f = h5py.File('/Users/yue/data/obj.hdf5', 'r')
im = f['object'][:, 350:900, 350:900]
f.close()
# im = anisodiff(im, niter=10)
im = imclip(im, verbose=False)
im = normalize(im, mode='median')
thresholds = threshold_otsu(im)
print('Threshold = {}'.format(thresholds))
im_seg = ImSeg(im)
im_seg.init(thresholds=thresholds,
diff_sdf_kwargs=kwarg(it=5, dt=0.1),
diff_error_kwargs=kwarg(it=20, dt=0.25),
diff_ave_kwargs=kwarg(it=5, dt=0.1),
reinit_sdf_kwargs=kwarg(niter=5, dt=0.1),
init_reinit_sdf_kwargs=kwarg(niter=50, dt=0.1),
im_slice=(slice(None), slice(None), 512 - 350),
out_path='/Users/yue/data/segment/sdf_diff_3d_1/', debug=True, verbose=True)
im_seg.initialize()
for i in xrange(10):
im_seg.iterate(10)
im_seg.save()
def get_cells(image):
'''
Get cellls from the polygon.
'''
new_image=np.ones([3,image.shape[0],image.shape[1]],dtype=float)
# apply threshold
thresh = threshold_otsu(image)
bw=image
# remove artifacts connected to image border
cleared = bw.copy()
clear_border(cleared)
# label image regions
label_image = label(cleared)
#skimage.measure.label
#find_contours
borders = np.logical_xor(bw, cleared)
label_image[borders] = -1
image_label_overlay = label2rgb(label_image, image=image)
#extract the regions and get a polygon per region
polygons=[]
for i,region in enumerate(regionprops(label_image)):
# skip small images
if region.area < 100:
continue
#polygons.append(matplotlib.path.Path(region.coords))
print (region.coords.shape)
a=np.zeros(region.coords.shape)
a[:,0]=region.coords[:,1]
a[:,1]=region.coords[:,0]
polygons.append(a)
return polygons
def get_background_markers(image_gray):
'''
Finds the pixels that definitely belong in background regions.
Parameters
-----------
image_gray : 2-D numpy array
A grayscale image.
Returns
-----------
markers_background : 2-D Boolean numpy array
An array with the same shape as image_gray, where the seeds of
the background regions are True.
'''
dark_threshold = threshold_by_blocks(image_gray, 20, background_intensity)
dark_pixels = image_gray <= dark_threshold
image_smooth = gaussian_filter(image_gray, 1)
otsu = image_gray > threshold_otsu(image_gray)
#minima = local_min(image_smooth) & np.logical_not(otsu)
#minima = local_min(image_gray) & (~ otsu)
minima = local_min(image_gray)
markers_background = dark_pixels | minima
return markers_background
def detect_edges(image):
# 1. convert to grayscale image
image_gray = rgb2gray(image)
# 2. convolve with Sobel filter
image_sobel = sobel(image_gray)
# 3. compute binary edge image with threshold from Otsu's method
image_edges = image_sobel > threshold_otsu(image_sobel)
return image_sobel, image_edges
def detect_edges(image):
# 1. convert to grayscale image
image_gray = rgb2gray(image)
# 2. convolve with Sobel filter
image_sobel = sobel(image_gray)
# 3. compute binary edge image with threshold from Otsu's method
image_edges = image_sobel > threshold_otsu(image_sobel)
return image_sobel, image_edges
def binary_from_thresh(img):
""" Base function for converting to binary using a threshold
args:
img: m x n ndarray
"""
thresh = threshold_otsu(img)
binary = img < thresh
return binary
def preprocess_image(self):
"""
Denoises and increases contrast.
"""
image = restoration.denoise_tv_chambolle(self.image, weight=0.1)
thresh = threshold_otsu(image)
self.bw = closing(image > thresh, square(2))
self.cleared = self.bw.copy()
return self.cleared
def image_features_hog3(img, num_features,orientation,maxcell,maxPixel):
image=denoise_bilateral(img, win_size=5, sigma_range=None, sigma_spatial=1, bins=10000, mode='constant', cval=0)
thresh = threshold_otsu(image)
binary = image > thresh
im = resize(binary, (maxPixel, maxPixel))
##hog scikit transform
return image_features_hog_fd(im)
def AddContour2(self):
val = filter.threshold_otsu(self)
mask = self < val
# Morphological ACWE. Initialization of the level-set.
macwe = ms.MorphACWE(self, smoothing=1, lambda1=1, lambda2=1)
macwe.levelset = ms.circle_levelset(self.shape, (20, 20), 25)
for i in range(20):
macwe.step()
print 'hey'
def signal_to_noise_ratio(im1, im2, mask=None, thresh=None):
''' Compute SNR of two images (see Dietrich et al. 2007,
JMRI, 26, 375) '''
print 'computing signal-to-noise ratio'
from skimage.filter import threshold_otsu
if mask is None:
if thresh is None:
thresh = threshold_otsu(im1)
mask = im1 > thresh
return ((im1[mask] + im2[mask]).mean() / \
(im1[mask] - im2[mask]).std() / sqrt(2), mask)
def automatedfilter(imageFile):
import matplotlib.pyplot as plt
import numpy as np
from skimage import data, io, color, exposure, filter, transform
from skimage.filter import threshold_otsu
imageThresh = io.imread(imageFile)
image = Image.open(imageFile)
thresh = threshold_otsu(imageThresh)
resizeImg = resizeImage(image)
imageArray = imageToBinaryArray(resizeImg, thresh)
return imageArray
def brain_mask(mat4d, size=2, numpass=2):
from skimage.filter import threshold_otsu
from scipy.ndimage import median_filter
bm = np.array(mat4d)
if bm.shape[3] > 1:
bm = np.mean(bm, axis=3)
for i in range(numpass):
bm = median_filter(bm, size=size)
t = threshold_otsu(bm)
bm[bm < t] = 0
bm[bm >= t] = 1
return bm.astype(int)
def feature_vector_from_rgb(image, sample_size=None):
"""Compute a feature vector from the composite images.
The channels are assumed to be in the following order:
- Red: MCF-7
- Green: cytoplasm GFP
- Blue: DAPI/Hoechst
Parameters
----------
im : array, shape (M, N, 3)
The input image.
sample_size : int, optional
For features based on quantiles, sample this many objects
rather than computing full distribution. This can considerably
speed up computation with little cost to feature accuracy.
Returns
-------
fs : 1D array of float
The features of the image.
names : list of string
The feature names.
"""
all_fs, all_names = [], []
ims = np.rollaxis(image[..., :3], -1, 0) # toss out alpha chan if present
mcf, cells, nuclei = ims
prefixes = ['mcf', 'cells', 'nuclei']
for im, prefix in zip(ims, prefixes):
fs, names = features.intensity_object_features(im,
sample_size=sample_size)
names = [prefix + '-' + name for name in names]
all_fs.append(fs)
all_names.extend(names)
nuclei_mean = nd.label(nuclei > np.mean(nuclei))[0]
fs, names = features.nearest_neighbors(nuclei_mean)
all_fs.append(fs)
all_names.extend(['nuclei-' + name for name in names])
mcf_mean = nd.label(mcf)[0]
fs, names = features.fraction_positive(nuclei_mean, mcf_mean,
positive_name='mcf')
all_fs.append(fs)
all_names.extend(names)
cells_t_otsu = cells > threshold_otsu(cells)
cells_t_adapt = threshold_adaptive(cells, 51)
fs, names = features.nuclei_per_cell_histogram(nuclei_mean, cells_t_otsu)
all_fs.append(fs)
all_names.extend(['otsu-' + name for name in names])
fs, names = features.nuclei_per_cell_histogram(nuclei_mean, cells_t_adapt)
all_fs.append(fs)
all_names.extend(['adapt-' + name for name in names])
return np.concatenate(all_fs), all_names
def task_1_3():
I_1 = imread('images/coins.png')
I_2 = imread('images/overlapping_euros1.png')
# Get the otsu value via the 'Otsu Threshold' (where the histogram is to be split/segmented)
otsu1 = filter.threshold_otsu(I_1)
otsu2 = filter.threshold_otsu(I_2)
# Extracting Histograms
hist1, bins_center1 = exposure.histogram(I_1)
hist2, bins_center2 = exposure.histogram(I_2)
# Printing the images, segmenting inside 'imshow'
plt.figure(figsize=(9, 4))
plt.subplot(131)
plt.imshow(I_1, cmap='gray', interpolation='nearest')
plt.axis('off')
plt.subplot(132)
plt.imshow(I_1 < otsu1, cmap='gray', interpolation='nearest')
plt.axis('off')
plt.subplot(133)
plt.plot(bins_center1, hist1, lw=2)
plt.axvline(otsu1, color='k', ls='--')
plt.tight_layout()
plt.show()
# Printing the images, segmenting inside 'imshow'
plt.figure(figsize=(9, 4))
plt.subplot(131)
plt.imshow(I_2, cmap='gray', interpolation='nearest')
plt.axis('off')
plt.subplot(132)
plt.imshow(I_2 < otsu2, cmap='gray', interpolation='nearest')
plt.axis('off')
plt.subplot(133)
plt.plot(bins_center2, hist2, lw=2)
plt.axvline(otsu2, color='k', ls='--')
plt.tight_layout()
plt.show()
def image_features_resize_thres(img, maxPixel, num_features,imageSize):
# X is the feature vector with one row of features per image
# consisting of the pixel values a, num_featuresnd our metric
X=np.zeros(num_features, dtype=float)
image=denoise_bilateral(img, win_size=5, sigma_range=None, sigma_spatial=1, bins=10000, mode='constant', cval=0)
thresh = threshold_otsu(image)
binary = image > thresh
im = resize(binary, (maxPixel, maxPixel))
# Store the rescaled image pixels
X[0:imageSize] = np.reshape(im,(1, imageSize))
return X
def local_threshold(img_arr):
"""
For each pixel, an optimal threshold is determined by maximizing
the variance between two classes of pixels of the local neighborhood
defined by a structuring element.
Input: 3D image tensor or 2D grayscaled image or
filtered/transformed image array.
Output: binary img_array where pixels are >= global threshold
"""
threshold_global_otsu = threshold_otsu(img_arr)
global_otsu = img_arr >= threshold_global_otsu
return np.ravel(global_otsu.astype(int))
def segment_shadow(image, labels, n_clusters=8):
img = image.ravel()
shadow_seg = img.copy()
for i in range(0, n_clusters):
# set up array of pixel indices matching cluster
mask = np.nonzero((labels.ravel() == i) == True)[0]
if len(mask) > 0:
if img[mask].var() > 0.005:
thresh = threshold_otsu(img[mask])
shadow_seg[mask] = shadow_seg[mask] < thresh
else:
shadow_seg[mask] = 0
shadow_seg = shadow_seg.reshape(*image.shape)
return shadow_seg
def select_area_for_detector(np_image):
import numpy as np
import pylab as pl
from skimage.filter import threshold_otsu, sobel
from skimage.morphology import label
from skimage.measure import regionprops
from skimage.filter import denoise_tv_chambolle
pl.close('all')
# Find regions
image_filtered = denoise_tv_chambolle(np_image, weight=0.002)
edges = sobel(image_filtered)
nbins = 50
threshold = threshold_otsu(edges, nbins)
edges_bin = edges >= threshold
label_image = label(edges_bin)
areas = []
areas_full = []
bord = []
# Extract information from the regions
for region in regionprops(label_image, ['Area', 'BoundingBox', 'Label']):
# Skip wrong regions
index = np.where(label_image==region['Label'])
if index[0].size==0 & index[1].size==0:
continue
# Skip small regions
if region['Area'] < 100:
continue
# Extract the coordinates of regions
minr, minc, maxr, maxc = region['BoundingBox']
margin = len(np_image) / 100
bord.append((minr-margin, maxr+margin, minc-margin, maxc+margin))
areas.append(edges_bin[minr-margin:maxr+margin,minc-margin:maxc+margin].copy())
areas_full.append(np_image[minr-margin:maxr+margin,minc-margin:maxc+margin].copy())
return areas, areas_full, bord
def _segment_edge_areas(edges, disk_size=9, mean_threshold=200, min_object_size=500):
"""
Takes a greyscale image (with brighter colors corresponding to edges) and returns a binary image where white
indicates an area with high edge density and black indicates low density.
"""
# Convert the greyscale edge information into black and white (ie binary) image
threshold = threshold_otsu(edges)
# Filter out the edge data below the threshold, effectively removing some noise
raw_channel_areas = edges <= threshold
# Smooth out the data
channel_areas = rank.mean(raw_channel_areas, disk(disk_size)) < mean_threshold
# Remove specks and blobs that are the result of artifacts
clean_channel_areas = remove_small_objects(channel_areas, min_size=min_object_size)
# Fill in any areas that are completely surrounded by the areas (hopefully) covering the channels
return ndimage.binary_fill_holes(clean_channel_areas)
def get_d(image):
'''
Extracting etalons from image
'''
print 'Extracting...'
max_cost = 0.2
max_et = 100
max_area = 30
max_transform = 3
image = rgb2gray(image)
tresh = threshold_otsu(image)
dt = []
for it in xrange(max_transform):
bi = image < tresh
li = label(bi)
print it
for region in regionprops(li, ['Area', 'BoundingBox']):
if region['Area'] < max_area:
continue
minr, minc, maxr, maxc = region['BoundingBox']
imr = bi[minr:maxr, minc:maxc]
imr = resize(imr, (30, 30))
h = False
for t in dt:
if cost(imr, t) < max_cost:
h = True
break
if h:
continue
else:
dt.append(imr)
if len(dt) >= max_et:
return dt
if it % 2:
sx = 0.9 - (it + 0.0) / 10
sy = 1.0 + (it + 0.0) / 11
rt = 0.02 + (it + 0.0) * 0.01
else:
sx = 0.9 + (it + 0.0) / 10
sy = 1.0 - (it + 0.0) / 11
rt = -0.03 - (it + 0.0) * 0.015
tform = AffineTransform(scale=(sx, sy), rotation=rt)
image = warp(image, tform)
print len(dt)
return dt
def otsu(img): rows,cols,depth=img.shape pixels=np.array([0 for x in range(256)]) for i in range(0,rows): for j in range(0,cols): bright=img[i,j] pixels[bright]=pixels[bright]+1 def w(k,pixels): sum=0 for i in range(0,k): sum=pixels[i] return sum*1.0/(rows*cols) def u(k,pixels): sum=0 for i in range(0,k): sum=i*pixels[i] return sum*1.0/(rows*cols) histoT, bin_edges=np.histogram(img,bins=range(256)) histo=np.array(histoT) values_pixels=np.array([0 for i in range(256)]) values_histo=np.array([0 for i in range(256)]) for j in range(256): if w(j,pixels)==0: continue values_pixels[j]=(((u(255,pixels)*w(j,pixels))-u(j,pixels))**2)/((w(j,pixels))*(1-w(j,pixels))) if w(j,histo)==0: continue values_histo[j]=(((u(255,histo)*w(j,histo))-u(j,histo))**2)/((w(j,histo))*(1-w(j,histo))) threshold=np.argmax(values_pixels) print "threshold using pixels",threshold print "threshold using np.histogram",np.argmax(values_histo) from skimage.filter import threshold_otsu print "threshold using scikit" , np.floor(threshold_otsu(img)) imgO=np.zeros((rows,cols),int) for i in range(cols): for j in range(rows): if img[i,j,0]>=threshold: imgO[i,j]=255 elif img[i,j,0]<threshold: imgO[i,j]=0 return imgO
