def fft_kernel(self, f_):
selected_frame = self.video[f_, :, :]
im_fft = np.fft.fftshift(np.fft.fft2(selected_frame))
amplitude = np.abs(im_fft)
phase = np.angle(im_fft)
amplitude_noiseless = np.multiply(self.mask, amplitude)
im_fft_noiseless = np.multiply(amplitude_noiseless, np.exp(phase * 1j))
im_fft_noiseless = np.fft.fftshift(im_fft_noiseless)
im_noiseless = np.fft.ifft2(im_fft_noiseless)
im_noise = self.video[f_, :, :] - np.real(im_noiseless)
if self.direction == 'Horizontal':
selem = rectangle(nrows=1, ncols=5)
elif self.direction == 'Vertical':
selem = rectangle(nrows=5, ncols=1)
filter_img = im_noise.copy()
for i_ in range(self.max_iterations):
try:
filter_img = filters.gaussian(filter_img,
sigma=1.2,
preserve_range=True)
# filter_img = rank.mean(filter_img, selem=selem)
except:
print(
f"{self.WARNING}\nThe Gaussian filter can not work!{self.ENDC}"
)
img_FPNc = np.real(im_noiseless) + np.real(filter_img)
return img_FPNc
def filterseriesall(oyscacld0, sizey, sizen, sizec): [nday, nr, nc] = oyscacld0.shape oyscacldl = oyscacld0.swapaxes(1,2).reshape(oyscacld0.shape[0], -1) [nday, npix] = oyscacldl.shape oyscacldl = oyscacldl.astype(np.int8) oyscacldl2 = deepcopy(oyscacldl) oyscacldyl = 1*(oyscacldl >=1) oyscacldyl2 = np.vstack((np.zeros((1, npix)), oyscacldyl, np.zeros((1, npix)))) oyscacldnl = 1*(oyscacldl <=1) oyscacldnl2 = np.vstack((np.zeros((1, npix)), oyscacldnl, np.zeros((1, npix)))) oyscacldcl = 1*(oyscacldl ==1) oyscacldcl2 = np.vstack((np.zeros((1, npix)), oyscacldcl, np.zeros((1, npix)))) ccc = ndimage.binary_hit_or_miss(oyscacldcl2, np.ones((sizec,1))) se = rectangle(sizec, 1) ccc = ndimage.binary_dilation(ccc, se)*1 ccc = ccc[1:-1,:] yyy = ndimage.binary_hit_or_miss(oyscacldyl2, np.ones((sizey,1))) se = rectangle(sizey, 1) yyy = ndimage.binary_dilation(yyy, se)*1 yyy = yyy[1:-1,:] yyy = yyy & 1*(ccc == 0) oyscacldl2[yyy==1] = 2 nnn = ndimage.binary_hit_or_miss(oyscacldnl2, np.ones((sizen,1))) se = rectangle(sizen, 1) nnn = ndimage.binary_dilation(nnn, se)*1 nnn = nnn[1:-1,:] nnn = nnn & 1*(ccc == 0) oyscacldl2[nnn==1] = 0 oyscacldl2[(np.logical_and(yyy==1, nnn==1))] = 1 oyscacld = oyscacldl2.reshape(nday, nr, nc, order='F') return oyscacld
def get_background_mask(mask, method="rectangle", r=10):
# This function gets the background mask shape of the neuron.
# Args:
# mask : 2D array as the mask for which to find the local background
# method : "rectangle" gets a rectangle surrounding the input mask, with
# dimensions twice the dimensions of the mask on either side.
# "disk" uses a disk shaped kernel to calculate dilation
# function on the input mask.
# "dilation" uses a square shaped kernel to calculate the
# dilation function on the input mask.
# TODO: add alternative versions that scale by a factor instead
# of by a fixed radius.
# r : radius for disk or edge size for rectangle to use for the kernel.
# Return is a 2D array with the same shape as the mask array, in which the
# local background is 1 but the input mask and external background is 0.
if method == "rectangle":
dims = get_mask_shape(mask)
bgmask = get_mask_rectangle(mask)
bgmask = dilation(bgmask, rectangle(dims[0] + 1, dims[1] + 1))
return np.logical_xor(bgmask, mask)
elif method == "disk":
dkern = disk(r)
bgmask = dilation(mask, dkern)
return np.logical_xor(bgmask, mask)
elif method == "dilation":
dkern = rectangle(r, r)
bgmask = dilation(mask, dkern)
return np.logical_xor(bgmask, mask)
else:
# default to rectangle
print('Incorrect method specified, defaulting to rectangle')
dims = get_mask_shape(mask)
bgmask = get_mask_rectangle(mask)
bgmask = dilation(bgmask, rectangle(dims[0], dims[1]))
return np.logical_xor(bgmask, mask)
def predict(self, path):
try:
img_path = path
img = self.read_image(img_path)
org = img.copy()
img_t = np.expand_dims(img, axis=0)
mask = self.model.predict(img_t)
mask = np.squeeze(mask, axis=0)
mask = np.squeeze(mask, axis=-1)
mask = misc.imresize(mask, [512, 512])
#union
print(mask.dtype)
mask = cv2.erode(mask, rectangle(3, 3))
edge = cv2.Canny(mask, 30, 100)
edge = cv2.dilate(edge, rectangle(3, 3))
org = cv2.cvtColor(org, cv2.COLOR_GRAY2BGR)
org[edge != 0] = [0, 127, 255]
cv2.imwrite('temp/mask.jpg', mask)
cv2.imwrite('temp/edge.jpg', edge)
cv2.imwrite('temp/2.jpg', org)
result = 1
print('inference sucess!')
except:
result = 0
print('inference failed!')
return result
def overlay_masks_with_borders(images_dir, subdir_name, target_dir, borders_size=3, dilation_size=5):
train_dir = os.path.join(images_dir, subdir_name)
for mask_dirname in tqdm(glob.glob('{}/*/masks'.format(train_dir))):
masks = []
for ind, image_filepath in enumerate(glob.glob('{}/*'.format(mask_dirname))):
image = np.asarray(Image.open(image_filepath))
image = np.where(image > 0, ind + 1, 0)
masks.append(image)
labeled_masks = np.sum(masks, axis=0)
overlayed_masks = np.where(labeled_masks, 1, 0)
selem = rectangle(dilation_size, dilation_size)
dilated_mask = dilation(overlayed_masks, selem=selem)
watershed_mask = watershed((dilated_mask >= 0).astype(np.bool), labeled_masks, watershed_line=True)
if watershed_mask.max() == watershed_mask.min():
masks_with_borders = overlayed_masks
else:
borders = (watershed_mask == 0) & (dilated_mask > 0)
selem = rectangle(borders_size, borders_size)
dilated_borders = dilation(borders, selem=selem)
masks_with_borders = np.where(dilated_borders, 2, overlayed_masks)
target_filepath = '/'.join(mask_dirname.replace(images_dir, target_dir).split('/')[:-1]) + '.png'
os.makedirs(os.path.dirname(target_filepath), exist_ok=True)
imwrite(target_filepath, masks_with_borders)
def ex_3_c():
# 9.5)
scale = 16 # resolution of shape
# draw original image
shape = np.zeros((8 * scale, 8 * scale), dtype=np.int)
shape[1 * scale:7 * scale, 1 * scale:3 * scale] = 1
shape[1 * scale:7 * scale, 5 * scale:7 * scale] = 1
shape[int(5.3 * scale):7 * scale, 1 * scale:7 * scale] = 1
plt.imshow(shape)
edore_a_struct = morphology.square(scale)
edore_a_origin = (scale // 2 - 1, scale // 2 - 1)
edore_a = ndimage.binary_erosion(shape, structure=edore_a_struct, origin=edore_a_origin)
plt.imshow(edore_a, cmap='binary_r')
edore_b = ndimage.binary_erosion(shape,
structure=morphology.rectangle(int(5 * scale), int(.5 * scale)),
origin=(int(2 * scale), 0))
plt.imshow(edore_b)
edore_c_struct = morphology.rectangle(scale * 2, scale * 2)
edore_c = ndimage.binary_erosion(shape, structure=edore_c_struct)
dilate_c_struct = morphology.disk(scale // 2)
shape_c = ndimage.binary_dilation(edore_c, structure=dilate_c_struct)
plt.imshow(edore_c, cmap='binary_r')
dilate_d_struct = ndimage.binary_dilation(shape, structure=morphology.disk(scale // 2))
edore_d_struct = ndimage.binary_erosion(dilate_d_struct, structure=morphology.disk(scale // 4))
plt.imshow(edore_d_struct)
def get_simple_eroded_dilated_mask(mask, erode_selem_size, dilate_selem_size, small_annotations_size):
if mask.sum() > small_annotations_size**2:
selem = rectangle(erode_selem_size, erode_selem_size)
mask_ = binary_erosion(mask, selem=selem)
else:
selem = rectangle(dilate_selem_size, dilate_selem_size)
mask_ = binary_dilation(mask, selem=selem)
return mask_
def get_col_row(img):
rows, cols = img.shape
scale = 80
col_selem = morphology.rectangle(cols // scale, 1)
img_cols = dil2ero(img, col_selem)
row_selem = morphology.rectangle(1, rows // scale)
img_rows = dil2ero(img, row_selem)
return img_cols, img_rows
def pre_process_image(image_file):
#get the image and resize
image_data = ndi.imread(image_file, mode='L')
resized_image = resize(image_data, (200, 200))
0.6
up_left, low_right = cropper(resized_image, 40, 0.6)
resized_image = resize(
resized_image[up_left[0]:low_right[0] + 1,
up_left[1]:low_right[1] + 1], (200, 200))
binar = binarize(resized_image, 0.4)
undilated = deepcopy(binar)
#dilate the binarized image
selem = rectangle(1, 2)
dil = dilation(binar, selem)
#binarize dilation
dil = binarize(dil)
#final = dil
final = deepcopy(dil)
for i in range(4):
for j in range(4):
final[i * 50 + 3:i * 50 + 25,
j * 50 + 3:j * 50 + 44] = undilated[i * 50 + 3:i * 50 + 25,
j * 50 + 3:j * 50 + 44]
#Try to remove all borders and grid lines in the image.
#Do this by scanning over rows and cols and if more than 25%
#of the pixels are <= 0.45 then set the entire row to 1(white)
#first rows
for row in range(len(final)):
count = 0
for pixel in final[row, :]:
if pixel == 0:
count += 1
if count >= 48:
final[row, :] = final[row, :] * 0 + 1
#columns
for col in range(len(final[0, :])):
count = 0
for pixel in final[:, col]:
if pixel == 0:
count += 1
if count >= 48:
final[:, col] = final[:, col] * 0 + 1
#add some final erosion (black) to fill out numbers and ensure they're connected
final = binarize(erosion(final, rectangle(1, 2)), .0000001)
return final
def process_image(pil_image, values):
img = np.array(pil_image)
selected_channels = [
values["-OTSU RED CHANNEL-"], values["-OTSU GREEN CHANNEL-"],
values["-OTSU BLUE CHANNEL-"]
]
if np.where(selected_channels)[0].size == 1 and len(img.shape) == 2:
if values["-APPLY LOCAL OTSU-"]:
radius = values["-LOCAL OTSU SIZE-"]
local_mask = disk(
radius
) if values["-LOCAL OTSU SHAPE-"] == "Disk" else rectangle(
int(radius), int(radius))
otsu_img = img >= rank.otsu(img, local_mask)
else:
otsu_img = img >= threshold_otsu(img)
otsu_np_img = 255 * np.asarray(otsu_img, dtype=np.uint8)
if values["-OTSU OVERLAY WITH IMAGE-"]:
cnts = cv2.findContours(otsu_np_img, cv2.RETR_LIST,
cv2.CHAIN_APPROX_NONE)[0]
cv2.drawContours(img, cnts, -1, 255, 1)
otsu_np_img = img
ret_img = Image.fromarray(otsu_np_img)
elif np.where(selected_channels)[0].size == 1:
if values["-APPLY LOCAL OTSU-"]:
radius = values["-LOCAL OTSU SIZE-"]
local_mask = disk(
radius
) if values["-LOCAL OTSU SHAPE-"] == "Disk" else rectangle(
int(radius), int(radius))
otsu_img = img[...,
np.where(selected_channels)[0][0]] >= rank.otsu(
img[..., np.where(selected_channels)[0][0]],
local_mask)
else:
threshold_global_otsu = threshold_otsu(
img[..., np.where(selected_channels)[0][0]])
otsu_img = img[..., np.where(selected_channels
)[0][0]] >= threshold_global_otsu
otsu_np_img = 255 * np.asarray(otsu_img, dtype=np.uint8)
if values["-OTSU OVERLAY WITH IMAGE-"]:
cnts = cv2.findContours(otsu_np_img, cv2.RETR_LIST,
cv2.CHAIN_APPROX_NONE)[0]
cv2.drawContours(img, cnts, -1, 255, 1)
otsu_np_img = img
ret_img = Image.fromarray(otsu_np_img)
else:
ret_img = pil_image
return ret_img
def pre_process_image(image_file):
#get the image and resize
image_data = ndi.imread(image_file, mode = 'L')
resized_image = resize(image_data, (200,200))
0.6
up_left,low_right = cropper(resized_image,40,0.6)
resized_image = resize(resized_image[up_left[0]:low_right[0]+1,up_left[1]:low_right[1]+1], (200,200))
binar = binarize(resized_image, 0.4)
undilated = deepcopy(binar)
#dilate the binarized image
selem = rectangle(1,2)
dil = dilation(binar, selem)
#binarize dilation
dil = binarize(dil)
#final = dil
final = deepcopy(dil)
for i in range(4):
for j in range(4):
final[i*50+3:i*50+25,j*50+3:j*50+44] = undilated[i*50+3:i*50+25,j*50+3:j*50+44]
#Try to remove all borders and grid lines in the image.
#Do this by scanning over rows and cols and if more than 25%
#of the pixels are <= 0.45 then set the entire row to 1(white)
#first rows
for row in range(len(final)):
count = 0
for pixel in final[row,:]:
if pixel == 0:
count += 1
if count >= 48:
final[row,:] = final[row,:]*0 + 1
#columns
for col in range(len(final[0,:])):
count = 0
for pixel in final[:,col]:
if pixel == 0:
count += 1
if count >= 48:
final[:,col] = final[:,col]*0 + 1
#add some final erosion (black) to fill out numbers and ensure they're connected
final = binarize(erosion(final, rectangle(1,2)),.0000001)
return final
def blurHorizon(res1, maskA):
# takes as input maskA and res1 and returns the two partial
# images, to be comjoined within main() into the final image
strel = skm.rectangle(5, 5)
# now to manipulate the mask A until we have just the horizon line left
lineAdil = skm.dilation(maskA, selem = strel)
horizonMaskMessy = lineAdil ^ maskA # because mask B was created from mask A anyway
horizonMask = lgstComp(horizonMaskMessy)
#these three comment lines below can be deleted, it's just another way to merge the two pieces:
#lineAerr = skm.erosion(maskA, selem = strel) # because mask B was created from mask A anyway
#horizonMaskMessyB = lineAerr ^ maskA
#horizonMaskMessy = horizonMaskMessyA | horizonMaskMessyB
line = res1.copy() # line will - eventually - have the masked horizon line only (with the median filter)
split = res1.copy() # split will contain the rest of the image "res1" (without the median filter)
lineBlurred = sknf.median_filter(line, footprint=np.ones((4, 4, 3)))
lineBlurred[~horizonMask] = 0
split[horizonMask] = 0
# now to convert it to a uniform format so that both images line up
split2 = ske.rescale_intensity(split)
lineBlurred2 = ske.rescale_intensity(lineBlurred)
return lineBlurred2, split2
def convert_dfds_to_video_events(dfdims, params):
"""Perform filtering, and peak finding
"""
# convert dfds into an "image"
dfdims = np.expand_dims(np.array(dfdims), 0)
# line structure element
selem = morph.rectangle(1, params['filter_lengths'])
# modified top-hat
ocdfd = morph.opening(morph.closing(dfdims, selem), selem)
mtdfd = dfdims - np.minimum(ocdfd, dfdims)
# make peaks sharper by diffing twice
doublediff_mtdfd = np.diff(np.diff(mtdfd))
use = np.abs(doublediff_mtdfd.squeeze())
# find peaks
sharpchange = np.where(use > params['diffthresh'])[0].tolist()
changeloc = []
k = 0
while k < len(sharpchange):
flag = k
a = sharpchange[k]
while (sharpchange[k] - a) < params['proximity']:
k += 1
if k == len(sharpchange):
break
changeloc.append(int(round(np.mean(sharpchange[flag:k]))))
changeloc = [c + 2 for c in changeloc]
# add one to compensate for the double diff
# and one more to compensate for k being 0 indexed
return changeloc
def open_image(img, mask_length):
# Morphological opening on greyscale/binary image
img = img.astype(np.uint8)
img = opening(img, rectangle(mask_length,1))
return(img)
def processVarianceVector(varVect, filterBlur):
filtVect = filters.gaussian(varVect, sigma=filterBlur)
scaleVect = (filtVect - np.amin(filtVect)) / (np.amax(filtVect) -
np.amin(filtVect))
# Choose start and end for slice
# Defined as first and last point that are above threshold of 0.5 in scaled blurred edge-transformed image
varThresh = scaleVect > 0.5
varClose = morphology.binary_closing(varThresh, morphology.rectangle(3, 1))
# May be a good idea to confirm that there is a single large contiguous 'true' block here
# If this is split or there are multiple blocks above threshold the next steps may return spurious values
startEnd = [np.amin(np.where(varClose)[0]), np.amax(np.where(varClose)[0])]
# Find first minimum to left of start, first to right of end
localMin = argrelextrema(scaleVect, np.less)
conservativeStartEnd = [
localMin[0][(np.amax(np.where(((localMin[0] - startEnd[0]) < 0))))],
localMin[0][(np.amin(np.where(((localMin[0] - startEnd[1]) > 0))))]
]
return startEnd, conservativeStartEnd
def preprocess(kernel_size=7):
"""
Filter all images in the specified folder using median filter
:param kernel_size: size of squared kernel used in median filter
:return:
"""
# path to original data
PATH_ORIG = '/Users/mikhail/projects/edu/research/denoising/data/origin/noisy/'
PATH_CLEAN = '/Users/mikhail/projects/edu/research/denoising/data/origin/clean/'
images_names = os.listdir(PATH_ORIG)
for i, image_name in enumerate(images_names):
#img = cv2.imread(PATH_ORIG + image_name)
# img_clean = cv2.medianBlur(img, 7)
# cv2.imwrite(PATH_CLEAN + new_name, img_clean)
img = skimage.io.imread(PATH_ORIG + image_name, as_gray=True)
# filter image using median filter
img_clean = median(img, selem=rectangle(kernel_size, kernel_size))
# save image in another folder with different name
new_name = 'F' + image_name[1:]
skimage.io.imsave(PATH_CLEAN + new_name, img_clean)
if (i % 200 == 0) and (i != 0):
print(f'{i} images have been filtered')
def postProcessing(self, predictions, frame_size, holeFilling, areaFiltering, P, connectivity, Morph):
nFrames, nPixels = predictions.shape
if connectivity == 8:
se = [[1, 1, 1], [1, 1, 1], [1, 1, 1]] # 8-connectivity
else:
se = [[0, 1, 0], [1, 1, 1], [0, 1, 0]] # 4-connectivity
for frame in range(0, nFrames):
actualFrame = np.reshape(predictions[frame, :], (frame_size[0], frame_size[1]))
if holeFilling:
#cv2.imwrite('Before_holefilling.png', 255 * actualFrame)
actualFrame = binary_fill_holes(actualFrame.astype(int), structure=se)
#cv2.imwrite('After_holefilling.png', 255 * actualFrame)
if areaFiltering:
actualFrame = remove_small_objects(actualFrame, P)
if Morph:
# SE = disk(2,2)
SE = rectangle(4,2)
#cv2.imwrite('Before_closing.png', 255 * actualFrame)
actualFrame = binary_closing(actualFrame.astype(int), selem=SE, out=None)
# cv2.imwrite('Results/After_closing'+str(frame)+'.png', 255 * actualFrame)
actualFrame = binary_fill_holes(actualFrame.astype(int), structure=se)
predictions[frame, :] = np.reshape(actualFrame.astype(int), (1, frame_size[0] * frame_size[1]))
return predictions
def image_opening(image, strel='rectangle', size_strel=3):
if strel == 'rectangle':
elem = morphology.rectangle(size_strel // 2, size_strel)
elif strel == 'square':
elem = morphology.square(size_strel)
elif strel == 'diagonal':
elem = np.zeros((size_strel, size_strel), int)
np.fill_diagonal(elem, 1)
elem = np.fliplr(elem)
elif strel == 'diamond':
elem = morphology.diamond(size_strel)
elif strel == 'horizontal_line':
elem = morphology.rectangle(1, size_strel)
output_image = morphology.opening(image, elem)
return output_image
def get_simple_eroded_mask(mask, selem_size, small_annotations_size):
if mask.sum() > small_annotations_size**2:
selem = rectangle(selem_size, selem_size)
mask_eroded = binary_erosion(mask, selem=selem)
else:
mask_eroded = mask
return mask_eroded
def identify_lanes(bf, bf_cropped):
if bf == 'na':
lane_mask = np.ones(bf_cropped.shape,dtype = int)
lane_binary_mask = lane_mask
else:
bf_sobel_h = sobel_h(bf_cropped)
if len(np.unique(bf_sobel_h)) > 1:
bf_sobel_h_threshold = threshold_li(bf_sobel_h)
bf_thresholded = bf_sobel_h > bf_sobel_h_threshold
else:
bf_thresholded = bf_sobel_h
bf_closed = closing(bf_thresholded, rectangle(10,20))
bf_small_removed = remove_small_objects(bf_closed)
for point in range(len(bf_small_removed[:bf_cropped.shape[0] - 30,bf_cropped.shape[1] /2])):
if bf_small_removed[point,bf_cropped.shape[1] /2] == True and bf_small_removed[point+30,bf_cropped.shape[1] /2] == True:
for i in range(30):
bf_small_removed[point+i,bf_cropped.shape[1] /2] = True
bf_dilated = binary_dilation(bf_small_removed)
bf_small_holes_removed = remove_small_holes(bf_dilated,30000)
bf_label_image = label(bf_small_holes_removed)
lane_mask = np.zeros(bf_cropped.shape,dtype = int)
mask_label = 1
for region in regionprops(bf_label_image):
if region.area > 10000:
if region.bbox[2] == 0 or region.bbox[2] == bf_cropped.shape[0]:
for coord in region.coords:
[x,y] = coord
lane_mask[x,y] = 0
else:
for coord in region.coords:
[x,y] = coord
lane_mask[x,y] = mask_label
mask_label += 1
lane_binary_mask = lane_mask > 0
return lane_mask,lane_binary_mask
def test_watershed(image):
images = {}
img = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
images['grayscale'] = img
r = 3
img = opening(img, disk(r))
images['opening' + str(r)] = img
w = 3
h = 3
img = closing_by_reconstruction(img, rectangle(w, h))
images['closing_by_reconstruction_' + str(w) + 'x' + str(h)] = img
img = np.uint8(img)
sigma = 3
img = feature.canny(img, sigma=sigma)
images['canny_' + str(sigma)] = img
img = np.uint8(img)
ret, thresh = cv.threshold(img, 0, 255,
cv.THRESH_BINARY_INV + cv.THRESH_OTSU)
images['threshold'] = thresh
r = 5
img = opening(img, disk(r))
images['opening_' + str(r)] = img
# noise removal
kernel = np.ones((3, 3), np.uint8)
opened = cv.morphologyEx(thresh, cv.MORPH_OPEN, kernel, iterations=2)
images['opened'] = opened
# sure background area
sure_bg = cv.dilate(opened, kernel, iterations=3)
images['sure_bg'] = sure_bg
# Finding sure foreground area
dist_transform = cv.distanceTransform(opened, cv.DIST_L2, 5)
ret, sure_fg = cv.threshold(dist_transform, 0.7 * dist_transform.max(),
255, 0)
images['dist_transform'] = dist_transform
images['sure_fg'] = sure_fg
# Finding unknown region
sure_fg = np.uint8(sure_fg)
unknown = cv.subtract(sure_bg, sure_fg)
images['unknown'] = unknown
# Marker labelling
ret, markers = cv.connectedComponents(sure_fg)
images['markers'] = markers
# Add one to all labels so that sure background is not 0, but 1
markers = markers + 1
images['markers+1'] = markers
# Now, mark the region of unknown with zero
markers[unknown == 255] = 0
images['markers_unknown'] = markers
markers = cv.watershed(image, markers)
images['markers_watershed'] = markers
image[markers == -1] = [255, 0, 0]
images['image'] = image
plot_images(images, 6, 3, cmap='gray')
def make_entropy_vars(wells_df, logs, l_foots):
new_df = pd.DataFrame()
grouped = wells_df.groupby(['Well Name'])
for key in grouped.groups.keys():
depth = grouped.get_group(key)['Depth']
temp_df = pd.DataFrame()
temp_df['Depth'] = depth
for log in logs:
temp_data = grouped.get_group(key)[log]
image = np.vstack((temp_data, temp_data, temp_data))
image -= np.median(image)
image /= np.max(np.abs(image))
image = img_as_ubyte(image)
for l_foot in l_foots:
footprint = rectangle(l_foot, 3)
temp_df[log + '_entropy_foot' + str(l_foot)] = entropy(
image, footprint)[0, :]
new_df = new_df.append(temp_df)
new_df = new_df.sort_index()
new_df = new_df.drop(['Depth'], axis=1)
return new_df
def post_process_v2(mask):
"""Mainly remove the convex areas"""
bw = label(mask == 1)
# 1) detach mislabeled pixels
bw = binary_opening(bw, rectangle(2, 20))
# 2) remove small objects
bw = remove_small_objects(bw, min_size=4096, connectivity=2)
# 3) solve the defeat, typically the convex outline
coords = corner_peaks(corner_harris(bw, k=0.2), min_distance=5)
valid = [c for c in coords
if 100 < c[1] < 476] # only cares about this valid range
if valid:
y, x = zip(*valid)
# corners appear in pair
if len(y) % 2 == 0:
# select the lowest pair
left_x, right_x = [func(x[0], x[1]) for func in (min, max)]
sep_x = np.arange(left_x, right_x + 1).astype(int)
sep_y = np.floor(np.linspace(y[0], y[1] + 1,
len(sep_x))).astype(int)
# make the gap manually
bw[sep_y, sep_x] = 0
bw = binary_opening(bw, disk(6))
else:
mask = np.zeros_like(bw)
mask[y, x] = 1
chull = convex_hull_image(mask)
bw = np.logical_xor(chull, bw)
bw = binary_opening(bw, disk(6))
return bw
def identify_lanes(bf_img, bf_cropped):
bf_sobel_h = sobel_h(bf_cropped)
# fig, ax = try_all_threshold(bf_sobel_h, figsize=(15,12), verbose=False)
# plt.show()
# if len(bf_img.shape) == 3:
# bf_sobel_h_threshold = threshold_otsu(bf_sobel_h)
# else:
bf_sobel_h_threshold = threshold_li(bf_sobel_h)
bf_thresholded = bf_sobel_h > bf_sobel_h_threshold
bf_closed = closing(bf_thresholded, rectangle(10, 20))
bf_dilated = binary_dilation(bf_closed)
bf_small_holes_removed = remove_small_holes(bf_dilated, 15000)
bf_small_removed = remove_small_objects(bf_small_holes_removed)
bf_label_image = label(bf_small_removed)
row = bf_small_removed.shape[0]
col = bf_small_removed.shape[1]
lane_mask = np.zeros([row, col], dtype=int)
mask_label = 1
for region in regionprops(bf_label_image):
if region.area > 10000:
if region.bbox[2] == 0 or region.bbox[2] == row:
for coord in region.coords:
[x, y] = coord
lane_mask[x, y] = 0
else:
for coord in region.coords:
[x, y] = coord
lane_mask[x, y] = mask_label
mask_label += 1
lane_binary_mask = lane_mask > 0
return lane_mask, lane_binary_mask, row, col
def bw_transform(img_src): # To finish
tval = threshold_otsu(img_src)
bn_src = (img_src > tval)
# Reducing horizontal and vertical lines
r_vertical = rectangle(bn_src.shape[1], 1)
r_horizontal = rectangle(1, bn_src.shape[0])
# Reducing horizontal lines
bn_src = white_tophat(bn_src, r_horizontal)
# Reducing vertical lines
bn_src = white_tophat(bn_src, r_vertical)
# Reducing salt
bn_src = remove_small_objects(bn_src, connectivity=2, min_size=9)
return bn_src
def fix_background(num):
#print('f')
img = session['cerenkovradii']
tim = time.time()
val = img.copy()
img -= np.min(img)
img += .001
ideal_r = 25
#print(ideal_r)
b4 = morphology.opening(img, morphology.disk(ideal_r - 10))
b0 = morphology.closing(img, morphology.disk(ideal_r))
b1 = morphology.opening(img, morphology.disk(ideal_r + 5))
b2 = morphology.opening(img, morphology.disk(ideal_r))
b3 = morphology.opening(img, morphology.disk(ideal_r - 5))
b = b1.copy()
c = ideal_r * 2
arr = np.array([[-1 * ideal_r, 1], [ideal_r - 10, 1], [0, 1],
[ideal_r - 5, 1], [ideal_r, 1], [ideal_r + 5, 1]])
arr = np.linalg.pinv(arr)
for i in range(len(b)):
for j in range(len(b[i])):
if abs(b3[i][j] - b1[i][j]) > 20:
arr2 = arr @ np.log(
np.array([
b0[i][j], b4[i][j], img[i][j], b3[i][j], b2[i][j],
b1[i][j]
]))
x = arr2[0]
y = arr2[1]
b[i][j] = np.exp(y) * np.exp(x * c)
b = filters.median(b, selem=morphology.rectangle(40, 2))
b = filters.median(b, selem=morphology.rectangle(2, 40))
img -= b
img -= np.median(img)
path = retrieve_image_path('cerenkovcalc', num)
os.remove(path)
np.save(path, img)
img -= np.min(img)
img /= np.max(img)
#print(time.time()-tim)
img = Image.fromarray((np.uint8(plt.get_cmap('viridis')(img) * 255)))
filepath = retrieve_image_path('cerenkovdisplay', num)
os.remove(filepath)
img.save(filepath)
return {'r': 2}
def text_segments(img, min_h=20, max_h=50):
gray_scale_img = rgb2grayscale(img)
binarized_adaptive_img = threshold_adaptive(gray_scale_img, block_size=40, offset=20)
dilated = dilation(~binarized_adaptive_img, rectangle(1, 15))
for segment in extract_segments(dilated.copy()):
if min_h < height(segment) < max_h:
yield segment
def get_completed_external_bearing_walls(input_img):
image = get_external_bearing_walls(input_img)
# fill horizontal gaps
selem_horizontal = morphology.rectangle(1, 50)
img_filtered = morphology.closing(image, selem_horizontal)
# fill vertical gaps
selem_vertical = morphology.rectangle(80, 1)
img_filtered = morphology.closing(img_filtered, selem_vertical)
# plt.imshow(img_filtered, cmap="gray")
# plt.gca().axis("off")
# plt.show()
return img_filtered
def func(frame):
_dtype = frame.dtype
kernel = mor.disk(3)
frameWP = frame - mor.white_tophat(frame, kernel) * (mor.white_tophat(frame, kernel) > 1000).astype(float)
kernel = mor.rectangle(25, 1)
closed = mor.closing(frameWP, kernel)
opened = mor.opening(closed, kernel)
result = ((frameWP.astype(float) / opened.astype(float)) * 3000.0)
return result.astype(_dtype)
def refine_image(img, max_size=2000):
h, w = np.size(img, 0), np.size(img, 1)
result = np.empty(img.shape, 'uint8')
if max(h, w) > max_size:
result = img
else:
for c in range(np.size(img, 2)):
result[:, :, c] = filters.rank.autolevel(img[:, :, c],
kernel.rectangle(h, w))
return result
def BinMM(img,thresh,size):
#threshold at sliderval (param1)
img = thrhold(img,thresh)
structElement = morphology.rectangle(size,size)
#structElement = morphology.disk(size)
#structElement = morphology.diamond(size)
img = morphology.binary_opening(np.squeeze(img), structElement).astype(np.uint8)
return img[:,:,np.newaxis]
def get_rectangle(width, height):
"""
:param width: Width of rectangle
:type width: int
:param height: Height of rectangle
:type height: int
:return: A structuring element consisting only of ones, i.e. every pixel belongs to the neighborhood.
:rtype: numpy.ndarray
"""
return rectangle(width, height)
def process(filename, plot=False):
# read in image filename
imagepath = os.path.join(os.getcwd(), filename)
orig_img = io.imread(filename, True, 'pil')
# binarize image
img = orig_img > 0.9 # binary threshold
# convert to grayscale (easier for viewing)
img = rgb2gray(img)
imshow(img)
# use erosion to expland black areas in the document. This will
# group together small text and make it easier to find contours
# of signatures, which are usually separated from text
eroded_img = binary_erosion(img, rectangle(30, 10))
# get contours of eroded image
contours, lengths = compute_contours(eroded_img)
# compute X and Y gradients over the contours. We expect that signatures
# will have have a constant gradient that is close to the length of
# the contour. We take the sum of the X-gradient to remove contours
# that are vertically biased
c_grad_x = map(lambda x: np.gradient(x[:, 1]), contours)
c_grad_y = map(lambda x: np.gradient(x[:, 0]), contours)
stuffs = []
for i, (x, y) in enumerate(zip(c_grad_x, c_grad_y)):
stuffs.append((sum(map(abs, x)), len(x)))
d = pd.DataFrame.from_records(stuffs)
d['diff'] = abs(d[0] - d[1])
d = d[d['diff'] > d['diff'].mean()]
contours = [contours[i] for i in d.index]
# compute bounding boxes for resulting contours
boxes = get_boundingboxes(contours)
# given a box, does sobel on the bounding box of that block
# computes contours within the subimage and returns them
def process_block(box):
mask = get_mask_from_boundingbox(img, box)
sobel_img = sobel(img, mask)
contours, lengths = compute_contours(sobel_img)
return len(contours), contours, lengths
# get all blocks
blocks = [process_block(box) for box in boxes]
# retrieve the blocks that have the fewest number of contours
num_contours = pd.Series(block[0] for block in blocks)
num_contours = num_contours[num_contours < num_contours.mean()]
# plot only those contours
ret_contours = []
for block in [blocks[i] for i in num_contours.index]:
len_con, contours, lengths = block
lengths = pd.Series(lengths)
lengths = lengths[lengths > lengths.mean()]
for i in lengths.index:
contour = contours[i]
ret_contours.append(contour)
plt.plot(contour[:, 1], contour[:, 0])
return ret_contours
def overlay_eroded_masks_from_annotations(annotations, image_size, selem_size):
mask = np.zeros(image_size)
selem = rectangle(selem_size, selem_size)
for ann in annotations:
rle = cocomask.frPyObjects(ann['segmentation'], image_size[0],
image_size[1])
m = cocomask.decode(rle)
m = m.reshape(image_size)
m = binary_erosion(m, selem=selem)
mask += m
return np.where(mask > 0, 1, 0).astype('uint8')
def process(filename, plot=False):
# read in image filename
imagepath = os.path.join(os.getcwd(), filename)
orig_img = io.imread(filename,True,'pil')
# binarize image
img = orig_img > 0.9 # binary threshold
# convert to grayscale (easier for viewing)
img = rgb2gray(img)
imshow(img)
# use erosion to expland black areas in the document. This will
# group together small text and make it easier to find contours
# of signatures, which are usually separated from text
eroded_img = binary_erosion(img,rectangle(30,10))
# get contours of eroded image
contours, lengths = compute_contours(eroded_img)
# compute X and Y gradients over the contours. We expect that signatures
# will have have a constant gradient that is close to the length of
# the contour. We take the sum of the X-gradient to remove contours
# that are vertically biased
c_grad_x = map(lambda x: np.gradient(x[:,1]), contours)
c_grad_y = map(lambda x: np.gradient(x[:,0]), contours)
stuffs = []
for i,(x,y) in enumerate(zip(c_grad_x,c_grad_y)):
stuffs.append( (sum(map(abs, x)), len(x)) )
d = pd.DataFrame.from_records(stuffs)
d['diff'] = abs(d[0] - d[1])
d = d[d['diff'] > d['diff'].mean()]
contours = [contours[i] for i in d.index]
# compute bounding boxes for resulting contours
boxes = get_boundingboxes(contours)
# given a box, does sobel on the bounding box of that block
# computes contours within the subimage and returns them
def process_block(box):
mask = get_mask_from_boundingbox(img,box)
sobel_img = sobel(img,mask)
contours, lengths = compute_contours(sobel_img)
return len(contours),contours,lengths
# get all blocks
blocks = [process_block(box) for box in boxes]
# retrieve the blocks that have the fewest number of contours
num_contours = pd.Series(block[0] for block in blocks)
num_contours = num_contours[num_contours < num_contours.mean()]
# plot only those contours
ret_contours = []
for block in [blocks[i] for i in num_contours.index]:
len_con,contours,lengths = block
lengths = pd.Series(lengths)
lengths = lengths[lengths > lengths.mean()]
for i in lengths.index:
contour = contours[i]
ret_contours.append(contour)
plt.plot(contour[:,1],contour[:,0])
return ret_contours
def GrayMM(img,thresh,size):
structElement = morphology.rectangle(size,size)
img[img == -9999] = 0
img = img/5000
img[img < 0] = 0
img[img > 1] = 1
outdata = morphology.opening(img, structElement)
#threshold after bin
imgOut = outdata > 255*thresh/5000
return imgOut
def color_based_crop(test_image):
median_ = np.median(test_image[:, :, 0], axis=(0, 1))
test_image_med = median(test_image[:, :, 0], disk(10))
test_image_treshold = (test_image_med[:, :] > (median_ + 10)) & (test_image[:, :, 0] < 180)
eroded_thr = erosion(test_image_treshold, rectangle(5, 5))
regions = list(regionprops(label(1 - eroded_thr)))
if len(regions) != 0:
biggest_region = max(regions, key=lambda x: x.area)
minr, minc, maxr, maxc = biggest_region.bbox
test_image = test_image[minr:maxr, minc:maxc, :]
return transform.resize(color.rgb2gray(test_image), (100, 100))
def region_filter_crop(rgbImage):
rgbImage = rgbImage[100:-100, 100:-100]
rgbImage = transform.resize(rgbImage, (1000, 1000))
eroded_mask = erosion(yen_mask(rgbImage), rectangle(20, 20))
regions = list(regionprops(label(eroded_mask)))
if len(regions) == 0:
return rgbImage
biggest_region = max(regions, key=lambda x: x.area)
minr, minc, maxr, maxc = biggest_region.bbox
rgbImage = rgbImage[minr:maxr, minc:maxc, :]
minr, minc, maxr, maxc = biggest_region.bbox
rgbImage = rgbImage[minr:maxr, minc:maxc, :]
return rgbImage
def dilate_skimage(self):
"""perform the dilation of the image"""
# set up structuring element
# (@Giacomo, is (1, 90) and (1, 0) different? using rectangle here...
struct_env = rectangle(1, 1)
# perform algorithm with given environment,
# store in same memory location
image = dilation(self.current_image, selem=struct_env,
out=self.current_image)
# update current image
self.current_image = image
# append function to logs
self.logs.add_log('dilate - skimage')
return image
def get_clustering_image(sample4x4_crop):
binar = binarize(sample4x4_crop)
################################################
#####APPLY FILTERS TO REMOVE NUM/SYMBOLS########
################################################
selem = rectangle(2,2)
dil = dilation(binar, selem)
#dil = erosion(dil)
#plt.imshow(dil, cmap=mpl.cm.Greys_r)
dil = binarize(dil)
#plt.imshow(dil, cmap=mpl.cm.Greys_r)
cluster_image = deepcopy(dil)
for i in range(4):
for j in range(4):
cluster_image[i*50+5:i*50+40,j*50+3:j*50+38] = np.zeros((35,35))+1
return cluster_image
def to_gray_scale(self, img, imbin, colorvalue=(255, 0, 0), alpha=1.0,
gradient=True):
max_color = max(colorvalue)
if max_color > 1.0:
colorvalue = [a / max_color for a in colorvalue]
colim = color.gray2rgb(img)
if gradient:
#se = morphology.disk(1)
se = morphology.rectangle(3,3)
imvis = imbin - morphology.erosion(imbin, se)
else:
imvis = imbin
for i, col in enumerate(colorvalue):
channel_img = colim[:,:,i]
channel_img[imvis>0] = (1-alpha) * channel_img[imvis>0]
colim[:,:,i] = alpha*col*imvis + channel_img
return colim
def rectMask(maskImg, width, height):
boxsize = maskImg.get_xsize()
maskArray = EMNumPy.em2numpy(maskImg)
if (boxsize <= width or boxsize <= height):
print "ERROR: the width or height of the rectangle cannot be larger than the boxsize of particles."
sys.exit()
#from skimage.morphology import rectangle
#Generates a flat, rectangular-shaped structuring element of a given width and height.
#Every pixel in the rectangle belongs to the neighboorhood.
rectArray = rectangle(height, width, dtype=np.uint8)
m, n = rectArray.shape
if (m%2 == 0):
padRow_before = (boxsize - m)/2
padRow_after = (boxsize - m)/2
else:
padRow_before = (boxsize - m)/2
padRow_after = (boxsize - m)/2+1
if (n%2 == 0):
padCol_before = (boxsize - n)/2
padCol_after = (boxsize - n)/2
else:
padCol_before = (boxsize - n)/2
padCol_after = (boxsize - n)/2+1
#pad_x = (boxsize - height)/2
#pad_y = (boxsize - width)/2
#rectArrayPad = np.pad(rectArray, ((pad_x, pad_x), (pad_y, pad_y)), mode='constant')
rectArrayPad = np.pad(rectArray, ((padRow_before, padRow_after), (padCol_before, padCol_after)), mode='constant')
#m, n = rectArrayPad.shape
#print m, n
#convert numpy to em image
rectImg = EMNumPy.numpy2em(rectArrayPad)
return rectImg
3,
nw_corner,
se_corner,
list(range(2005, 2012)),
'Bulk Order 397884/L4-5 TM'
)
temporal_nvdi = (temporal_band_4 - temporal_band_3) / (temporal_band_4 + temporal_band_3)
field_mask = compress_temporal_image(temporal_nvdi)
imsave(fname_template.format('temporal_nvdi', 'png'), field_mask)
# Detect Fields
print('Detecting Fields')
field_mask = field_mask >= 10
# Find the area containing the fields
field_area = binary_closing(binary_erosion(field_mask, rectangle(5, 5)), rectangle(50, 50))
between_fields = logical_and(field_area, logical_not(field_mask))
# Find the roads and separate the fields
# Separate out into smaller blocks
print('Separating Fields in image')
for stride in [100, 200, 400]: # pixels
num_row_strides = int_(between_fields.shape[0]/stride)
num_col_strides = int_(between_fields.shape[1]/stride)
r_stride = int_(between_fields.shape[0]/num_row_strides)
c_stride = int_(between_fields.shape[1]/num_col_strides)
for r in range(num_row_strides+1):
for c in range(num_col_strides+1):
h, theta, d = hough_line(between_fields[r*r_stride:(r+1)*r_stride, c*c_stride:(c+1)*c_stride])
threshold = 0 #0.0005*max(h)
image=io.imread(file_path)
# load classifier
clf=joblib.load("digits_cls.pkl")
""" convert image from rgb to gray_scale"""
from skimage.color import rgb2gray
gray_image=rgb2gray(image)
""" apply gaussian filter """
try:
from skimage import filters
except ImportError:
from skimage import filter as filters
gaussian_img=filters.gaussian_filter(gray_image,(5,5),0)
""" set threshold_otsu for convert image in binary image image """
# it optimaly set threshold value
from skimage.filters import threshold_otsu
thresh=threshold_otsu(gaussian_img)
binary=gaussian_img>thresh
""" find contours in image"""
from skimage import measure
new_b=binary
contours=measure.find_contours(binary)
# make rectangle for digits
from skimage.morphology import rectangle
rectangles=[rectangle(contour) for contour in contours]
def morphElement(self, width, height):
return morphology.rectangle(width, height)
def smoothing_func(lower_val_beta,upper_val_beta,lower_val_alpha,upper_val_alpha):
"""
This function eliminates the blocking effects appeared from the previous stages.
The input arguments are explained in the image_normalization function.
"""
print 'The parameters are found successfully, and they are saved.'
print 'Please wait to do smoothing over the parameters...'
smooth_ngbh_x=5
smooth_ngbh_y=5
selem=rectangle(smooth_ngbh_x,smooth_ngbh_y)
accuracy1=0.0025
accuracy2=.05
r=r_org/num_partitions_x
c=c_org/num_partitions_y
max_shared_array_size = 33000000
def do_bilateral():
num_threads = num_parallel
volume_size = np.prod([r_org,c_org,s])
volume_parts = np.ceil(np.float(volume_size)/ (100*max_shared_array_size))
value_total = np.zeros((r_org,c_org,s))
for z_division in np.arange(volume_parts):
s_portion = int(s/volume_parts)
s_portion_prev = s_portion
if z_division==volume_parts:
s_portion = s - volume_parts*s_portion_prev
value_portion, value_portion_arr = make_shared_farray([r_org,c_org,s_portion])
v_queue = multiprocessing.Queue()
finished_count = multiprocessing.Value(ctypes.c_long, 0)
buckets=s_portion
for bucket in range(buckets):
v_queue.put(bucket)
def thread_proc():
while True:
try:
bucket = v_queue.get_nowait()
except:
break
beta_mat_block=beta[:,:,(z_division*s_portion)+bucket]
alpha_mat_block=alpha[:,:,(z_division*s_portion)+bucket]
correction_mat_pixel=scsp.diags(Dimg_org[((z_division*s_portion)+bucket)*r_org*c_org:((z_division*s_portion)+bucket+1)*r_org*c_org],0)
correction_mat2_pixel=scsp.eye(r_org*c_org,r_org*c_org)
correction_mat_pixel=scsp.hstack([correction_mat_pixel,correction_mat2_pixel])
del correction_mat2_pixel
beta_mat_block=np.repeat(beta_mat_block,window_size_x,axis=0)
beta_mat=np.repeat(beta_mat_block,window_size_y,axis=1)
del beta_mat_block
beta_mat=np.uint16((float(1)/float(accuracy1))*beta_mat)
beta_changed=rank.bilateral_mean(beta_mat,selem=selem,s0=lower_val_beta,s1=upper_val_beta)
beta_changed=(np.float32(beta_changed))*float(accuracy1)
del beta_mat
beta_vec=np.reshape(beta_changed,(r_org*c_org,1),order='F')
alpha_mat_block=np.repeat(alpha_mat_block,window_size_x,axis=0)
alpha_mat=np.repeat(alpha_mat_block,window_size_y,axis=1)
del alpha_mat_block
alpha_mat=alpha_mat+cnst
alpha_mat=np.uint16((float(1)/float(accuracy2))*alpha_mat)
alpha_changed=rank.bilateral_mean(alpha_mat,selem=selem,s0=lower_val_alpha,s1=upper_val_alpha)
alpha_changed=((np.float32(alpha_changed))*float(accuracy2))-cnst
del alpha_mat
alpha_vec=np.reshape(alpha_changed,(r_org*c_org,1),order='F')
param_vec=np.vstack([beta_vec,alpha_vec])
corrected_data_smoothed=correction_mat_pixel*param_vec
corrected_data_smoothed=np.reshape(corrected_data_smoothed,(r_org,c_org),order='F')
num_finished = 0
with finished_count.get_lock():
finished_count.value += 1
num_finished = finished_count.value
#print ' Finished %d/%d' % (num_finished, buckets)
with value_portion_arr.get_lock():
value_portion[...][:,:,bucket]=corrected_data_smoothed
procs = []
for i in range(num_threads):
p = multiprocessing.Process(target = thread_proc)
p.start()
procs.append(p)
for p in procs:
p.join()
value_total[:,:,(z_division*s_portion_prev):(z_division*s_portion_prev+s_portion)]=value_portion
return value_total
alpha=np.zeros((r_org/window_size_x,c_org/window_size_y,s))
beta=np.zeros((r_org/window_size_x,c_org/window_size_y,s))
#---------------------------------------------------------------------------
for partnum_y in np.arange(num_partitions_y):
for partnum_x in np.arange(num_partitions_x):
partnum=num_partitions_x*partnum_y+partnum_x
f=h5py.File('%s/parameters_final_partition%s_%s.h5' %(output_path,step,partnum),'r')
param=f[group_name].value
alpha_part=np.reshape(param[len(param)/2:],(r/window_size_x,c/window_size_y,s),order='F')
beta_part=np.reshape(param[0:len(param)/2],(r/window_size_x,c/window_size_y,s),order='F')
alpha[(partnum_x*r/window_size_x):((partnum_x+1)*r/window_size_x),(partnum_y*c/window_size_y):((partnum_y+1)*c/window_size_y),:]=alpha_part
beta[(partnum_x*r/window_size_x):((partnum_x+1)*r/window_size_x),(partnum_y*c/window_size_y):((partnum_y+1)*c/window_size_y),:]=beta_part
Corrected_data_smoothed=np.zeros((r_org,c_org,s))
#---------------------------------------------------
del alpha_part
del beta_part
Corrected_data_smoothed=do_bilateral()
var=np.max(Corrected_data_smoothed)-np.min(Corrected_data_smoothed)
Corrected_data_smoothed=(Corrected_data_smoothed-np.min(Corrected_data_smoothed))*float(255)/float(var)
f=h5py.File('%s/normalized_data_final.h5'%output_path,'w')
dset=f.create_dataset(group_name,data=Corrected_data_smoothed)
f.close()
return Corrected_data_smoothed
roi_y1 = image.shape[1]
roi_y2 = 0
image = image[roi_x2:roi_x1, roi_y2:roi_y1]
ground_truth = ground_truth[roi_x2:roi_x1, roi_y2:roi_y1]
if image.ndim == 3:
print "Extract NIR channel"
image = image[:,:,0]
else:
print "One dimension image"
print "OTSU Threshold with sliding window"
selem = rectangle(100,100)
local_otsu = rank.otsu(image, selem)
#
if soil_removed:
soil_removed_image=io.imread(str(sys.argv[3]),as_grey=True)
if (roi == True):
soil_removed_image = soil_removed_image[roi_x2:roi_x1, roi_y2:roi_y1]
ii, jj = np.where(soil_removed_image==0)
image[ii, jj] = 0
binary_image = image > local_otsu
print "Distance Transform"
