def extract_image_features(self, data):
# Please do not modify the header above
# extract feature vector from image data
feature_data = []
for i in data:
# 1. PREPROCESSING: grayscaling
i = color.rgb2gray(i)
# 1. PREPROCESSING: gaussian blur
i = filters.gaussian(i, sigma=(0.6, 0.6))
# 1. PREPROCESSING: thresholding to get black and white (as displayed in pdf)
thresh = filters.threshold_minimum(i)
binary_image = i > thresh
# Couldn't resolve error related to putting a boolean image array inside hog, had to use image without thresholding
# 2. FEATURE DESCRIPTOR: HOG
(feature_i, hog_image) = feature.hog(i,
orientations=8,
pixels_per_cell=(32, 32),
cells_per_block=(2, 2),
visualize=True,
multichannel=False)
feature_data.append(feature_i)
# FOR TESTING PURPOSES ONLY
# print(H.size)
# io.imshow(hog_image)
# plt.show()
feature_data = np.array(feature_data)
# Please do not modify the return type below
return feature_data
def initial_segmentation(image, PATCH_RATIO):
"""
Initialization of the image segmentation.
:param image: A numpy matrix. Original image.
:param PATCH_RATIO: Constant. Ratio between patch area against cell mean cell area.
"""
from skimage.filters import threshold_li, threshold_otsu, threshold_minimum
from skimage.morphology import closing, square
thresh_li = threshold_li(image)
thresh_otsu = threshold_otsu(image)
try:
thresh_min = threshold_minimum(image)
except RuntimeError:
thresh_min = thresh_otsu + 100
if thresh_min < thresh_otsu:
threshold_steps = range(int(thresh_li), int(thresh_otsu),
abs(int((thresh_otsu - thresh_li) / 5)))
else:
threshold_steps = [thresh_otsu]
binary_image = closing(image > threshold_steps[0], square(3))
label_image = label(binary_image)
regions = regionprops(label_image, image)
regions_above_noise = []
areas = []
for region in regions:
if region.area >= 9:
#Lista con las nuevas regiones
areas.append(region.area)
regions_above_noise.append(region)
median = np.median(areas)
patch = int((PATCH_RATIO * median)**(0.5))
return (threshold_steps, patch, regions_above_noise, label_image)
def call_doublets(self, threshold=None, verbose=True):
if threshold is None:
# automatic threshold detection
# http://scikit-image.org/docs/dev/api/skimage.filters.html
from skimage.filters import threshold_minimum
try:
threshold = threshold_minimum(self.doublet_scores_sim_)
if verbose:
print("Automatically set threshold at doublet score = {:.2f}".format(threshold))
except:
self.predicted_doublets_ = None
if verbose:
print("Warning: failed to automatically identify doublet score threshold. Run `call_doublets` with user-specified threshold.")
return self.predicted_doublets_
Ld_obs = self.doublet_scores_obs_
Ld_sim = self.doublet_scores_sim_
se_obs = self.doublet_errors_obs_
Z = (Ld_obs - threshold) / se_obs
self.predicted_doublets_ = Ld_obs > threshold
self.z_scores_ = Z
self.threshold_ = threshold
self.detected_doublet_rate_ = (Ld_obs>threshold).sum() / float(len(Ld_obs))
self.detectable_doublet_fraction_ = (Ld_sim>threshold).sum() / float(len(Ld_sim))
self.overall_doublet_rate_ = self.detected_doublet_rate_ / self.detectable_doublet_fraction_
if verbose:
print('Detected doublet rate = {:.1f}%'.format(100*self.detected_doublet_rate_))
print('Estimated detectable doublet fraction = {:.1f}%'.format(100*self.detectable_doublet_fraction_))
print('Overall doublet rate:')
print('\tExpected = {:.1f}%'.format(100*self.expected_doublet_rate))
print('\tEstimated = {:.1f}%'.format(100*self.overall_doublet_rate_))
return self.predicted_doublets_
def analyze_minThreshold(image):
"""Returns bright on dark particles using a thresholding algorithm
Implements contrast stretching and minimum thresholding to detect particles
Cleanup is performed by closing and removing the particles that contact the clear_border
"""
#Convert to grayscale
i_grey = rgb2gray(image)
#Convert to uint8
i_uint = img_as_ubyte(i_grey)
#Contrast stretching
p2, p98 = np.percentile(i_uint, (2, 98))
i_contStretch = exposure.rescale_intensity(i_uint, in_range=(p2, p98))
#Minimum thresholding
i_min_thresh = i_uint > threshold_minimum(i_contStretch)
#Close open domains
i_closed = closing(i_min_thresh, square(3))
#Remove artifacts connected to image border
i_cleared = clear_border(i_closed)
#Label image regions
label_image = label(i_cleared)
#Extract region properties
partProps = regionprops(label_image, intensity_image=i_grey)
#Return
return partProps
def handleBFOTO(self):
#view = 0
v = 0
self.views[v].clear()
#TODO take picture with webcam (openCV)
os.system("streamer -c /dev/video1 -s 1280x960 -o ./img/foto.ppm")
#os.system("streamer -c /dev/video0 -s 1920x1080 -o ./img/foto.ppm")
os.system("convert ./img/foto.ppm ./img/test.png")
path = './img/test.png'
img = rgb2gray(io.imread(path))
#img = equalize_hist(rgb2gray(io.imread(path)))
io.imsave('./img/testGRAY.png', img)
# thresholding
#thresh = threshold_mean(img)
#thresh = threshold_otsu(img)
thresh = threshold_minimum(img)
print(thresh)
binary = img > thresh
io.imsave('./img/testTH.png', img_as_uint(binary))
# adaptive thresholding
#block_size = 35
#adaptive_thresh = threshold_local(img, block_size, offset=10)
#binary_adaptive = img > adaptive_thresh
#io.imsave('./testTHadapt.png', img_as_uint(binary))
# load iamge
path = './img/testTH.png'
self.loadIMG(path,v)
def _auto_crop(image, expand=20):
"""
Automated-crop based on the biggest darkest object.
Parameters
----------
image : ndarray
Full image.
expand : scalar
Expand by this number of pixels.
Returns
-------
cropped
Notes
-----
The original image is thresholded with a minimum threshold to get the
darkest pixels.
"""
import numpy as np
from skimage import measure
from skimage import filters
darkest = image < filters.threshold_minimum(image)
labels = measure.label(darkest)
props = measure.regionprops(labels)
areas = np.array([prop.area for prop in props])
bb = props[areas.argmax()].bbox
return image[bb[0] - expand:bb[2] + expand, bb[1] - expand:bb[3] + expand]
def preprocess(filename):
"""Perform image processing to isolate characters from page background"""
# Read in image
filename_wo_extension = filename.split('.')[0]
page = io.imread(filename, as_grey=True)
# Blur the image
page_blur = filters.gaussian(page)
# Logarithmic correction to even background color
page_logarithmic_corrected = exposure.adjust_log(page_blur, 1)
# Increase contrast
p3, p98 = np.percentile(page_logarithmic_corrected, (3, 98))
page_contrast = exposure.rescale_intensity(page_logarithmic_corrected, in_range=(p3, p98))
# Separate characters from background and remove anythind touching the edge
page_filter = page_contrast < filters.threshold_minimum(page_contrast)
page_filter = segmentation.clear_border(page_filter)
# Remove specks
page_clean = morphology.remove_small_objects(page_filter, 30)
# Dilate characters
page_dilate = morphology.binary_dilation(page_clean);
page_dilate = morphology.binary_dilation(page_dilate);
page_dilate = morphology.binary_dilation(page_dilate);
page_dilate = morphology.binary_dilation(page_dilate);
return page_dilate
def crop_im(pil_image):
w, h = pil_image.size
if w > 1000:
pil_image = tr.Resize([1000, 1000])(pil_image)
try:
with warnings.catch_warnings():
warnings.simplefilter("ignore")
with np.errstate(divide='ignore'):
im = np.array(pil_image)
im_v = equalize_adapthist(rgb2hsv(im)[:, :, 2])
thresh = threshold_minimum(im_v)
binary = im_v > thresh
label_img = label(binary)
regions = regionprops(label_img)
areas = [r.area for r in regions]
largest_cc_idx = np.argmax(areas)
fov = regions[largest_cc_idx]
cropped = im[fov.bbox[0]:fov.bbox[2],
fov.bbox[1]:fov.bbox[3], :]
fov_im = binary_fill_holes(regions[largest_cc_idx].image)
if cropped.shape[1] > 512:
return Image.fromarray(cropped), Image.fromarray(
255 * fov_im.astype('uint8'))
else:
return pil_image, Image.fromarray(
255 * np.ones(pil_image.size).astype('uint8'))
except:
return pil_image, Image.fromarray(
255 * np.ones(pil_image.size).astype('uint8'))
def __call__(self, img):
# img is a numpy rgb image
grey_img = rgb2grey(img)
t1 = filters.threshold_minimum(grey_img)
t2 = filters.threshold_yen(grey_img)
img1 = mark_boundaries(img, (grey_img > t1), color=(1, 0, 0))
img1 = mark_boundaries(img1, (grey_img > t2), color=(1, 0, 0))
img2 = mark_boundaries(img, grey_img < 0)
img = ((img1 + img2) / 2)
#img = mark_boundaries(img, quickshift(img_as_float(img), kernel_size =5, max_dist = 10, ratio = 1.0))
#img = mark_boundaries(img, slic(img_as_float(img), n_segments=10))
#fimg = rgb2grey(img)
#t = filters.threshold_otsu(fimg)
#img = mark_boundaries(img, (fimg > t).astype(np.uint8), color=(1,0,0))
#img = mark_boundaries(img, (fimg - filters.threshold_niblack(fimg)< 0).astype(np.uint8), color=(1,0,0))
#img_gray = rgb2grey(img)
#img_gray = img[:, :, 1]
# morphological opening (size tuned on training data)
#circle7 = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (7, 7))
#img_open = cv2.morphologyEx(img_gray, cv2.MORPH_OPEN, circle7)
# Otsu thresholding
#img_th = cv2.threshold(img_open, 0, 255, cv2.THRESH_OTSU)[1]
# Invert the image in case the objects of interest are in the dark side
#if (np.sum(img_th == 255) > np.sum(img_th == 0)):
# img_th = cv2.bitwise_not(img_th)
# second morphological opening (on binary image this time)
#bin_open = cv2.morphologyEx(img_th, cv2.MORPH_OPEN, circle7)
# connected components
#img = mark_boundaries(img,cv2.connectedComponents(bin_open)[1], color=(1,0,0))
return (img * 255).astype(np.uint8)
def threshold(image):
""" Does thresholding
"""
image = np.asarray(image)
image = np.dot(image[...,:3], [0.299, 0.587, 0.114])
thresh = threshold_minimum(image[:,:])
return image[:,:] > thresh
def binary(img, method):
"""Threshold image
:param img: grayscale image (numpy array)
:param method: thresholding method
:return: binary image
"""
if method == 'otsu':
thresh = threshold_otsu(img)
binary = img > thresh
elif method == 'mean':
thresh = threshold_mean(img)
binary = img > thresh
binary = 1 - binary
elif method == 'local':
thresh = threshold_local(img, 35, offset=10)
binary = img > thresh
else:
thresh = threshold_minimum(img)
binary = img > thresh
return binary
def analyze_watershed(image):
"""Returns bright on dark particles using a watershed algorithm
Implements contrast stretching, sobel edge detection and a watershed algortihm to detect particles
Cleanup is performed by closing and removing the particles that contact the clear_border
"""
#Convert to grayscale
i_grey = rgb2gray(image)
#Convert to uint8
i_uint = img_as_ubyte(i_grey)
#Contrast stretching
p2, p98 = np.percentile(i_uint, (2, 98))
i_contStretch = exposure.rescale_intensity(i_uint, in_range=(p2, p98))
#Construct elevation map
elevation_map = sobel(i_contStretch)
#Create markers using extremes of the intensity histogram
markers = np.zeros_like(i_uint)
threshold = threshold_minimum(i_contStretch)
markers[i_uint < 0.7 * threshold] = 1
markers[i_uint > 1.3 * threshold] = 2
#Apply the watershed algorithm for segmentation
i_segmented = watershed(elevation_map, markers)
#Close open domains
i_closed = closing(i_segmented, square(3))
#Remove artifacts connected to image border
i_cleared = clear_border(i_closed)
#Label image regions
label_image = label(i_cleared)
#Extract region properties
partProps = regionprops(label_image, intensity_image=i_grey)
#Return
return partProps
def call_doublets(self, threshold=None, verbose=True):
''' Call trancriptomes as doublets or singlets
Arguments
---------
threshold : float, optional (default: None)
Doublet score threshold for calling a transcriptome
a doublet. If `None`, this is set automatically by looking
for the minimum between the two modes of the `doublet_scores_sim_`
histogram. It is best practice to check the threshold visually
using the `doublet_scores_sim_` histogram and/or based on
co-localization of predicted doublets in a 2-D embedding.
verbose : bool, optional (default: True)
If True, print summary statistics.
Sets
----
predicted_doublets_, z_scores_, threshold_,
detected_doublet_rate_, detectable_doublet_fraction,
overall_doublet_rate_
'''
if threshold is None:
# automatic threshold detection
# http://scikit-image.org/docs/dev/api/skimage.filters.html
from skimage.filters import threshold_minimum
threshold = threshold_minimum(self.doublet_scores_sim_)
if verbose:
print("Automatically set threshold at doublet score = {:.2f}".
format(threshold))
Ld_obs = self.doublet_scores_obs_
Ld_sim = self.doublet_scores_sim_
se_obs = self.doublet_errors_obs_
Z = (Ld_obs - threshold) / se_obs
self.predicted_doublets_ = Ld_obs > threshold
self.z_scores_ = Z
self.threshold_ = threshold
self.detected_doublet_rate_ = (Ld_obs > threshold).sum() / float(
len(Ld_obs))
self.detectable_doublet_fraction_ = (Ld_sim > threshold).sum() / float(
len(Ld_sim))
self.overall_doublet_rate_ = self.detected_doublet_rate_ / self.detectable_doublet_fraction_
if verbose:
print('Detected doublet rate = {:.1f}%'.format(
100 * self.detected_doublet_rate_))
print('Estimated detectable doublet fraction = {:.1f}%'.format(
100 * self.detectable_doublet_fraction_))
print('Overall doublet rate:')
print('\tExpected = {:.1f}%'.format(100 *
self.expected_doublet_rate))
print('\tEstimated = {:.1f}%'.format(100 *
self.overall_doublet_rate_))
return self.predicted_doublets_
def thinning(image_abs_path,i):
grayscale_img = imread(image_abs_path, as_gray=True)
gaussian_blur = gaussian(grayscale_img, sigma=1)
thresh_sauvola = threshold_minimum(gaussian_blur)
binary_img = gaussian_blur < thresh_sauvola
thinned_img = skeletonize(binary_img)
thinned_img = thinned_img == 0
plt.imsave('output.png',thinned_img, format="png", cmap="hot")
plt.imsave('output_'+str(i)+'.png',thinned_img, format="png", cmap="hot")
def threshold(self, thresh, **kwargs):
"""Threshold the image
Parameters
----------
thresh : str or float
If a float in [0,1] is provided, pixels whose grayscale value is
above said threshold will be white, others black.
A number of additional methods are supported:
* 'mean': Threshold image based on the mean of grayscale values.
* 'minimum': Threshold image based on the minimum method, where
the histogram of the input image is computed and
smoothed until there are only two maxima.
* 'local': Threshold image based on `local pixel neighborhood
<https://scikit-image.org/docs/stable/api/skimage.filters.html#skimage.filters.threshold_local>_.
Requires ``block_size``: odd number of pixels in the
neighborhood.
* 'otsu': `Otsu's method
<https://scikit-image.org/docs/stable/api/skimage.filters.html#skimage.filters.threshold_otsu>_
* 'isodata': `ISODATA method
<https://scikit-image.org/docs/stable/api/skimage.filters.html#skimage.filters.threshold_isodata>`_,
also known as the Ridler-Calvard method or
intermeans.
Returns
-------
stim : `ImageStimulus`
A copy of the stimulus object with two gray levels 0.0 and 1.0
"""
if len(self.img_shape) > 2:
raise ValueError("Thresholding is only supported for grayscale "
"(i.e., single-channel) images. Use `rgb2gray` "
"first.")
img = self.data.reshape(self.img_shape)
if isinstance(thresh, str):
if thresh.lower() == 'mean':
img = img > threshold_mean(img)
elif thresh.lower() == 'minimum':
img = img > threshold_minimum(img, **kwargs)
elif thresh.lower() == 'local':
img = img > threshold_local(img, **kwargs)
elif thresh.lower() == 'otsu':
img = img > threshold_otsu(img, **kwargs)
elif thresh.lower() == 'isodata':
img = img > threshold_isodata(img, **kwargs)
else:
raise ValueError("Unknown threshold method '%s'." % thresh)
elif np.isscalar(thresh):
img = self.data.reshape(self.img_shape) > thresh
else:
raise TypeError("Threshold type must be str or float, not "
"%s." % type(thresh))
return ImageStimulus(img,
electrodes=self.electrodes,
metadata=self.metadata)
def load_image(self, filename):
new_image = io.imread(filename, as_gray=True)
new_image = (np.iinfo(self.camera.dtype).max *
(new_image / new_image.max()))
new_image = transform.resize(new_image, self.camera.shape).astype(
self.camera.dtype)
new_image = new_image > filters.threshold_minimum(new_image)
self.camera[:] = np.iinfo(self.camera.dtype).max * new_image.astype(
self.camera.dtype).copy()
def threshold_minimum(arr1d):
"""
doesnt work: Unable to find two maxima in histogram
:param arr1d:
:return:
"""
import skimage.filters as sf
thresh = sf.threshold_minimum(arr1d, nbins=256, max_iter=100)
return thresh
class BinaryAlg:
_operations = {
'Isodata': lambda x : 1*((abs(x) > skfilters.threshold_isodata(x))),
'Li': lambda x : 1*((abs(x) > skfilters.threshold_li(x))),
'Mean': lambda x : 1*((abs(x) > skfilters.threshold_mean(x))),
'Minimum': lambda x : 1*((abs(x) > skfilters.threshold_minimum(x))),
'Otsu': lambda x : 1*((abs(x) > skfilters.threshold_otsu(x))),
'Triangle': lambda x : 1*((abs(x) > skfilters.threshold_triangle(x))),
'Yen': lambda x : 1*((abs(x) > skfilters.threshold_yen(x)))
}
def create_stare_mask(image, image_path=None):
im_gray = rgb2gray(image)
thresh_val = threshold_minimum(im_gray)
mask = np.where(im_gray > thresh_val, 1, 0)
# Make sure the larger portion of the mask is considered background
if np.sum(mask == 0) < np.sum(mask == 1):
mask = np.where(mask, 0, 1)
if image_path:
save_image(image_path, mask)
return mask
def region_analyzer(I, pts, maxitter=100):
Igg = I.copy() #going to make BW img out of green channel
Igg[:, :, 0] = Igg[:, :, 1] #red and blue get same values as green channel
Igg[:, :, 2] = Igg[:, :, 1]
thresh = threshold_minimum(Igg)
#cutoff between B & W ####MAY NEED TO CHANGE IF IT DOESNT WORK
detect = 0
itter = 0
while pts > detect:
IBinary = (Igg[:, :, 2] > thresh
) #array where true at brightness > threshold
# plt.imshow(IBinary)
IBinaryFix = clear_border(1 - closing(IBinary, square(3)))
# plt.imshow(IBinaryFix)
label_image = label(
IBinaryFix) # find and lable all white contiguous shapes
region_properties = regionprops(
label_image) #get properties of labeled regions
# #For all the properties you can assess see:
# # http://scikit-image.org/docs/dev/api/skimage.measure.html
n = len(region_properties) #number of objects detected
e = np.zeros(n) #container for our eccentricities
middle = np.zeros([n, 2])
i = 0
dim = np.shape(I)
tol = 0.001 * (
dim[0] * dim[1]
) #####May need to change if it doesnt work based on picture and dot size
param_save = np.zeros([n, 4])
for region in region_properties:
# take regions with large enough areas
if region.filled_area >= tol:
# draw rectangle around segmented coins
minr, minc, maxr, maxc = region.bbox #object's bounding box
param_save[i, :] = np.array([minr, minc, maxr, maxc])
e[i] = region.eccentricity #closer to 0 is closer to circle
# bx = (minc, maxc, maxc, minc, minc)
# by = (minr, minr, maxr, maxr, minr)
y0, x0 = region.centroid
# plt.plot(bx, by, '-b', linewidth=2.5)
# plt.plot(x0,y0,'or')
middle[i, :] = x0, y0
i += 1 #advance
detect = len(np.nonzero(e)[0])
if np.mean(IBinary) > 0.5:
thresh = thresh + 0.01 * thresh
elif np.mean(IBinary <= 0.5):
thresh = thresh - 0.01 * thresh
itter += 1
if itter == maxitter:
break
return e, middle
def thresh(self):
"""Automatically choose a threshold based on the counts"""
try:
thresh = threshold_minimum(np.array(self.c), 25)
int(np.log(thresh)) # ValueError if thresh <= 0
self.t = int(thresh)
except (ValueError, RuntimeError, OverflowError):
try:
self.t = int(0.5*(max(self.c) + min(self.c)))
int(np.log(self.t)) # ValueError if thresh <= 0
except (ValueError, TypeError, OverflowError):
self.t = 1
self.threshedit.setText(str(self.t))
def rgb2gray(filepath):
'''
Function
- takes filepath of image,
- converts image to gray scale,
- resizes, downsamples and denoises image (optional)
- flattens image to vector of length 424*424
returns vector
'''
img = imread(filepath)
if (gray):
gray_img = np.dot(img[..., :3], [0.299, 0.587, 0.144])
else:
gray_img = np.asarray(img)
gray_img = gray_img.astype('float32')
if (scaling == True):
start = 424 // 2 - scaling_param // 2
stop = 424 // 2 + scaling_param // 2
gray_img = gray_img[start:stop, start:stop]
if (downsampling == True):
gray_img = downscale_local_mean(gray_img, (ds_param, ds_param))
if (normalising == True):
if (gray):
gray_img = (gray_img - np.min(gray_img)) / (np.max(gray_img) -
np.min(gray_img))
else:
gray_img[:, :,
0] = (gray_img[:, :, 0] - np.mean(gray_img[:, :, 0])) / (
np.max(gray_img[:, :, 0]) -
np.mean(gray_img[:, :, 0]))
gray_img[:, :,
1] = (gray_img[:, :, 1] - np.mean(gray_img[:, :, 1])) / (
np.max(gray_img[:, :, 1]) -
np.mean(gray_img[:, :, 1]))
gray_img[:, :,
2] = (gray_img[:, :, 2] - np.mean(gray_img[:, :, 2])) / (
np.max(gray_img[:, :, 2]) -
np.mean(gray_img[:, :, 2]))
if (denoising == True):
gray_img = denoise_tv_chambolle(gray_img, weight=0.02)
if (contouring == True):
try:
thresh = filters.threshold_minimum(gray_img)
except RuntimeError:
thresh = filters.threshold_otsu(gray_img)
#print(np.mean(gray_img))
gray_img = gray_img > thresh
gray_img = gray_img.flatten()
return gray_img
def prepWhole(img):
# type: (np.ndarray) -> Tuple[np.ndarray,np.ndarray,np.ndarray]
# cv2.imshow('C',img)
img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
img = cv2.medianBlur(img, 5)
cv2.imwrite('median.jpg', img)
# cv2.imshow('G',img)
# img = cv2.resize(img,(45,45),interpolation=cv2.INTER_CUBIC)
# cv2.imshow('sz',img)
adap = fl.threshold_minimum(img)
print(adap)
# if adap<127: adap=130
temp, img = cv2.threshold(img, adap, 255, cv2.THRESH_BINARY_INV)
# block_size = 35
# adaptive_thresh = fl.threshold_local(img, block_size, offset=10)
# img = 255*(img > adaptive_thresh)
# img = cv2.adaptiveThreshold(img, 255, 1, 1, 11, 2)
# blur = cv2.GaussianBlur(img, (5, 5), 0)
# ret3, img = cv2.threshold(blur, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
# cv2.imshow('T',img)
size = np.size(img)
skel = np.zeros(img.shape, np.uint8)
element = cv2.getStructuringElement(cv2.MORPH_CROSS, (3, 3))
done = False
# thresh = img
img = cv2.dilate(img, None, iterations=3)
img = cv2.erode(img, None, iterations=2)
thresh = img
edges = cv2.Canny(thresh, 100, 200)
while (not done):
eroded = cv2.erode(img, element)
temp = cv2.dilate(eroded, element)
temp = cv2.subtract(img, temp)
skel = cv2.bitwise_or(skel, temp)
img = eroded.copy()
zeros = size - cv2.countNonZero(img)
if zeros == size:
done = True
# skel=cv2.erode(skel,element)
# cv2.imshow("skel", skel)
# out=skel
# skel = cv2.dilate(skel, None, iterations=3)
# skel = cv2.erode(skel, None, iterations=2)
# skel = cv2.medianBlur(skel, 5)
# temp=1*(thresh>127)
# skel = 255*skeletonize(temp)
return skel, thresh, edges
def get_binary(args, image, file: str, binpath: str) -> str:
"""
Binarize image with different algorithms
:param args:
:param image:
:param file:
:param binpath:
:return:
"""
if not os.path.exists(binpath + file.split('/')[-1]):
create_dir(binpath)
uintimage = get_uintimg(image)
if args.filter == "sauvola":
thresh = imgfilter.threshold_sauvola(uintimage, args.threshwindow,
args.threshweight)
binary = image > thresh
elif args.filter == "niblack":
thresh = imgfilter.threshold_niblack(uintimage, args.threshwindow,
args.threshweight)
binary = thresh
elif args.filter == "otsu":
thresh = imgfilter.threshold_otsu(uintimage, args.threshbin)
binary = image <= thresh
elif args.filter == "yen":
thresh = imgfilter.threshold_yen(uintimage, args.threshbin)
binary = image <= thresh
elif args.filter == "triangle":
thresh = imgfilter.threshold_triangle(uintimage, args.threshbin)
binary = image > thresh
elif args.filter == "isodata":
thresh = imgfilter.threshold_isodata(uintimage, args.threshbin)
binary = image > thresh
elif args.filter == "minimum":
thresh = imgfilter.threshold_minimum(uintimage, args.threshbin,
args.threshitter)
binary = image > thresh
elif args.filter == "li":
thresh = imgfilter.threshold_li(uintimage)
binary = image > thresh
elif args.filter == "mean":
thresh = imgfilter.threshold_mean(uintimage)
binary = image > thresh
else:
binary = uintimage
with warnings.catch_warnings():
# Transform rotate convert the img to float and save convert it back
warnings.simplefilter("ignore")
misc.imsave(binpath + file.split('/')[-1], binary)
return binpath + file.split('/')[-1]
def get_fov(img):
im_s = img.size
if max(im_s) > 500:
img = Resize(500)(img)
with np.errstate(divide='ignore'):
im_v = equalize_adapthist(np.array(img))[:, :, 1]
# im_v = equalize_adapthist(rgb2hsv(np.array(img))[:, :, 2])
thresh = threshold_minimum(im_v)
binary = binary_fill_holes(im_v > thresh)
x0, y0, r = get_circ(binary)
fov = create_circular_mask(binary.shape, center=(x0, y0), radius=r)
return Resize(im_s[ : :-1])(Image.fromarray(fov))
def binarize(image_abs_path):
# Convert color image (3-channel deep) into grayscale (1-channel deep)
# We reduce image dimensionality in order to remove unrelevant features like color.
grayscale_img = imread(image_abs_path, as_grey=True)
# Apply Gaussian Blur effect - this removes image noise
gaussian_blur = gaussian(grayscale_img, sigma=1)
# Apply minimum threshold
thresh_sauvola = threshold_minimum(gaussian_blur)
# Convert thresh_sauvola array values to either 1 or 0 (white or black)
binary_img = gaussian_blur > thresh_sauvola
return binary_img
def binarize_curv(filter_img, im_name, output_path, save_img=False):
"""Binarizes the filtered output of the fibermorph.filter_curv function.
Parameters
----------
filter_img : np.ndarray
Image after ridge filter (float64).
im_name : str
Image name.
output_path : str or pathlib object
Output directory path.
save_img : bool
True or false for saving image.
Returns
-------
np.ndarray
An array with the binarized image.
"""
selem = skimage.morphology.disk(3)
thresh_im = filter_img > threshold_minimum(filter_img)
# clear the border of the image (buffer is the px width to be considered as border)
cleared_im = skimage.segmentation.clear_border(thresh_im, buffer_size=10)
# dilate the hair fibers
binary_im = scipy.ndimage.binary_dilation(cleared_im,
structure=selem,
iterations=2)
if save_img:
output_path = make_subdirectory(output_path, append_name="binarized")
# invert image
save_im = skimage.util.invert(binary_im)
# save image
with pathlib.Path(output_path).joinpath(im_name +
".tiff") as save_name:
im = Image.fromarray(save_im)
im.save(save_name)
return binary_im
else:
return binary_im
def threshold(data, process_param):
if process_param["threshold"] == "otsu":
thresh = threshold_otsu(data)
if process_param["threshold"] == "mean":
thresh = threshold_mean(data)
if process_param["threshold"] == "minimum":
thresh = threshold_minimum(data)
if process_param["threshold"] == "yen":
thresh = threshold_yen(data)
if process_param["threshold"] == "isodata":
thresh = threshold_isodata(data)
if process_param["threshold"] == "li":
thresh = threshold_li(data)
if process_param["threshold"] == "local":
thresh = threshold_local(data, process_param["local_size"])
if process_param["threshold"] == "local_otsu":
selem = disk(process_param["local_size"])
data = data.astype(np.float64)
data = data - np.min(data)
data = np.uint8(255 * data / np.max(data))
thresh = rank.otsu(data, selem)
if process_param["threshold"] == "lg_otsu":
selem = disk(process_param["local_size"])
data = data.astype(np.float64)
data = data - np.min(data)
data = np.uint8(255 * data / np.max(data))
threshl = rank.otsu(data, selem)
threshg = threshold_otsu(data)
if process_param["threshold"] == "niblack":
thresh = threshold_niblack(data, process_param["local_size"])
mask = data > thresh
if process_param["threshold"] == "sauvola":
thresh = threshold_sauvola(data, process_param["local_size"])
mask = data > thresh
if process_param["threshold"] == "lg_otsu":
mask1 = data >= threshl
mask2 = data > threshg
mask = mask1 * mask2
elif process_param["threshold"] == "local_otsu":
mask = data >= thresh
else:
mask = data > thresh
labels = label(mask)
return (labels)
def vein_detection(OriginalImg, singleCellMask=[]):
gray = skimage.color.rgb2gray(OriginalImg)
if singleCellMask != []:
thres = filters.threshold_minimum(gray)
leaf_mask = ~(gray > thres) # plt. figure(),plt.imshow(leaf_mask)
leaf_mask = morphology.binary_closing(
leaf_mask, morphology.disk(2)) # remove small dark spots
else:
leaf_mask = generate_single_cellMask(OriginalImg)
vein_image = -(gray * leaf_mask)
imadjusted = exposure.rescale_intensity(vein_image)
vein = feature.canny(imadjusted)
vein = vein * 255
return vein
def thresh_and_binarize(image_,
method='rosin',
invert=True,
min_size=10,
thr_percent=95):
"""
receives greyscale np.ndarray image
inverts the intensities
thresholds on the minimum peak
converts the image into binary about that threshold
:param image_: np.ndarray
:param method: str
'bimodal' or 'unimodal'
:return: spots threshold_min on this image
"""
if invert:
image_ = u.invert(image_)
if method == 'bimodal':
thresh = threshold_minimum(image_, nbins=512)
spots = copy(image_)
spots[image_ < thresh] = 0
spots[image_ >= thresh] = 1
elif method == 'otsu':
spots = create_otsu_mask(image_, scale=1)
elif method == 'rosin':
spots = create_unimodal_mask(image_, str_elem_size=3)
elif method == 'bright_spots':
spots = image_ > np.percentile(image_, thr_percent)
str_elem = disk(min_size)
# spots = binary_closing(spots, str_elem)
spots = binary_opening(spots, str_elem)
spots = clear_border(spots)
else:
raise ModuleNotFoundError(
"not a supported method for thresh_and_binarize")
return spots
plt.show()
######################################################################
# Bimodal histogram
# =================
#
# For pictures with a bimodal histogram, more specific algorithms can be used.
# For instance, the minimum algorithm takes a histogram of the image and smooths it
# repeatedly until there are only two peaks in the histogram.
from skimage.filters import threshold_minimum
image = data.camera()
thresh_min = threshold_minimum(image)
binary_min = image > thresh_min
fig, ax = plt.subplots(2, 2, figsize=(10, 10))
ax[0, 0].imshow(image, cmap=plt.cm.gray)
ax[0, 0].set_title('Original')
ax[0, 1].hist(image.ravel(), bins=256)
ax[0, 1].set_title('Histogram')
ax[1, 0].imshow(binary_min, cmap=plt.cm.gray)
ax[1, 0].set_title('Thresholded (min)')
ax[1, 1].hist(image.ravel(), bins=256)
ax[1, 1].axvline(thresh_min, color='r')
# =================
#
# For pictures with a bimodal histogram, more specific algorithms can be used.
# For instance, the minimum algorithm takes a histogram of the image and smooths it
# repeatedly until there are only two peaks in the histogram. Then it
# finds the minimum value between the two peaks. After smoothing the
# histogram, there can be multiple pixel values with the minimum histogram
# count, so you can pick the 'min', 'mid', or 'max' of these values.
#
from skimage.filters import threshold_minimum
image = data.camera()
thresh_min = threshold_minimum(image, bias='min')
binary_min = image > thresh_min
thresh_mid = threshold_minimum(image, bias='mid')
binary_mid = image > thresh_mid
thresh_max = threshold_minimum(image, bias='max')
binary_max = image > thresh_max
fig, axes = plt.subplots(4, 2, figsize=(10, 10))
ax = axes.ravel()
ax[0].imshow(image, cmap=plt.cm.gray)
ax[0].set_title('Original')
ax[0].axis('off')
ax[1].hist(image.ravel(), bins=256)
ax[1].set_title('Histogram')
