def PlayGame(model):
# get init image
reward, image, end = pong.sweet(10)
image = rgb2gray(image)
image = resize(image, (80, 80))
thresh = threshold_mean(image)
binary = image > thresh
binary = np.expand_dims(binary, axis=2)
reward = 0
policy_images = []
policy_action = []
while True:
action = model.predict(np.expand_dims(binary, axis=0))
reward_now, nextImage, end = pong.sweet(action)
if end:
break
policy_images.append(binary)
policy_action.append(action)
if reward_now > reward:
reward = reward_now
nextImage = rgb2gray(nextImage)
nextImage = resize(image, (80, 80))
thresh = threshold_mean(nextImage)
binary = nextImage > thresh
binary = np.expand_dims(binary, axis=2)
return reward, np.asarray(policy_images), np.asarray(policy_action)
def burst_intensity(Data, n):
intensity_matrix = Data[n]
intensity_list = intensity_matrix.tolist()
time = list(xrange(180))
plt.plot(time, intensity_list, 'k')
#plt.xlim([200,300])
plt.xlim([50, 150])
plt.xlabel('Time (Seconds)')
plt.ylabel('Intensity')
plt.title('Burst Intensity at 55 Mhz')
#plt.hlines(threshold_otsu(Data), 100, 400, 'r', linestyles='dashed', label='Otsu')
#plt.hlines(threshold_yen(Data), 100, 400, 'b', linestyles='dashed', label='Yen')
#plt.hlines(threshold_isodata(Data), 100, 400, 'r', linestyles='dashed', label='Isodata')
#plt.hlines(threshold_li(Data), 100, 400, 'g', linestyles='dashed', label='Li')
#plt.hlines(threshold_minimum(Data), 100, 400, 'c', linestyles='dashed', label='Minimum')
plt.hlines(threshold_mean(Data),
0,
400,
'y',
linestyles='dashed',
label='Mean')
#plt.hlines(threshold_triangle(Data), 100, 400, 'k', linestyles='dashed', label='Triangle')
mean_1std = np.std(Data) + threshold_mean(Data)
mean_2std = np.std(Data) + np.std(Data) + threshold_mean(Data)
plt.hlines(mean_1std, 0, 400, 'r', linestyles='dashed', label='1σ')
plt.hlines(mean_2std, 0, 400, 'r', linestyles='solid', label='2σ')
plt.legend(loc='upper right', title="Thresholds")
plt.show
def _threshold_image(image_array, k, lightbg, darkbg):
"""
Handler to properly threshold the image_array to a binary image of
foreground and background. Algorithm used is a k-means clustering.
:param image_array:
:return: a 2D binary image
"""
channel_image = ImageSegmenter._optimal_thresholding_channel_image(
image_array)
#histogram = ImageSegmenter._image_histogram(channel_image)
#cluster_vector = ImageSegmenter._k_means_iterate(histogram, k)
#has_light_bg = sum(histogram[0:50]) < sum(histogram[205:])
#t0_min = threshold_minimum(image_array)
if (lightbg == 'auto' and darkbg == 'auto'):
# filter the image slightly
sizefoot = [2, 2]
channel_image = ndimage.median_filter(channel_image, sizefoot)
channel_image = adjust_gamma(channel_image, gamma=1.4, gain=1)
histogram = ImageSegmenter._image_histogram(channel_image)
t0_min = threshold_mean(
channel_image[0:np.argwhere(channel_image).max(0)[0],
0:np.argwhere(channel_image).max(0)[1]])
has_light_bg = sum(histogram[0:5]) < sum(histogram[250:])
else:
channel_image = ImageSegmenter._optimal_thresholding_channel_image(
image_array)
histogram = ImageSegmenter._image_histogram(channel_image)
t0_min = threshold_mean(channel_image)
has_light_bg = sum(histogram[0:5]) < sum(histogram[250:])
return ImageSegmenter._apply_cluster_threshold(
t0_min, channel_image, has_light_bg, lightbg,
darkbg) # ImageSegmenter._has_dark_objects(channel_image))
def game(center):
global V
global zone
global img_rgb
global zone2
global count_of_jps
state = 0
V = 110.0
count_of_jps = 0
for i in range(100000):
img_rgb = get_img()
img_gray = cv2.cvtColor(img_rgb, cv2.COLOR_BGR2GRAY)
thresh = threshold_mean(img_gray)
binary = (img_gray > thresh).astype(int)
x_start, x_end = center[0] + width // 2, center[0] + width // 2 + int(
V)
y_start, y_end = center[1] - height // 2, center[1] + height // 2 - 15
zone = binary[y_start:y_end, x_start:x_end]
yt_start, yt_end = center[1] - height // 2, center[1] + height // 2 - 15
zone2 = binary[yt_start:yt_end, x_start:x_end]
if 0 in zone and state == 0:
press()
count_of_jps += 1
V += (8.0 / 60)
state = 1
if (0 not in zone2) and state == 1:
state = 2
down()
if (0 in zone2) and state == 2:
state = 0
def threshold(img):
#img = color.rgb2grey(img)
#img = img[:,:,2]
img = color.rgb2grey(img)
thresh = filters.threshold_mean(img)
binary = img > thresh
return binary
def count_seg(filename):
image = io.imread(filename)
gray_image = color.rgb2gray(np.invert(image))
thresh = filters.threshold_mean(gray_image)
binary = gray_image > thresh
label_arr, num_seg = ndi.label(np.invert(binary))
return num_seg
def countCirciulatyC1(nda):
thresh = threshold_mean(nda)
binary = nda > thresh
count = np.array(binary)
a = np.count_nonzero(count == True)
value = 2 * math.sqrt(a / math.pi)
labelFirstValue.configure(text=value)
def threshold(self, threshold_name):
if self.scene.circles:
self.scene.reset()
if self.current_augments['overlay_applied']:
del self.scene.coords
self.init_scene()
self.read_excel()
self.current_augments['overlay_applied'] = False
if threshold_name == "origional":
self.showimage(self.overview)
self.thresholdval = None
self.current_augments["threshold"] = False
return
self.thresholdval = threshold_name
im = rgb2gray(self.overview)
if threshold_name == "otsu":
threshold = threshold_otsu(im)
if threshold_name == "li":
threshold = threshold_li(im)
if threshold_name == "mean":
threshold = threshold_mean(im)
if threshold_name == "triangle":
threshold = threshold_triangle(im)
self.current_augments["threshold"] = threshold_name
self.current_image = im < threshold
self.showimage(self.current_image)
def find_roi_bbox_1(rgb_image, show=False): # rgb
# hsv -> 3 channel
hsv = cv2.cvtColor(rgb_image, cv2.COLOR_RGB2HSV)
# plt.imshow(hsv)
# plt.show()
thres = threshold_mean(hsv[..., 0])
# fig, ax = try_all_threshold(hsv[..., 0])
# plt.show()
mask = (hsv[..., 0] > thres).astype('uint8')
# close_kernel = np.ones((11, 11), dtype=np.uint8)
close_kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (11, 11))
image_close = cv2.morphologyEx(np.array(mask), cv2.MORPH_CLOSE,
close_kernel)
# open_kernel = np.ones((7, 7), dtype=np.uint8)
open_kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (7, 7))
image_open = cv2.morphologyEx(np.array(image_close), cv2.MORPH_OPEN,
open_kernel)
image_open = cv2.morphologyEx(
np.array(image_open), cv2.MORPH_DILATE,
cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3)))
image_fill = hole_fill(image_open)
image_fill = max_prop(image_fill)
bounding_boxes, rgb_contour = get_bbox(np.array(image_fill), rgb_image,
show)
return bounding_boxes, rgb_contour, image_fill
def threshold(file='zones/0.png', t='otsu', img=None):
from skimage.filters import try_all_threshold
from skimage.filters import threshold_mean, threshold_li, threshold_otsu
if img is None:
img = misc.imread(file)
fig, ax = try_all_threshold(img, figsize=(10, 8), verbose=False)
plt.show()
thresh = None
if t == 'otsu':
thresh = threshold_otsu(img)
elif t == 'mean':
thresh = threshold_mean(img)
else:
thresh = threshold_li(img)
binary = img > thresh
fig, axes = plt.subplots(ncols=2, figsize=(8, 3))
ax = axes.ravel()
ax[0].imshow(img, cmap=plt.cm.gray)
ax[0].set_title('Original image')
ax[1].imshow(binary, cmap=plt.cm.gray)
ax[1].set_title('Result')
for a in ax:
a.axis('off')
plt.show()
return binary
def carve(roi, thresh=None, holes_area=None, return_unfilled=False):
"""Carve image by thresholding and filling in small holes.
Args:
roi: Image as Numpy array.
thresh: Value by which to threshold. Defaults to None, in which
case a mean threshold will be applied.
holes_area: Maximum area of holes to fill.
return_unfilled: True to return the thresholded by unfilled image.
Returns:
Tuple of ``roi_carved``, the carved image; ``maks``, the mask
used to carve; and, if ``return_unfilled`` is True, ``roi_unfilled``,
the image after carving but before filling in holes.
"""
roi_carved = np.copy(roi)
if thresh is None:
thresh = filters.threshold_mean(roi_carved)
mask = roi_carved > thresh
if holes_area:
pxs_orig = np.sum(mask)
mask = morphology.remove_small_holes(mask, holes_area)
print("{} pxs in holes recovered".format(np.sum(mask) - pxs_orig))
roi_unfilled = np.copy(roi_carved) if return_unfilled else None
roi_carved[~mask] = 0
if holes_area and return_unfilled:
return roi_carved, mask, roi_unfilled
return roi_carved, mask
def threshold_mean_filter(
folder
): # iterate through folders, assembling feature, label, and classname data objects
class_id = 0
features = []
labels = np.array([])
classnames = []
for root, dirs, filenames in os.walk(folder):
for d in sorted(dirs):
#print("Reading data from", d)
classnames.append(
d) # use the folder name as the class name for this label
files = os.listdir(os.path.join(root, d))
for f in files:
imgFile = os.path.join(root, d, f) # Load the image file
img = plt.imread(imgFile)
img = cv2.resize(
img,
(128,
128)) # Resizing all the images to insure proper reading
img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
threshold_mean_filt = threshold_mean(img)
features.append(threshold_mean_filt.ravel())
labels = np.append(
labels, class_id) # Add it to the numpy array of labels
class_id += 1
features = np.array(
features) # Convert the list of features into a numpy array
return features, labels, classnames
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 itcd(input_img,
smoothing=30,
min_distance=10,
thres_coef=1,
equalization=False):
"""
Returns boundaries of tree crowns in the imageself.
Implementation of canopies thresholding and watershed segmentation.
input_img: input image (np.array)
"""
if equalization:
with warnings.catch_warnings():
warnings.simplefilter("ignore")
input_img = equalize_adapthist(input_img)
img_gaussian = gaussian(input_img, smoothing)
canopy_mask = img_gaussian > thres_coef * threshold_mean(img_gaussian)
masked_gaussian = np.copy(img_gaussian)
masked_gaussian[canopy_mask == False] = 0
local_maxima = peak_local_max(masked_gaussian,
min_distance=min_distance,
exclude_border=0,
indices=False)
markers, n_labels = ndi.label(local_maxima)
segments = watershed(-img_gaussian, markers, mask=canopy_mask)
# has to be modified in order to segment not segemented areas further
# segments[np.where((segments==0) & (canopy_mask==True))] = n_labels+1
return segments
def montage_wb_ratio(input_image, patch_shape, n_filters, ele_print=False):
patches = view_as_windows(input_image, patch_shape)
patches = patches.reshape(-1, patch_shape[0] * patch_shape[1])[::8]
fb, _ = kmeans2(patches, n_filters, minit='random')
fb = fb.reshape((-1, ) + patch_shape)
fb_montage = montage2d(fb, fill=False, rescale_intensity=True)
shape_var = np.ceil(np.sqrt(n_filters))
elements = np.split(np.hstack(np.split(fb_montage, shape_var)),
shape_var**2,
axis=1)
del elements[n_filters:]
wb_ratios = []
bin_elements = []
for element in elements:
thresh = threshold_mean(element)
binary = element > thresh
ratio = np.sum(binary) / binary.size
wb_ratios.append(ratio)
if ele_print:
bin_elements.append(binary)
wb_ratios = sorted(wb_ratios, reverse=True)
if ele_print:
show_images(elements)
show_images(bin_elements)
return (wb_ratios)
def get_pixelsize(img):
# the linear measure is 20 micron
line_length=20
# 4th layer codes the pixelsize
im = np.asarray(img,dtype=np.uint8)
im_last=im[:,:,3]
thresh = filters.threshold_mean(im_last)
binary = im_last < thresh
label_img = measure.label(binary)
regions = measure.regionprops(label_img)
length=np.NaN
if len(regions)==1:
bb = regions[0].bbox
length=bb[3]-bb[1]
# length in pixel per micron
pixel_per_micron=length/line_length
else:
pixel_per_micron=1.5
if pixel_per_micron<1:
pixel_per_micron=1.5
return pixel_per_micron
def __apply_threshold(image_array):
"""
Apply a mean threshold to the image information so that
every mid-tones are converted to either black or white.
:param {Numpy.ndarray} image_array: Input image array
:return: {Numpy.ndarray} Bitmap containing only boolean values
"""
return image_array > threshold_mean(image_array)
def classify_border(border_array):
norm_arr = normalize(border_array)
kernel = np.ones((3, 3)).astype("uint8")
filtered_arr = opening(norm_arr, kernel)
# thres = threshold_triangle(filtered_arr)
thres = threshold_mean(filtered_arr)
thres_img = filtered_arr > thres
thres_img = thres_img.astype('uint8')
return thres_img
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 threshold_mean(arr1d):
"""
WORKS !!!
:param arr1d:
:return:
"""
import skimage.filters as sf
thresh = sf.threshold_mean(arr1d)
return thresh
def hysteresis(image, alpha=1.0):
"""Hystersis thresholding with low and high clipped values
determined by the mean, li and isodata threshold"""
low = np.min([alpha * threshold_mean(image), threshold_li(image)])
high = threshold_isodata(image)
threshold = apply_hysteresis_threshold(image, low, high)
return threshold
def getLowerThreshold(jellyimage):
"""
Returns the expected lower threshold of an image based on mean pixel intensity.
Through method testing the mean threshold was found to be best at segmenting the jellyfish
:param jellyimage: rgb np image array (shape: y, x, 3)
:return: float of intensity to threshold around
"""
grayJelly = getGrayJelly(jellyimage)
lower_bound = filters.threshold_mean(grayJelly)
return lower_bound
def preprocessing(d):
w, h = d.shape
threshold = threshold_mean(d)
# print(threshold)
binary_value = d > threshold #returns True or False
shift = 2 * (binary_value * 1) - 1 # Boolean to int conversion
# print(shift)
# Reshape
flatten = np.reshape(shift, (w * h))
return flatten
def preprocessing(img):
w, h = img.shape
# Thresholding
thresh = threshold_mean(img)
binary = img > thresh
shift = 2 * (binary * 1) - 1 # Boolian to int
# Reshape
flatten = np.reshape(shift, (w * h))
return flatten
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 max_thresholding(im):
'''Computes maximum projection and binarisation on images
Input: Image to process
Ouput: Image after Maximum projection and binarization
'''
max_im = np.max(im, axis=0)
thresh = threshold_mean(max_im)
binary_im = max_im > thresh
return binary_im
def _binarize(g_orig, erode=False, thresh_option='mean'):
g_orig = rescale(g_orig) # rescale mask to [0, 1]
thresh = threshold_mean(
g_orig) if thresh_option == 'mean' else threshold_local(
g_orig, block_size=15)
g = (g_orig > thresh).astype(np.float)
if erode: # Take 1-pixel radial erosion from the raw gt mask
g = erosion(g, disk(1))
return g
def label_segments(filename, savename='/testing_segment/', pwd=''):
imgname = filename.split('/')[-1][:-4]
image = io.imread(filename)
gray_image = color.rgb2gray(image)
thresh = filters.threshold_mean(gray_image)
binary = gray_image > thresh
bw_img = pwd + savename + imgname + '_binary.jpg'
cv2.imwrite(bw_img, binary * 255)
label_arr, num_seg = ndi.label(binary * 255)
segments = np.arange(1, num_seg + 1)
return binary, np.array(label_arr), segments, image
def removeBackground(img, hueValue, threshold=0):
distance = hueDistance(img, hueValue)
image_copy = img.copy()
if threshold == 0:
image_copy[distance < filters.threshold_mean(distance)] = 0
else:
image_copy[distance < threshold] = 0
return image_copy
def preprocessing(img, w=100, h=100):
# Resize image
img = resize(img, (w,h), mode='reflect')
# Thresholding
thresh = threshold_mean(img)
binary = img > thresh
shift = 2*(binary*1)-1 # Boolian to int
# Reshape
flatten = np.reshape(shift, (w*h))
return flatten
plt.show()
######################################################################
# How to apply a threshold?
# =========================
#
# Now, we illustrate how to apply one of these thresholding algorithms.
# This example uses the mean value of pixel intensities. It is a simple
# and naive threshold value, which is sometimes used as a guess value.
#
from skimage.filters import threshold_mean
image = data.camera()
thresh = threshold_mean(image)
binary = image > thresh
fig, axes = plt.subplots(ncols=2, figsize=(8, 3))
ax = axes.ravel()
ax[0].imshow(image, cmap=plt.cm.gray)
ax[0].set_title('Original image')
ax[1].imshow(binary, cmap=plt.cm.gray)
ax[1].set_title('Result')
for a in ax:
a.axis('off')
plt.show()
