def __call__(self, img_small):
m = morphology.square(self.square_size)
img_th = morphology.black_tophat(img_small, m)
img_sob = abs(filters.sobel_v(img_th))
img_closed = morphology.closing(img_sob, m)
threshold = filters.threshold_otsu(img_closed)
return img_closed > threshold
def getImage(i, imOriginal, mean):
if i == 0: #return a central crop of 99x99 pixels
resized = cv2.resize(imOriginal, (128, 128))
resized = resized * 256.0 - mean
return resized[14:113, 14:113]
rot = np.random.uniform(0, 360, 1).astype(int)[0] #Random rotations
rot = 90 * np.random.uniform(0, 4, 1).astype(int)[0] #Random rotations
# rot = 0
im_size = imOriginal.shape[0]
if (np.random.rand() > 0.5):
if (np.random.rand() > 0.5):
imOriginal = cv2.flip(imOriginal, 0)
else:
imOriginal = cv2.flip(imOriginal, 1)
scale = np.random.uniform(0.9, 1.1)
mat = cv2.getRotationMatrix2D((im_size / 2, im_size / 2), rot, scale=scale)
resized = cv2.warpAffine(img_out,
mat, (im_size, im_size),
borderValue=(255, 255, 255))
img_out = np.zeros((resized.shape[0], resized.shape[1], 3), dtype=np.uint8)
img_orig = resized[:, :, 0]
img_btop = 255 - black_tophat(img_orig, selem)
img_wtop = 255 - white_tophat(img_orig, selem)
img_out[:, :, 1] = img_btop
img_out[:, :, 2] = img_wtop
resized = cv2.resize(img_out, (128, 128))
resized = resized * 256.0 - mean #Geht richtig in den Keller auf Werte um 4, wenn man mean nicht abzieht
# offsetX = np.random.uniform(10,18,1).astype(int)[0]
# offsetY = np.random.uniform(10,18,1).astype(int)[0]
offsetX = np.random.uniform(0, 28, 1).astype(int)[0] #Random rotations
offsetY = np.random.uniform(0, 28, 1).astype(int)[0] #Random rotations
return resized[offsetY:(99 + offsetY), offsetX:(99 + offsetX)]
def detectCentroid(input):
# Centroid Detection and contouring
#Utilizing the Hough-Transform
kernel = np.ones((4, 4), np.float32) / 25
input = cv2.filter2D(input, -1, kernel)
output = black_tophat(input, disk(15))
blur = cv2.GaussianBlur(output, (5, 5), 0)
_, threshold = cv2.threshold(blur, 254, 255, 0)
threshold = threshold.astype('uint8')
centroid = cv2.HoughCircles(threshold, cv2.HOUGH_GRADIENT, 1, 100, param1=5, param2=10, minRadius=9, maxRadius=15)
# ensure at least some circles were found
if centroid is not None:
# Convert the circle parameters a, b and r to integers.
centroid = np.uint16(np.around(centroid))
for pt in tqdm(centroid[0, :]):
a, b, r = pt[0], pt[1], pt[2]
# Draw the circumference of the circle.
cv2.circle(threshold, (a, b), r, (78, 55, 128), 2)
# Draw a small circle (of radius 1) to show the center.
cv2.circle(threshold, (a, b), 1, (0, 0, 0), 3)
print(centroid)
cv2.destroyWindow("Original Image")
cv2.imshow("Centroid", threshold)
cv2.waitKey(0)
return threshold, a, b
def black_top_func(filename):
image = asarray(Image.open(filename))
image = rgb2gray(image)
image = black_tophat(image)
plt.imsave(filename, image, cmap='gray')
return filename
def subtract_background(image, elem='disk', radius=50, light_bg=False):
"""Background substraction using structure element.
Slightly adapted from: https://forum.image.sc/t/background-subtraction-in-scikit-image/39118/4
:param image: input image
:type image: NumPy.Array
:param elem: type of the structure element, defaults to 'disk'
:type elem: str, optional
:param radius: size of structure element [pixel], defaults to 50
:type radius: int, optional
:param light_bg: light background, defaults to False
:type light_bg: bool, optional
:return: image with background subtracted
:rtype: NumPy.Array
"""
# use 'ball' here to get a slightly smoother result at the cost of increased computing time
if elem == 'disk':
str_el = disk(radius)
if elem == 'ball':
str_el = ball(radius)
if light_bg:
img_subtracted = black_tophat(image, str_el)
if not light_bg:
img_subtracted = white_tophat(image, str_el)
return img_subtracted
def norm_image(path):
image = np.array(cv2.imread(path))
temp_img = gray_img = np.uint8(rgb2gray(image))
selem = disk(6)
b_tophat = black_tophat(gray_img, selem)
resultant_img = b_tophat + gray_img
median_img = cv2.medianBlur(resultant_img, 5)
gaussian_img = scipy.ndimage.filters.gaussian_filter(median_img,
sigma=1.90,
order=0,
output=None,
mode='reflect',
cval=0.0,
truncate=4.0)
xc, yc, r = center(gaussian_img)
R = radius(gaussian_img)
theta = np.arange(0.00, np.pi * 2, 0.01) #theta
rng = np.arange(0, 100)
norm_img = np.zeros((rng.size, theta.size))
for t in theta:
for rc in rng:
mc = (R - r) * (rc) / 100 + r
x = int(xc + mc * np.cos(t))
y = int(yc + mc * np.sin(t))
try:
norm_img[rc, np.where(theta == t)] = temp_img[x, y]
except Exception as e:
pass
return norm_img
def Analyze(input):
# perhaps we want to first normalize the image so the maximum pixel is 255, and minimum is 0
img = pydicom.dcmread(input)
normalizedImg = rescale(img.pixel_array)
normalizedImgO = normalizedImg.copy()
normalizedImg = (black_tophat(normalizedImg, disk(12)))
normalizedImg = cv2.GaussianBlur(normalizedImg, (5, 5), 3)
# apply hough transform
circles = cv2.HoughCircles(normalizedImg,
cv2.HOUGH_GRADIENT,
1,
100,
param1=100,
param2=5,
minRadius=3,
maxRadius=10)
# place circles and cente rectangle on image
if circles is not None:
# Convert the circle parameters a, b and r to integers.
circles = np.uint16(np.around(circles))
for pt in tqdm(circles[0, :]):
a, b, r = pt[0], pt[1], pt[2]
# Draw the circumference of the circle.
cv2.circle(normalizedImgO, (a, b), r, (0, 0, 0), 2)
print(circles)
return normalizedImgO
def getImage(i, imOriginal, mean):
if i == 0: #return a central crop of 99x99 pixels
resized = cv2.resize(imOriginal, (128, 128))
resized = resized * 256.0 - mean
return resized[14:113, 14:113]
rot = np.random.uniform(0,360,1).astype(int)[0] #Random rotations
rot = 90 * np.random.uniform(0,4,1).astype(int)[0] #Random rotations
# rot = 0
im_size = imOriginal.shape[0]
if (np.random.rand() > 0.5):
if (np.random.rand() > 0.5):
imOriginal = cv2.flip(imOriginal,0)
else:
imOriginal = cv2.flip(imOriginal,1)
scale = np.random.uniform(0.9,1.1)
mat = cv2.getRotationMatrix2D((im_size / 2, im_size / 2), rot, scale=scale)
resized = cv2.warpAffine(img_out, mat, (im_size, im_size), borderValue=(255,255,255))
img_out = np.zeros((resized.shape[0], resized.shape[1], 3), dtype=np.uint8)
img_orig = resized[:,:,0]
img_btop = 255-black_tophat(img_orig, selem)
img_wtop = 255-white_tophat(img_orig, selem)
img_out[:, :, 1] = img_btop
img_out[:, :, 2] = img_wtop
resized = cv2.resize(img_out, (128, 128))
resized = resized * 256.0 - mean #Geht richtig in den Keller auf Werte um 4, wenn man mean nicht abzieht
# offsetX = np.random.uniform(10,18,1).astype(int)[0]
# offsetY = np.random.uniform(10,18,1).astype(int)[0]
offsetX = np.random.uniform(0,28,1).astype(int)[0] #Random rotations
offsetY = np.random.uniform(0,28,1).astype(int)[0] #Random rotations
return resized[offsetY:(99+offsetY), offsetX:(99+offsetX)]
def insert_db(self, mode, image, label, features, channel_no, inverse):
if inverse:
image_ubyte = 255 - img_as_ubyte(image)
else:
image_ubyte = img_as_ubyte(image)
image_ubyte = numpy.transpose(image_ubyte, (2, 0, 1))
image_string = image_ubyte.tostring()
if features != None:
delimeter = '!@#$'
self.datum.data = image_string + delimeter + features
elif channel_no > 3:
selem = disk(6)
w_tophat = white_tophat(image_ubyte, selem)
b_tophat = black_tophat(image_ubyte, selem)
self.datum.data = image_string + w_tophat.tostring() + b_tophat.tostring()
else:
self.datum.data = image_string
if label != None:
self.datum.label = int(label)
serialized = self.datum.SerializeToString()
if mode == 'train':
self.train_batch.Put("%08d" % self.train_no, serialized)
self.train_no += 1
elif mode == 'valid':
self.valid_batch.Put("%08d" % self.valid_no, serialized)
self.valid_no += 1
elif mode == 'test':
self.test_batch.Put("%08d" % self.test_no, serialized)
self.test_no += 1
def image_process(im):
'''Enter function general description + arguments'''
strel = disk(5)
im_wavg = np.mean(im,0)
im_binary = black_tophat(im_wavg, strel)
im_binary = im_binary > np.max(im_binary)/2
im_binary = im_binary.astype('float')
return im_wavg, im_binary
def rolling_disk(image, radius=50, light_bg=False):
from skimage.morphology import white_tophat, black_tophat, disk
str_el = disk(radius)
print(image.shape)
if light_bg:
return black_tophat(image, str_el)
else:
return white_tophat(image, str_el)
def remove_uneven_illumination(data):
s = np.shape(data)
date_new = np.zeros(s, dtype=float)
for i in range(s[2]):
date_new[:, :, i] = 255 - black_tophat(data[:, :, i], disk(31))
return (date_new)
def subtract_background(image, radius, light_bg=False):
# you can also use 'ball' here to get a slightly smoother result at the
# cost of increased computing time
str_el = disk(radius)
if light_bg:
return black_tophat(image, str_el)
else:
return white_tophat(image, str_el)
def run(img):
if len(img.shape) > 2 and img.shape[2] == 4:
img = color.rgba2rgb(img)
if len(img.shape) == 2:
img = color.gray2rgb(img)
img = color.rgb2grey(img)
img = black_tophat(img, disk(1))
return to_base64(img)
def morpho_split(data_dcm_directory, Image_file, Image, Is_a_file, sig, diam):
if Is_a_file:
#Lecture des données pixel du fichier DICOM
Lec = sitk.ReadImage(os.path.join(data_dcm_directory, Image_file))
#Conversion en array
Image = sitk.GetArrayFromImage(Lec[:, :, 0])
#Conversion de l'image de non signé 16bits vers le type float
Image = Image.astype(float)
#Lissage de l'image par un filtre gaussien
IG8 = Image
#IG8 = filters.gaussian(Image,sigma=sig)
#Augmentation du contraste de l'image filtrée
IG8 = IG8 / (0.7 * np.max(IG8))
indices = np.unravel_index(np.argmax(IG8, axis=None), IG8.shape)
max_y = int(np.median(indices[0], overwrite_input=True))
max_x = int(np.median(indices[1], overwrite_input=True))
margin_y = int(2 * (3 / 2) * diam /
0.336) #Marge de sécurité de deux fois le diamètre
margin_x = int(2 * (3 / 2) * diam / 0.336) # en +/-x et en +/-y.
print(max_y, margin_y, max_x, margin_x)
#Définition du Kernel pour le filtrage morphologique
Kerb = morphology.disk(40)
Field = IG8.copy()
Filled_Field = IG8.copy()
#Kerf = morphology.disk(60)
#Field = morphology.white_tophat(IG8,Kerf) # A priori inutile de faire du top-hat pour avoir le champ. Mathématiquement, pour
# # enlever la bille, il suffit d'ajouter le bottom-hat au top hat, qui est ici l'image de base.
# # Cela peut être faux, attention!
Ball = morphology.black_tophat(
IG8[max_y - margin_y:max_y + margin_y,
max_x - margin_x:max_x + margin_x], Kerb)
B = np.zeros((1280, 1280))
B[max_y - margin_y:max_y + margin_y,
max_x - margin_x:max_x + margin_x] = Ball
Filled_Field[max_y - margin_y:max_y + margin_y,
max_x - margin_x:max_x + margin_x] += Ball
Ball = B
#Figures de contrôle
# plt.figure()
# plt.subplot(131)
# plt.imshow(Filled_Field)
# plt.subplot(132)
# plt.imshow(Field)
# plt.subplot(133)
# plt.imshow(Ball)
return (Filled_Field, Ball)
def remove_hair(im):
"""
Segmentation of the hairs in an image in order to remove them.
Usage:
im = remove_hair(im)
Parameters
----------
im: ndarray, shape (width, height, channels)
Image that contains hairs.
Returns
-------
new_im: ndarray (width, height, channels)
An image with hairs removed.
"""
n, m, _ = im.shape
# step 1: looking for the mask using a threshold on the RGB image
bool_im = np.zeros((n, m))
for i in range(n):
for j in range(m):
if im[i, j, 0] < 20 or im[i, j, 1] < 20 or im[i, j, 2] < 20:
bool_im[i, j] = 1
else:
bool_im[i, j] = 0
# step 2: looking for the mask using a morphological operation and then a threshold
gray_im = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY)
tophat = black_tophat(gray_im, disk(20)) / 255
tophat = (tophat > 0.15).astype(np.int) # 0.2 is used in the paper
# step 3: take the union of both results
mask = dilation((bool_im.astype(np.bool) + tophat.astype(np.bool)) * 1)
# step 4: if there are not enough hairs, no need to preprocess
if 100 * sum(sum(mask)) / (n * m) < 5:
return im
# step 5: we remove the hairs as indicated in the paper
new_im = im.copy()
for i in range(n):
for j in range(m):
if mask[i, j] == 1:
i_index = [max(i - 30, 0), min(i + 30, n)]
j_index = [max(j - 30, 0), min(j + 30, m)]
temp = im[i_index[0]:i_index[1], j_index[0]:j_index[1]]
new_im[i, j, 0] = np.median(temp[:, :, 0])
new_im[i, j, 1] = np.median(temp[:, :, 1])
new_im[i, j, 2] = np.median(temp[:, :, 2])
return new_im
def black_tophat(img):
orig_img = util.img_as_ubyte(img)
image = orig_img.copy()
image[340:350, 200:210] = 255
image[100:110, 200:210] = 0
selem = morphology.disk(6)
eroded = morphology.black_tophat(image, selem)
plot_comparison(orig_img, eroded, 'Black Tophat')
plt.tight_layout()
plt.show()
def _label_augment(g):
"""Augment the 3rd class: attaching cell borders """
se = square(3)
g_tophat = black_tophat(g, se)
g_dilation = dilation(g_tophat, se)
g_aug = g + (np.max(g) + 1) * g_dilation
g_aug[g_aug == 3.0] = 2.0
g_aug[find_boundaries(
g)] = 2.0 # highlight all borders as the 3rd label
return g_aug
def find_void_radii(self):
# create compensated top-hat filter
deg_per_pix = 20 / self.img_smooth.shape[0]
kernel_width_pix = int(self.kernel_width /
deg_per_pix) # convert deg to pix
self.cth_rad = np.array([
int(2 * kernel_width_pix),
int(2 * kernel_width_pix * np.sqrt(2))
])
selem = (2 * np.pad(
disk(self.cth_rad[0]),
self.cth_rad[1] - self.cth_rad[0],
mode="constant",
constant_values=0,
) + disk(self.cth_rad[1]) * -1)
# apply compensated top-hat filter
self.img_cth = black_tophat(self.img_smooth, selem)
# create marker for watershedding
marker = np.zeros(self.img_smooth.shape)
for src in range(len(self.pos)):
marker[self.pos[src, 1], self.pos[src, 0]] = src + 1
self.marker = marker
# create mask for watershedding
mask = np.zeros(self.img_cth.shape)
limit = np.percentile(self.img_cth.flatten(), 80)
mask[limit <= self.img_cth] = 1
self.mask = mask[::-1]
# create image for watershedding
distance = ndi.distance_transform_edt(mask)
# watershedding
labels = watershed(
-distance, # map_lowres_smooth,
markers=marker,
mask=mask,
watershed_line=True,
)
self.labels = labels
rad = np.zeros(len(self.pos))
for src in range(len(self.pos)):
lab = labels[self.pos[src, 1], self.pos[src, 0]]
area_pix = len(labels[labels == lab])
rad[src] = np.sqrt(area_pix / np.pi)
self.radii = rad
def black_tophat():
image = io.imread("pics/Cosmos.jpg")
blacked = morphology.black_tophat(image)
fig, (ax0, ax1) = plt.subplots(nrows=1, ncols=2, figsize=(8, 3),
sharex=True, sharey=True)
ax0.imshow(image, cmap=plt.cm.gray)
ax0.axis('off')
ax1.imshow(blacked, cmap=plt.cm.gray)
ax1.axis('off')
plt.show()
def calc_msi(raster_input, s_min, s_max, s_delta):
""" Calculates morphological shadow index (MSI) per Huang et al. (2015)
Assumes use of linear structuring element
MSI = sum(dxs)(blacktop_hat(morphological profiles))/(D*S)
d = degrees (0,45, 90, 135)
D = 4
s = size of linear structuring element (pixels)
S = (s_max-s_min)/s_delta + 1
Parameters
------------
raster_input : 3-dim raster (tif) stack for calculating brightness
s_min, s_max, s_delta: numerical input (integer)
Returns
------------
Calculated values for MSI in a numpy array
"""
# Calculate brightness for cloud masked stack
brightness = np.nanmax(raster_input, axis=0)
# Cap brightness values at a max of 1. Replace all values greater than 1 with a value of 1
brightness_cap = np.where(brightness > 1, 1, brightness)
# Initialize inputs for MSI calculation
selem = selemline(0, 0)
b_tophat_array_sum = black_tophat(brightness_cap, selem)
# Loop and sum black tophat morphological profiles for MSI calculation
for i in range(s_min, s_max + s_delta, s_delta):
for x in range(0, 4):
selem = selemline(i, 45 * x)
b_tophat = black_tophat(brightness_cap, selem)
b_tophat_array_sum = b_tophat_array_sum.__add__(b_tophat)
D = 4
S = ((s_max - s_min) / s_delta) + 1
msi = b_tophat_array_sum / (D * S)
return msi
def black_top_hat(image, k=2, plot=False, verbose=True):
if verbose:
print('\t - Removing black holes using disk of radius %d' % k)
res = black_tophat(image, disk(k))
if plot:
d.compare3(image,
res,
image + res,
title1='Original',
title2='Black Top Hat',
title3='Complimentary')
return image + res
def _try_black_tophat(self, roi, cur_text, cur_mrz):
roi_b = morphology.black_tophat(roi, morphology.disk(5))
new_text = ocr(roi_b) # There are some examples where this line basically hangs for an undetermined amount of time.
new_mrz = MRZ.from_ocr(new_text)
if new_mrz.valid_score > cur_mrz.valid_score:
new_mrz.aux['method'] = 'black_tophat'
cur_text, cur_mrz = new_text, new_mrz
new_text, new_mrz = self._try_larger_image(roi_b, cur_text, cur_mrz)
if new_mrz.valid_score > cur_mrz.valid_score:
new_mrz.aux['method'] = 'black_tophat(rescaled(3))'
cur_text, cur_mrz = new_text, new_mrz
return cur_text, cur_mrz
def Calvo_segmentation(img,Th,Tw,elem,threshold,dilation):
elem_estru = np.ones((elem,elem))
Image = img[:,:,1]
Image = morph.black_tophat(Image,elem_estru)
#Image = ndi.median_filter(Image,3)
arr_sigma = np.linspace(0.1, 3, 6)
Image = frangi_2d(Image,arr_sigma)
Image_array= Image.flatten()
Image_array = np.sort(Image_array,axis=None)
Tw = np.percentile(Image_array,Tw)
Th = np.percentile(Image_array,Th)
# Tw_zip = zip(percentile_array,Tw)
# print(list(Tw_zip))
Image = skifilter.apply_hysteresis_threshold(Image,Tw,Th)
L,N = ndi.label(Image)
T = ndi.sum(Image,L, range(1,N+1))
comp2remove = np.nonzero(T<threshold)[0] + 1
num_rows,num_cols = L.shape
Image = np.copy(Image)
for row in range(num_rows):
for col in range(num_cols):
label = L[row,col]
if label in comp2remove:
Image[row,col] = 0
for i in range(dilation):
Image = morph.binary_dilation(Image)
for i in range(dilation):
Image = morph.binary_erosion(Image)
#plot_image(Image,"Result4")
return Image
def detect_dust(image, drawable, isnegative=True, sensitivity=85, spot_size=9):
"""
Detects dust particles.
"""
# image = gimp.image_list()[0]
sensitivity = 1.0 * sensitivity / 100
spot_size = int(spot_size)
H = pdb.gimp_image_height(image)
W = pdb.gimp_image_width(image)
# first let's get the pixel values
layer = pdb.gimp_image_get_active_layer(image)
raster_image = channelData(layer).reshape([H, W, 3])
bpp = 8 #TODO get this
MAX = 2**bpp - 1
# to grayscale
raster_image_gray = color.rgb2gray(raster_image)
if isnegative:
mask_level = raster_image_gray > sensitivity
# white top hat to avoid uniform burned areas
strel = morpho.square(spot_size)
mask_th = morpho.white_tophat(raster_image_gray, selem=strel)
# take only (very) outliers
mask_th = mask_th > mask_th.mean() + 3 * mask_th.std()
else: # positive
mask_level = raster_image_gray < 1 - sensitivity
# black top hat to avoid uniform dark areas
strel = morpho.square(spot_size)
mask_th = morpho.black_tophat(raster_image_gray, selem=strel)
# take only (very) outliers
mask_th = mask_th > mask_th.mean() + 3 * mask_th.std()
strel = morpho.disk(1)
mask_th = morpho.opening(mask_th, selem=strel)
# mask composition
mask = mask_th & mask_level
# morphological dilation
strel = morpho.disk(3)
mask = morpho.dilation(mask, selem=strel)
# layer composition
mask_list = [mask * MAX for _ in range(4)]
dust_mask_rgba = np.stack(mask_list, axis=2)
createMaskLayer(image, "dust", dust_mask_rgba)
def conjugate_tophats(img, structures):
"""Funtion which performs a sum of conjugate top-hats of an image with the chose structuring elements
Parameters
----------
img : np.ndarray<float>
The input image
structures : np.ndarray<float>
The structuring elements
Returns
-------
img_th : np.ndarray<float>
The output image
"""
img_th = np.zeros(img.shape)
for struct in structures:
img_th += black_tophat(img, struct)
return img_th
def black_tophat_(image, selem=None, out=None):
orig_phantom = img_as_ubyte(image)
fig, ax = plt.subplots()
ax.imshow(orig_phantom, cmap=plt.cm.gray)
def plot_comparison(original, filtered, filter_name):
fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(8, 4), sharex=True,
sharey=True)
ax1.imshow(original, cmap=plt.cm.gray)
ax1.set_title('original')
ax1.axis('off')
ax2.imshow(filtered, cmap=plt.cm.gray)
ax2.set_title(filter_name)
ax2.axis('off')
phantom = orig_phantom.copy()
phantom[340:350, 200:210] = 255
phantom[100:110, 200:210] = 0
b_tophat = black_tophat(phantom, selem)
plot_comparison(phantom, b_tophat, 'black tophat')
plt.show()
def other_water(image):
b_tophat = morphology.black_tophat(image, disk(4))
thresholded_image = threshold_image(b_tophat)
distance = ndi.distance_transform_edt(thresholded_image)
local_maxi = peak_local_max(distance,
indices=False,
footprint=np.ones((3, 3)),
labels=image)
markers = ndi.label(local_maxi)[0]
labels = watershed(thresholded_image, markers)
label_image = skimage.morphology.remove_small_objects(labels, min_size=100)
counter = 1
config = '/Users/reganlamoureux/other_watershed_images/watershed_image{}.png'.format(
counter)
while os.path.exists(config):
counter += 1
config = '/Users/reganlamoureux/new_watershed_images/watershed_image{}.png'.format(
counter)
plt.imsave(config, label_image)
def analyse(self):
all_wells=[]
for well in range(self.img_set.sizes['v']):
self.img_set.default_coords['v'] = well
res=[]
if self.mask[well] is not None:
for img in self.img_set:
passed=[]
im=difference_of_gaussians(img, 1, 5)
blur=gaussian(im, sigma=2)
black=black_tophat(blur, selem=disk(4))
thresh=threshold_otsu((black))
black=black*self.mask[well].astype(bool).astype(int)
objects=regionprops(ndi.label(black>thresh)[0])
for obj in objects:
if obj.area>self.min_area and obj.area<self.max_area:
passed.append(obj.area)
res.append(len(passed))
else:
res.append([])
all_wells.append(res)
with open("out.csv", "w", newline="") as f:
writer = csv.writer(f)
writer.writerows(res)
plot_comparison(phantom, w_tophat, 'white tophat') ###################################################################### # As you can see, the 10-pixel wide white square is highlighted since it is # smaller than the structuring element. Also, the thin, white edges around # most of the ellipse are retained because they're smaller than the # structuring element, but the thicker region at the top disappears. # # Black tophat # ============ # # The ``black_tophat`` of an image is defined as its morphological **closing # minus the original image**. This operation returns the *dark spots of the # image that are smaller than the structuring element*. b_tophat = black_tophat(phantom, selem) plot_comparison(phantom, b_tophat, 'black tophat') ###################################################################### #As you can see, the 10-pixel wide black square is highlighted since #it is smaller than the structuring element. # #**Duality** # #As you should have noticed, many of these operations are simply the reverse #of another operation. This duality can be summarized as follows: # # 1. Erosion <-> Dilation # # 2. Opening <-> Closing #
newField = ogr.FieldDefn("SandMask", ogr.OFTInteger)
outLayer.CreateField(newField)
gdal.Polygonize(band, band, outLayer, 0, [], callback=None)
outDatasource.Destroy()
sourceRaster = None
band = None
# =============================================================================
# Segment
# =============================================================================
print("\nBeginning segmentation")
# tophat edges
print("Black tophat edge detection")
tophat = morph.black_tophat(gray, selem=morph.selem.disk(1))
tophat = tophat < np.percentile(tophat, tophat_th * 100)
tophat = morph.remove_small_holes(tophat, area_threshold=5, connectivity=2)
if not np.sum(tophat) == 0:
foo = func.featAND_fast(ignore_mask, tophat)
ignore_mask = np.logical_and(foo, ignore_mask)
# canny edges
print("Canny edge detection")
canny = feat.canny(gray, sigma=canny_sig)
canny = np.invert(canny)
foo = func.featAND_fast(ignore_mask, canny)
ignore_mask = np.logical_and(foo, ignore_mask)
# sobel edges
print("Sobel edge detection")
sobel = filt.sobel(gray)
sobel = sobel < np.percentile(sobel, sobel_th * 100)
# is passed, a new array will be allocated. # # Returns # ------- # opening : uint8 array # The result of the black top filter. # <codecell> # We will be working with phantom.png for this function. # First defining the structuring element as a disk using disk() #selem = disk(3); selem = disk(5) #selem = disk(10); phantom[150:160, 200:210] = 255 b_tophat = black_tophat(phantom, selem) # Displaying the original and eroded image # 'plt.figure() can be used for showing multiple images together plt.figure(1) io.imshow(phantom) plt.figure(2) io.imshow(b_tophat) #plt.figure(3) #io.imshow(opening(phantom, selem)) plt.show() # <markdowncell> # **Comments** : #
writeImg(outPath, img_org, kind, file, mani_num) #Original
rots = np.random.uniform(0,360,10).astype(int) #10 random rotations
for i, rot in enumerate(rots):
im_size = img_org.shape[0]
if (np.random.rand() > 0.5):
if (np.random.rand() > 0.5):
img_org = cv2.flip(img_org,0)
else:
img_org = cv2.flip(img_org,1)
scale = np.random.uniform(0.7,1.3)
mat = cv2.getRotationMatrix2D((im_size / 2, im_size / 2), rot, scale=scale)
img_rotated = cv2.warpAffine(img_org, mat, (im_size, im_size), flags=cv2.INTER_LINEAR, borderValue=(255,255,255))
img_out = np.zeros((img_rotated.shape[0], img_rotated.shape[1], 3), dtype=np.uint8)
img_orig = img_rotated[:,:,0]
img_btop = 255-black_tophat(img_orig, selem)
img_wtop = 255-white_tophat(img_orig, selem)
img_out[:, :, 1] = img_btop
img_out[:, :, 2] = img_wtop
img_rotated = img_out
if show:
cv2.imshow('Rot_' + str(i), img_rotated)
writeImg(outPath, img_rotated, kind, file, i+1) #Original
if show:
cv2.waitKey(20000 )
lineNum += 1
if (lineNum > 20):
break
def func(frame):
return mor.black_tophat(frame, mor.disk(size))
import numpy as np
from PIL import Image
from skimage.morphology import erosion, dilation, opening, closing
from skimage.morphology import black_tophat, white_tophat
from skimage.morphology import disk, diamond, rectangle, square, star
def my_imshow(arr, filter_name):
f,ax = plt.subplots()
ax.set_title(filter_name)
#ax.axis('off')
ax.set_adjustable('box-forced')
ax.imshow(arr, cmap=cm.gray, interpolation='none')
plt.show()
#Import an image.
image = np.array(Image.open('Butterfly.jpg'))
my_imshow(image, 'original')
#White tophat
fly = img.copy()
fly[340:350, 200:210] = 255
fly[100:110, 200:210] = 0
w_tophat = white_tophat(fly, selem)
my_imshow(w_tophat, 'white-tophat')
#Black tophat
b_tophat = black_tophat(fly, selem)
my_imshow(b_tophat, 'black-tophat')
def convert_test_data(self, data_set_folder, min_pixel, test_db_name, test_output_pickle_path,
inverse, channel_no = 1):
self.remove_folder(test_db_name)
test_db = leveldb.LevelDB(test_db_name)
pickleTestX = test_output_pickle_path + "/testX_size_" + str(min_pixel) + ".pickle"
pickleFileNames = test_output_pickle_path + "/fileNames.pickle"
if not os.path.exists(test_output_pickle_path):
os.makedirs(test_output_pickle_path)
numberofImages = 0
datum = caffe.proto.caffe_pb2.Datum()
datum.channels = channel_no
datum.width = min_pixel
datum.height = min_pixel
test_batch = leveldb.WriteBatch()
print "Load test dataset from image files"
for fileNameDir in os.walk(data_set_folder):
for index, fileName in enumerate(fileNameDir[2]):
if fileName[-5:] != ".JPEG":
continue
numberofImages += 1
imageSize = min_pixel * min_pixel
num_rows = numberofImages # one row for each image in the test dataset
batch_size = 10000
data_size = min(batch_size, numberofImages)
testX = numpy.zeros((data_size, channel_no, imageSize), dtype=numpy.uint8)
files = []
db_index = 0
pickle_index = 0
batch_no = 1
print "Reading images"
for fileNameDir in os.walk(data_set_folder):
for index, fileName in enumerate(fileNameDir[2]):
if fileName[-5:] != ".JPEG":
continue
nameFileImage = "{0}{1}{2}".format(fileNameDir[0], os.sep, fileName)
org_image = Image.open(nameFileImage)
files.append(fileName)
image = org_image.resize((min_pixel, min_pixel), Image.ANTIALIAS)
"""
print fileName
plt.figure(1, figsize=(1, 1), dpi=100)
plt.gray();
plt.subplot(1, 1, 1)
plt.imshow(image)
plt.show()
"""
if inverse:
image_ubyte = 255 - img_as_ubyte(image)
else:
image_ubyte = img_as_ubyte(image)
if channel_no > 1:
selem = disk(6)
w_tophat = white_tophat(image_ubyte, selem)
b_tophat = black_tophat(image_ubyte, selem)
datum.data = image_ubyte.tostring() + w_tophat.tostring() + b_tophat.tostring()
image_output = numpy.concatenate((image_ubyte, w_tophat, b_tophat), axis=1)
else:
datum.data = image_ubyte.tostring()
image_output = image_ubyte
test_batch.Put("%08d" % db_index, datum.SerializeToString())
testX[pickle_index] = numpy.reshape(image_output, (channel_no, imageSize))
db_index += 1
pickle_index += 1
if db_index % 1000 == 0:
test_db.Write(test_batch, sync = True)
del test_batch
test_batch = leveldb.WriteBatch()
print 'Processed %i test images.' % db_index
if pickle_index % batch_size == 0:
pickle_file_name = pickleTestX + "_" + str(batch_no)
with open(pickle_file_name,'wb') as fp:
cPickle.dump(testX, fp)
print "pickled %s" % pickle_file_name
data_size = min(batch_size, numberofImages - batch_size * batch_no)
testX = numpy.zeros((data_size, channel_no, imageSize), dtype=numpy.uint8)
batch_no += 1
pickle_index = 0
report = [int((j+1)*num_rows/20.) for j in range(20)]
if db_index in report: print numpy.ceil(db_index *100.0 / num_rows), "% done"
# Write last batch of images
if db_index % 1000 != 0:
test_db.Write(test_batch, sync = True)
if pickle_index % batch_size > 0:
pickle_file_name = pickleTestX + "_" + str(batch_no)
with open(pickle_file_name,'wb') as fp:
cPickle.dump(testX, fp)
print "pickled %s" % pickle_file_name
with open(pickleFileNames,'wb') as fp:
cPickle.dump(files, fp)
print 'Processed a total of %i images.' % db_index
