def human_afterloop(output_directory, pre_time, fle_name, buffer_directory):
start2 = time()
d_c = import_edited(buffer_directory)
rebw = load(open(buffer_directory+'-'+'DO_NOT_TOUCH_ME.dmp','rb'))
seg_dc = (label(d_c,neighbors=4)+1)*d_c
if np.max(seg_dc)<4:
return 'FAILED: mask for %s looks unsegmented' % fle_name
colormap = repaint_culsters(int(np.max(seg_dc)))
segs = len(set(seg_dc.flatten().tolist()))-1
# shows the result before saving the clustering and printing to the user the number of the images
plt.subplot(1,2,1)
plt.title(fle_name)
plt.imshow(rebw, cmap='gray', interpolation='nearest')
plt.subplot(1,2,2)
plt.title('Segmentation - clusters: %s'%str(segs))
plt.imshow(mark_boundaries(rebw, d_c))
plt.imshow(seg_dc, cmap=colormap, interpolation='nearest', alpha=0.3)
plt.show()
plt.imshow(mark_boundaries(rebw, d_c))
plt.imshow(seg_dc, cmap=colormap, interpolation='nearest', alpha=0.3)
plt.savefig(path.join(output_directory, fle_name+'_%s_clusters.png'%str(segs)), dpi=500, bbox_inches='tight', pad_inches=0.0)
return fle_name+'\t clusters: %s,\t total time : %s'%(segs, "{0:.2f}".format(time()-start2+pre_time))
def watershed(base_image, seed_image=None, threshold_distance=80):
""" execute watershed with chosen seeds
"""
from scipy import ndimage as ndi
from skimage.morphology import watershed
from skimage.feature import peak_local_max
from skimage.morphology import label
import matplotlib.pyplot as plt
distance = ndi.distance_transform_edt(base_image)
# imgplot = plt.imshow(distance)
fig = plt.figure() # a new figure window
ax = fig.add_subplot(1, 1, 1) # specify (nrows, ncols, axnum)
# ax.imshow(distance>threshold_distance, cmap='Greys')
thresh = distance > threshold_distance
ax.imshow(thresh, cmap='Greys')
#local_maxi = peak_local_max(distance, labels=jac, footprint=np.ones((100, 100)), indices=False)
if seed_image is None:
markers = label(thresh)
else:
markers = label(seed_image)
# imgplot = plt.imshow(markers)
watersh = watershed(-distance, markers, mask=base_image)
# plt.imshow(watersh, cmap=plt.cm.viridis, interpolation='nearest')
return watersh
def segmentationize(imageSe):
"""
Divides coherent forms of an image in smaller groups of type integer.
"""
# create an matrix of distances to the next sourrounding area
distance = ndimage.distance_transform_edt(imageSe, sampling=3)
erosed = ndimage.binary_erosion(imageSe, iterations=8).astype(imageSe.dtype)
distanceE = ndimage.distance_transform_edt(erosed, sampling=3)
distance += (2 * distanceE)
labels, num = label(imageSe, background=0, return_num='True')
sizes_image = ndimage.sum(imageSe, labels, range(num))
sizes_image = np.sort(sizes_image, axis=None)
pos = int(0.4 * num)
areal = int(sizes_image[pos] ** 0.5)
if areal <= 10:
areal = 10
elif (areal % 2) != 0:
areal += 1
footer = circarea(areal) # draw circle area
# find the positions of the maxima from the distances
local_maxi = peak_local_max(distance, indices=False, footprint=footer, labels=imageSe)
markers = label(local_maxi)
# watershed algorithm starts at the maxima and returns labels of particles
simplefilter("ignore", FutureWarning) # avoid warning in watershed method
labels_ws = watershed(-distance, markers, mask=imageSe)
simplefilter("default", FutureWarning)
return labels, labels_ws, local_maxi
def test_return_num(self):
x = np.array([[1, 0, 6],
[0, 0, 6],
[5, 5, 5]])
assert_array_equal(label(x, return_num=True)[1], 4)
assert_array_equal(label(x, background=0, return_num=True)[1], 3)
def clear_body(self, body, minimum_object_size_px=2400):
""" Vycisti obraz od stolu a ostatnich veci okolo tela a zanecha pouze a jen telo """
body = scipy.ndimage.filters.gaussian_filter(copy.copy(body).astype(float), sigma=[15, 0, 0]) > 0.7
# fallowing lines are here to supress warning "Only one label was provided to `remove_small_objects`. "
blabeled = morphology.label(body)
if np.max(blabeled) > 1:
body = morphology.remove_small_objects(morphology.label(blabeled), minimum_object_size_px)
del blabeled
body[0] = False
body[-1] = False
body = scipy.ndimage.filters.gaussian_filter(copy.copy(body.astype(float)), sigma=[1, 3, 3]) > 0.2
bodylabel = label(body)
n_of_pixels = [np.count_nonzero(bodylabel==i) for i in range(len(np.unique(bodylabel)))]
labelsort = np.argsort(n_of_pixels)[::-1]
newbody = np.zeros(body.shape)
newbody[bodylabel==labelsort[0]] = body[(bodylabel==labelsort[0])]
newbody[bodylabel==labelsort[1]] = body[(bodylabel==labelsort[1])]
return newbody.astype(bool)
def test_4_vs_8(self):
x = np.array([[0, 1],
[1, 0]], dtype=int)
assert_array_equal(label(x, 4),
[[0, 1],
[2, 3]])
assert_array_equal(label(x, 8),
[[0, 1],
[1, 0]])
def analyseClusters(binary, newlabels):
"""
Calculates the sizes and porosities of the clusters.
"""
# dilate particles to find cluster
dilated = ndimage.binary_dilation(binary, iterations=_DILATIONFACTOR_TO_FIND_CLUSTER)
labels, num = label(dilated, background=0, return_num=True)
pxArea = (_CONVERSIONFACTOR_FOR_PIXEL) ** 2
outputImage = labels.copy()
clusterAreas = np.zeros(num)
porosities = np.zeros(num)
circumference = np.zeros(num)
fcirc = np.zeros(num)
particlesPerCluster = np.zeros(num)
illegalIndex = []
for i in range(num):
cluster = labels == i
cluster = ndimage.binary_fill_holes(cluster)
helper = np.zeros_like(newlabels)
helper[cluster] = newlabels[cluster]
newLabel, particleNum = label(helper, background=0, return_num=True)
particlesPerCluster[i] = particleNum
particleArea = float(np.sum(binary[cluster].astype(np.int)))
# cluster area and porosity
outputImage[cluster] = i
helper = ndimage.binary_erosion(cluster, iterations=_DILATIONFACTOR_TO_FIND_CLUSTER-3, border_value=1)
helper = ndimage.binary_erosion(helper, iterations=3, border_value=0)
fl = float(np.sum(helper[cluster].astype(np.int)))
clusterAreas[i] = fl * pxArea
porosity = (fl - particleArea)/ fl
porosity = porosity if porosity >= 0 else 0.0 # porosity can not be less than 0
porosities[i] = porosity
# circumference
new = np.zeros((helper.shape[0],helper.shape[1],3), dtype=np.uint8)
new[:,:,1] = helper
gray = cv2.cvtColor(new, cv2.COLOR_RGB2GRAY)
gray[gray > 0] = 255
blur = cv2.GaussianBlur(gray,(5,5),0)
gray = cv2.Canny(blur, 10, 200)
contours, hierarchy = cv2.findContours(gray, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
arclength = 0
for con in contours:
arclength += cv2.arcLength(con,True)
circumference[i] = arclength * _CONVERSIONFACTOR_FOR_PIXEL
fcirc[i] = (4. * np.pi * fl) / arclength**2
if fcirc[i] > 1.0: # fcirc can not be greater than 1
illegalIndex.append(i)
fcirc = np.delete(fcirc, illegalIndex)
clusterData = {'areas':clusterAreas,'circ':circumference,'ppc':particlesPerCluster,'fcirc':fcirc,'porosities':porosities}
return outputImage, clusterData, num
def test_4_vs_8(self):
x = np.array([[0, 1],
[1, 0]], dtype=int)
with catch_warnings():
assert_array_equal(label(x, 4),
[[0, 1],
[2, 3]])
assert_array_equal(label(x, 8),
[[0, 1],
[1, 0]])
def label_img(img):
# Labelling the nests is done using connected components
img = create_bin(img)
labeled_img = label(input=img, connectivity=2, background=0)
#min size holes ina nest
rem_holes = remove_small_holes(labeled_img, min_size=100, connectivity=2)
#min size of a nest
labeled_img1 = remove_small_objects(rem_holes, min_size=70, connectivity=2)
labeled = label(labeled_img1, connectivity=2, background=0)
print labeled
return labeled
def test_background(self):
x = np.array([[1, 0, 0],
[1, 1, 5],
[0, 0, 0]])
assert_array_equal(label(x), [[0, 1, 1],
[0, 0, 2],
[3, 3, 3]])
assert_array_equal(label(x, background=0),
[[0, -1, -1],
[0, 0, 1],
[-1, -1, -1]])
def run(self, workspace):
cell_object = workspace.object_set.get_objects(self.primary_objects.value)
cell_labeled = cell_object.get_segmented()
cell_image = cell_object.get_parent_image()
cell_image = (cell_image * 1000).astype(np.uint16)
# object_count = cell_labeled.max()
maxi = skr.maximum(cell_image.astype(np.uint8), skm.disk(10))
local_max = maxi - cell_image < 10
local_max_labelize, object_count = scipy.ndimage.label(local_max, np.ones((3, 3), bool))
histo_local_max, not_use = np.histogram(local_max_labelize, range(object_count + 2))
old = local_max_labelize.copy()
# filter in intensity mean
# =======================================================================
#
# regionprops_result = skmes.regionprops(local_max_labelize, intensity_image=cell_image)
#
# for region in regionprops_result:
# if region["mean_intensity"]
# =======================================================================
# filter on size
for i in range(object_count + 1):
value = histo_local_max[i]
if value > self.range_size.max or value < self.range_size.min:
local_max_labelize[local_max_labelize == i] = 0
# split granule for each cell
cell_labeled = skm.label(cell_labeled)
cell_count = np.max(cell_labeled)
for cell_object_value in range(1, cell_count):
cell_object_mask = cell_labeled == cell_object_value
granule_in_cell = np.logical_and(cell_object_mask, local_max_labelize)
granule_in_cell = skm.label(granule_in_cell)
# ===================================================================
# plt.imshow(granule_in_cell + cell_object_mask)
# plt.show()
# ===================================================================
#
# get the filename
#
measurements = workspace.measurements
file_name_feature = self.source_file_name_feature
filename = measurements.get_current_measurement("Image", file_name_feature)
print "filename = ", filename
def process_img (timestamp,img, point):
img_gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
thr = cv2.adaptiveThreshold(img_gray,255,cv2.ADAPTIVE_THRESH_GAUSSIAN_C,\
cv2.THRESH_BINARY,11,2)
thr = 255 - thr
kernel = np.ones((1,7),np.uint8)
dilated_img = cv2.dilate(thr, kernel,iterations = 1)
L = morphology.label(dilated_img)
#cv2.circle(img,point,5,(255,0,255),3)
#cv2.imshow('img',img)
cnt = 1
for region in regionprops(L):
minr, minc, maxr, maxc = region.bbox
if maxr - minr > 200:
continue
if point[1]>=minr and point[1]<=maxr and point[0]>=minc and point[0]<=maxc:
subimg = img[minr:maxr,minc:maxc]
imgName = 'sub/' + timestamp + '_' + str(cnt) + '.png'
cnt = cnt + 1
cv2.imwrite(imgName,subimg)
def findAllRegions(self):
cleared = self.filtered.copy()
#clear_border(cleared)
label_image = label(cleared)
#borders = numpy.logical_xor(self.filtered, cleared)
#label_image[borders] = 0
return regionprops(label_image, ['Area', 'BoundingBox', 'Centroid'])
def scikit_example_plot_label():
image = data.coins()[50:-50, 50:-50]
# apply threshold
thresh = threshold_otsu(image)
bw = closing(image > thresh, square(3))
# remove artifacts connected to image border
cleared = bw.copy()
clear_border(cleared)
# label image regions
label_image = label(cleared)
borders = np.logical_xor(bw, cleared)
label_image[borders] = -1
fig, ax = plt.subplots(ncols=1, nrows=1, figsize=(6, 6))
ax.imshow(label_image, cmap='jet')
for region in regionprops(label_image, ['Area', 'BoundingBox']):
# skip small images
if region['Area'] < 100:
continue
# draw rectangle around segmented coins
minr, minc, maxr, maxc = region['BoundingBox']
rect = mpatches.Rectangle((minc, minr), maxc - minc, maxr - minr,
fill=False, edgecolor='red', linewidth=2)
ax.add_patch(rect)
plt.show()
def large_contiguous_regions(thresholded_image, min_area): """ NOTE: THIS FUNCTION IS SPECIALLY WRITTEN FOR TRACHEAL SECTIONS. This function gets the largest contiguous region of an image, based on its labels. """ labelled_image = label(thresholded_image) regions = np.zeros((np.shape(thresholded_image)[0], np.shape(thresholded_image)[1])) maxarea = 0 for region in np.unique(labelled_image): image_area = np.shape(labelled_image)[0] ** 2 region_matrix = labelled_image == region region_in_thresholded = np.logical_and(region_matrix, thresholded_image) region_in_thresholded_area = np.sum(region_in_thresholded) if region_in_thresholded_area > image_area * min_area: regions = regions + region_in_thresholded return regions
def separate_segments(self):
"""
Perform image segmentation on the "segment image", and remove any
segments that aren't the right part of the track.
"""
# binary image
binary_segment_image = (
self.end_segment_image > self.options.low_threshold_kev)
# segmentation: labeled regions, 8-connectivity
labels = morph.label(binary_segment_image, connectivity=2)
x1 = self.end_coordinates[0] - self.end_segment_offsets[0]
y1 = self.end_coordinates[1] - self.end_segment_offsets[1]
x2 = self.start_coordinates[0] - self.end_segment_offsets[0]
y2 = self.start_coordinates[1] - self.end_segment_offsets[1]
chosen_label = labels[x1, y1]
if labels[x2, y2] != chosen_label:
# this happens with 4-connectivity. need to use 8-connectivity
raise RuntimeError('What the heck happened?')
binary_again = (labels == chosen_label)
# dilate this region, in order to capture information below threshold
# (it won't include the other regions, because there must be a gap
# between)
pix_to_keep = morph.binary_dilation(binary_again)
self.end_segment_image[np.logical_not(pix_to_keep)] = 0
def single_out_annotation(base_image, small_cc_image):
""" extracting individual annotations :
starting from potential annotation + noise, we remove the noise and
consolidate annotation area, then return the coordinates of center of
potential annotations"""
# remove small stuff
filtered_small_cc, removed_small_cc_small = remove_small_ccomponents(small_cc_image, size_closing=5, hist_thres=120)
#plot_image(removed_small_cc_small)
# dilate
from skimage.morphology import binary_dilation, disk
dilation_radius = 10
small_cc_cleaned_mask = binary_dilation(filtered_small_cc, disk(dilation_radius))
#plot_image(small_cc_cleaned_mask)
#label connected compoenents
from skimage.morphology import label
from skimage.measure import regionprops
from skimage.io import imsave
markers, n_label = label(small_cc_cleaned_mask, connectivity=1, background=0, return_num=True)
#for each cc, defines a region
region_prop = regionprops(markers, (base_image*255).astype(np.uint8))
#for each region, do something
base_path = '/media/sf_RemiCura/PROJETS/belleepoque/extract_data_from_old_paris_map/jacoubet/results/annotations/'
for region in region_prop:
#print(region.bbox, region.area)
imsave(base_path+str(region.bbox)+'.png', region.intensity_image)
return region_prop
def roofRegion(edge):
"""Estimate region based on edges of roofRegion
"""
# apply threshold
thresh = threshold_otsu(image)
bw = closing(image > thresh, square(3))
# remove artifacts connected to image border
cleared = bw.copy()
clear_border(cleared)
# label image regions
label_image = label(cleared)
borders = np.logical_xor(bw, cleared)
label_image[borders] = -1
image_label_overlay = label2rgb(label_image, image=image)
fig, ax = plt.subplots(ncols=1, nrows=1, figsize=(6, 6))
ax.imshow(image_label_overlay)
for region in regionprops(label_image):
# skip small images
if region.area < 100:
continue
# draw rectangle around segmented coins
minr, minc, maxr, maxc = region.bbox
rect = mpatches.Rectangle((minc, minr), maxc - minc, maxr - minr,
fill=False, edgecolor='red', linewidth=2)
ax.add_patch(rect)
plt.show()
def get_cells(image):
'''
Get cellls from the polygon.
'''
new_image=np.ones([3,image.shape[0],image.shape[1]],dtype=float)
# apply threshold
thresh = threshold_otsu(image)
bw=image
# remove artifacts connected to image border
cleared = bw.copy()
clear_border(cleared)
# label image regions
label_image = label(cleared)
#skimage.measure.label
#find_contours
borders = np.logical_xor(bw, cleared)
label_image[borders] = -1
image_label_overlay = label2rgb(label_image, image=image)
#extract the regions and get a polygon per region
polygons=[]
for i,region in enumerate(regionprops(label_image)):
# skip small images
if region.area < 100:
continue
#polygons.append(matplotlib.path.Path(region.coords))
print (region.coords.shape)
a=np.zeros(region.coords.shape)
a[:,0]=region.coords[:,1]
a[:,1]=region.coords[:,0]
polygons.append(a)
return polygons
def remove_none_edge_intersecting(img, edge=0, width=1):
mask = np.zeros(img.shape,dtype=int)
out = np.zeros(img.shape,dtype=int)
# print '--->', img.sum()
if edge == 0:
mask[:,0:0+width] = 1
elif edge == 1:
mask[:,-1-width:-1] = 1
elif edge == 2:
mask[0:width,:] = 1
elif edge == 3:
mask[-1-width:-1,:] = 1
else:
raise ValueError('Edge is duff')
s = label(img.astype(int))
s_set = np.unique(s * mask)
if s_set.sum() > 0:
for v in s_set:
q = (s == v)
if np.all(img[q]):
out[s == v] = 1
return out
def single_out_annotation(base_image, small_cc_image):
""" extracting individual annotations :
starting from potential annotation + noise, we remove the noise and
consolidate annotation area, then return the coordinates of center of
potential annotations"""
import numpy as np
# remove small stuff
filtered_small_cc, removed_small_cc_small = remove_small_ccomponents(
small_cc_image, size_closing=5, hist_thres=120)
# plot_image(removed_small_cc_small)
# dilate
from skimage.morphology import binary_dilation, disk
dilation_radius = 10
small_cc_cleaned_mask = binary_dilation(filtered_small_cc, disk(dilation_radius))
# plot_image(small_cc_cleaned_mask)
# label connected compoenents
from skimage.morphology import label
from skimage.measure import regionprops
markers, n_label = label(small_cc_cleaned_mask, connectivity=1, background=0, return_num=True)
# for each cc, defines a region
image_for_region = (base_image*255).astype(np.uint8)
region_prop = regionprops(markers, image_for_region)
# for each region, do something
return region_prop
def getRegions():
"""Geocode address and retreive image centered
around lat/long"""
address = request.args.get('address')
results = Geocoder.geocode(address)
lat, lng = results[0].coordinates
zip_code = results[0].postal_code
map_url = 'https://maps.googleapis.com/maps/api/staticmap?center={0},{1}&size=640x640&zoom=19&sensor=false&maptype=roadmap&&style=visibility:simplified|gamma:0.1'
request_url = map_url.format(lat, lng)
req = urllib.urlopen(request_url)
img = io.imread(req.geturl(),flatten=True)
labels, numobjects = ndimage.label(img)
image = filter.canny(img, sigma=3)
thresh = threshold_otsu(image)
bw = closing(image > thresh, square(3))
# remove artifacts connected to image border
cleared = bw.copy()
clear_border(cleared)
# label image regions
label_image = label(cleared)
borders = np.logical_xor(bw, cleared)
label_image[borders] = -1
image_label_overlay = label2rgb(label_image, image=image)
fig, ax = plt.subplots(ncols=1, nrows=1, figsize=(6, 6))
ax.imshow(image_label_overlay)
def FilterChangeByArea(self,area):
size = np.round(area / (0.4**2)) #devide with square of image resolution
BinArray = gfh.ReadData(self.chng)
BigChng = np.zeros(np.shape(BinArray))
LabelArray = morphology.label(np.squeeze(BinArray))
N_chng = np.max(LabelArray)
if N_chng > 0:
k = 1
for i in range(N_chng):
indx,indy = np.where(LabelArray == i)
#larger than x m² and smaller than half the image
if (len(indx) >= size) & (len(indx) < (self.Ndata/2)):
BigChng[indx,indy] = k
k += 1
print str(k)
ROI = gfh.ReadData(self.ROI)
xROI,yROI,_ = np.where(ROI == 0)
BigChng[xROI,yROI] = -9999
gfh.WriteToFile(self.chng,BigChng)
gfh.TIFF2PNG(self.chng,self.png_path + 'chng_AreaSelect' +
self.png_fn_tag,'Fit')
else:
print 'no changes found, test thresholdvalues!'
return 0
def test_random(self):
x = (np.random.random((20, 30)) * 5).astype(np.int)
labels = label(x)
n = labels.max()
for i in range(n):
values = x[labels == i]
assert np.all(values == values[0])
def treshold(self, value):
value = 2 * value
self.image_tresholded = (self.image_array > value)
self.image_labeled = label(self.image_tresholded)
self.image_labl.setImage(self.image_labeled)
self.image_orig.setImage(np.ma.masked_array(self.image_tresholded,
mask=(self.image_array > value)))
self.text.setText('value {}'.format(value))
self.tresh = value
def test_background_two_regions(self):
x = np.array([[0, 0, 6],
[0, 0, 6],
[5, 5, 5]])
assert_array_equal(label(x, background=0),
[[-1, -1, 0],
[-1, -1, 0],
[ 1, 1, 1]])
def ProcessImage(im, targetDim = 250, doDenoiseOpening = True):
#Resize to specified pixels max edge size
scaling = 1.
if im.shape[0] > im.shape[1]:
if im.shape[0] != targetDim:
scaling = float(targetDim) / im.shape[0]
im = misc.imresize(im, (targetDim, int(round(im.shape[1] * scaling))))
else:
if im.shape[1] != targetDim:
scaling = float(targetDim) / im.shape[1]
im = misc.imresize(im, (int(round(im.shape[0] * scaling)), targetDim))
#print "scaling", scaling
greyim = 0.2126 * im[:,:,0] + 0.7152 * im[:,:,1] + 0.0722 * im[:,:,2]
#Highlight number plate
imnorm = np.array(greyim, dtype=np.uint8)
se = np.ones((3, 30), dtype=np.uint8)
opim = morph.opening(imnorm, se)
diff = greyim - opim + 128.
misc.imsave("diff.png", diff)
#Binarize image
vals = diff.copy()
vals = vals.reshape((vals.size))
meanVal = vals.mean()
stdVal = vals.std()
threshold = meanVal + stdVal
#print "Threshold", threshold
binIm = diff > threshold
misc.imsave("threshold.png", binIm)
#print vals.shape
#plt.plot(vals)
#plt.show()
#Denoise
diamond = morph.diamond(2)
if doDenoiseOpening:
currentIm = morph.binary_opening(binIm, diamond)
else:
currentIm = binIm
denoiseIm2 = morph.binary_closing(currentIm, np.ones((3, 13)))
#print "currentIm", currentIm.min(), currentIm.max(), currentIm.mean()
#print "denoiseIm2", denoiseIm2.min(), denoiseIm2.max(), currentIm.mean()
#misc.imsave("denoised1.png", currentIm * 255)
#misc.imsave("denoised2.png", denoiseIm2 * 255)
#Number candidate regions
#print "Numbering regions"
numberedRegions, maxRegionNum = morph.label(denoiseIm2, 4, 0, return_num = True)
return numberedRegions, scaling
def getArea(address):
"""Geocode address and retreive image centered
around lat/long"""
address = address
results = Geocoder.geocode(address)
lat, lng = results[0].coordinates
zip_code = results[0].postal_code
map_url = 'https://maps.googleapis.com/maps/api/staticmap?center={0},{1}&size=640x640&zoom=19&sensor=false&maptype=roadmap&&style=visibility:simplified|gamma:0.1'
request_url = map_url.format(lat, lng)
req = urllib.urlopen(request_url)
img = io.imread(req.geturl(),flatten=True)
labels, numobjects = ndimage.label(img)
image = filter.canny(img, sigma=3)
thresh = threshold_otsu(image)
bw = closing(image > thresh, square(3))
# remove artifacts connected to image border
cleared = bw.copy()
clear_border(cleared)
# label image regions
label_image = label(cleared)
borders = np.logical_xor(bw, cleared)
label_image[borders] = -1
image_label_overlay = label2rgb(label_image, image=image)
fig, ax = plt.subplots(ncols=1, nrows=1, figsize=(6, 6))
ax.imshow(image_label_overlay)
dist = []
rp = regionprops(label_image)
rp = [x for x in rp if 100 < x.area <= 900]
for region in rp:
# skip small images
#if region.area < 100:
# continue
dist.append(sqrt( ( 320-region.centroid[0] )**2 + ( 320-region.centroid[1] )**2 ))
# draw rectangle around segmented coins
#minr, minc, maxr, maxc = region.bbox
#rect = mpatches.Rectangle((minc, minr), maxc - minc, maxr - minr,
# fill=False, edgecolor='red', linewidth=2)
#ax.add_patch(rect)
roof_index = dist.index(min(dist))
minr, minc, maxr, maxc = rp[roof_index].bbox
rect = mpatches.Rectangle((minc, minr), maxc - minc, maxr - minr,
fill=False, edgecolor='red', linewidth=2)
ax.add_patch(rect)
img = StringIO()
fig.savefig(img)
img.seek(0)
session['roof_area'] = rp[roof_index].area
roof_area = (rp[roof_index].area)*12
return(roof_area)
def mixing_region(filename):
white = io.imread(filename)
val = filter.threshold_otsu(white)
light_mask = white > val
regions = morphology.label(light_mask)
index_large_region = np.argmax(np.bincount(regions.ravel()))
fluid_mask = regions == index_large_region
fluid_mask = morphology.binary_erosion(fluid_mask, selem=np.ones((3, 3)))
return fluid_mask
def test_background_one_region_center(self):
x = np.array([[0, 0, 0],
[0, 1, 0],
[0, 0, 0]])
assert_array_equal(label(x, neighbors=4, background=0),
[[-1, -1, -1],
[-1, 0, -1],
[-1, -1, -1]])
def quick_features(img,save_to_disk=False,abs_path='',file_prefix='',cfg = []):
# Pull out some settings from cfg if available
if cfg:
min_obj_area = cfg.get('MinObjectArea',100)
objs_per_roi = cfg.get('ObjectsPerROI',1)
deconv = cfg.get("Deconvolve").lower() == 'true'
edge_thresh = cfg.get('EdgeThreshold',2.5)
use_jpeg = cfg.get("UseJpeg").lower() == 'true'
raw_color = cfg.get("SaveRawColor").lower() == 'true'
else:
min_obj_area = 100
objs_per_roi = 1
deconv = False
use_jpeg = False
raw_color = True
edge_thresh = 2.5
# Define an empty dictionary to hold all features
features = {}
features['rawcolor'] = np.copy(img)
# compute features from gray image
gray = np.uint8(np.mean(img,2))
# threshold-based segmentation
#med_val = np.median(gray)
#std_val = np.std(gray)
#thresh1 = threshold_otsu(gray)
#thresh3 = med_val + 1.6*std_val
#binary = (gray >= thresh1) | (gray >= thresh3)
#bw_img1 = morphology.closing(binary,morphology.square(3))
# edge-based segmentation
edges_mag = scharr(gray)
edges_med = np.median(edges_mag)
edges_thresh = edge_thresh*edges_med
edges = edges_mag >= edges_thresh
edges = morphology.closing(edges,morphology.square(3))
filled_edges = ndimage.binary_fill_holes(edges)
edges = morphology.erosion(filled_edges,morphology.square(3))
#edges = morphology.erosion(edges,morphology.square(3))
# combine threshold and edge based segmentations
bw_img2 = edges
#bw_img = np.pad(bw_img2,1, 'constant')
bw_img = bw_img2
# Compute morphological descriptors
label_img = morphology.label(bw_img,neighbors=8,background=0)
props = measure.regionprops(label_img,gray)
# clear bw_img
bw_img = 0*bw_img
props = sorted(props, reverse=True, key=lambda k: k.area)
if len(props) > 0:
# Init mask with the largest area object in the roi
bw_img = (label_img)== props[0].label
base_area = props[0].area
# use only the features from the object with the largest area
max_area = 0
max_area_ind = 0
avg_area = 0.0
avg_maj = 0.0
avg_min = 0.0
avg_or = 0.0
avg_count = 0
if len(props) > objs_per_roi:
n_objs = objs_per_roi
else:
n_objs = len(props)
for f in range(0,n_objs):
if props[f].area > min_obj_area:
bw_img = bw_img + ((label_img)== props[f].label)
avg_count = avg_count + 1
if f >= objs_per_roi:
break
# Take the largest object area as the roi area
# no average
avg_area = props[0].area
avg_maj = props[0].major_axis_length
avg_min = props[0].minor_axis_length
avg_or = props[0].orientation
# Check for clipped image
if np.max(bw_img) == 0:
bw = bw_img
else:
bw = bw_img/np.max(bw_img)
clip_frac = float(np.sum(bw[:,1]) +
np.sum(bw[:,-2]) +
np.sum(bw[1,:]) +
np.sum(bw[-2,:]))/(2*bw.shape[0]+2*bw.shape[1])
features['clipped_fraction'] = clip_frac
# Save simple features of the object
features['area'] = avg_area
features['minor_axis_length'] = avg_min
features['major_axis_length'] = avg_maj
if avg_maj == 0:
features['aspect_ratio'] = 1
else:
features['aspect_ratio'] = avg_min/avg_maj
features['orientation'] = avg_or
# print "Foreground Objects: " + str(avg_count)
else:
features['clipped_fraction'] = 0.0
# Save simple features of the object
features['area'] = 0.0
features['minor_axis_length'] = 0.0
features['major_axis_length'] = 0.0
features['aspect_ratio'] = 1
features['orientation'] = 0.0
# Masked background with Gaussian smoothing, image sharpening, and
# reduction of chromatic aberration
# mask the raw image with smoothed foreground mask
blurd_bw_img = gaussian(bw_img,3)
img[:,:,0] = img[:,:,0]*blurd_bw_img
img[:,:,1] = img[:,:,1]*blurd_bw_img
img[:,:,2] = img[:,:,2]*blurd_bw_img
# Make a guess of the PSF for sharpening
psf = make_gaussian(5, 3, center=None)
# sharpen each color channel and then reconbine
if np.max(img) == 0:
img = np.float32(img)
else:
img = np.float32(img)/np.max(img)
if deconv:
img[img == 0] = 0.0001
img[:,:,0] = restoration.richardson_lucy(img[:,:,0], psf, 7)
img[:,:,1] = restoration.richardson_lucy(img[:,:,1], psf, 7)
img[:,:,2] = restoration.richardson_lucy(img[:,:,2], psf, 7)
# Estimate color channel shifts and try to align.
# this works for most images but some still retain and offset.
# need to figure out why...
# r_shift, r_error, r_diffphase = register_translation(img[:,:,1], img[:,:,2],1)
# b_shift, b_error, b_diffphase = register_translation(img[:,:,1], img[:,:,0],1)
# # this swap of values is needed for some reason
# if r_shift[0] < 0 and r_shift[1] < 0:
# r_shift = -r_shift
# if b_shift[0] < 0 and b_shift[1] < 0:
# b_shift = -b_shift
# r_tform = transform.SimilarityTransform(scale=1,rotation=0,translation=r_shift)
# img[:,:,2] = transform.warp(img[:,:,2],r_tform)
# b_tform = transform.SimilarityTransform(scale=1,rotation=0,translation=b_shift)
# img[:,:,0] = transform.warp(img[:,:,0],b_tform)
# Rescale image to uint8 0-255
img[img < 0] = 0
if np.max(img) == 0:
img = np.uint8(255*img)
else:
img = np.uint8(255*img/np.max(img))
features['image'] = img
features['binary'] = 255*bw_img
# Save the binary image and also color image if requested
if save_to_disk:
#try:
# convert and save images
# Raw color (no background removal)
if use_jpeg:
if raw_color:
cv2.imwrite(os.path.join(abs_path,file_prefix+"_rawcolor.jpeg"),features['rawcolor'])
# Save the processed image and binary mask
cv2.imwrite(os.path.join(abs_path,file_prefix+".jpeg"),features['image'])
else:
if raw_color:
cv2.imwrite(os.path.join(abs_path,file_prefix+"_rawcolor.png"),features['rawcolor'])
# Save the processed image and binary mask
cv2.imwrite(os.path.join(abs_path,file_prefix+".png"),features['image'])
# Binary should also be saved png
cv2.imwrite(os.path.join(abs_path,file_prefix+"_binary.png"),features['binary'])
return features
image[ii, jj] = 0
binary_image = image > local_otsu
print "Distance Transform"
distance = ndimage.distance_transform_edt(binary_image)
print "Extract local maxima"
local_maxi = peak_local_max(distance,
indices=False,
footprint=np.ones((55, 55)),
threshold_abs=10,
labels=binary_image)
print "Markers for WS"
markers = morphology.label(local_maxi)
print "Watershed"
start_ws = time.clock()
labels_ws = watershed(-distance, markers, mask=binary_image)
end_ws = time.clock()
time_ws = end_ws - start_ws
imsave("labelsws.png", labels_ws)
print "Threshold to extract circles"
rest, ground_truth = cv2.threshold(ground_truth, 7, 255, cv2.THRESH_BINARY)
print "HoughCircles"
circles = cv2.HoughCircles(ground_truth,
cv.CV_HOUGH_GRADIENT,
def segment_image(pic_array, gaussian, blurred, equalized, cwhite):
###Blur image with the specified gaussian kernel
if (cwhite):
mean = np.mean(pic_array)
pic_array[pic_array > mean] = pic_array[pic_array > mean] - mean
if (blurred):
pic_convolved = scipy.signal.fftconvolve(pic_array,
gaussian[0],
mode='same')
else:
pic_convolved = pic_array
if (equalized):
pic_convolved = exposure.equalize_hist(pic_convolved)
###Segment middle layer
mean = np.mean(pic_convolved) + np.std(pic_convolved)
pic_layer1 = mp.dilation(pic_convolved > mean, mp.square(4))
###Segment top layer
mean = np.mean(pic_convolved[pic_layer1 == 0]) + np.std(
pic_convolved[pic_layer1 == 0]) / 2
pic_layer2 = np.invert(mp.erosion(pic_convolved < mean, mp.square(4)))
###Merge layers
final_picture = pic_layer1 * 2 + pic_layer2
###Split layers into connected components
conn_comps_layer0 = mp.label(final_picture < 1, connectivity=1)
conn_comps_layer1 = mp.label(final_picture == 1, connectivity=1)
conn_comps_layer2 = mp.label(final_picture > 1, connectivity=1)
###Create labelled output image (print preview)
layered_output_image = np.zeros(conn_comps_layer0.shape)
###Split segments into seperate entities for future slicing
bottom_imgs = []
middle_imgs = []
top_imgs = []
threshold = -1 #conn_comps_layer0.shape[0]*conn_comps_layer0.shape[1]/64
for i in range(0, np.max(conn_comps_layer0))[:1]:
new_layer = (conn_comps_layer0 == i)
if np.sum(new_layer) > threshold:
#new_layer = np.invert(new_layer)
bottom_imgs.append(new_layer)
layered_output_image = layered_output_image + new_layer * (1 + i)
#threshold = -1
for i in range(0, np.max(conn_comps_layer1))[:1]:
new_layer = (conn_comps_layer1 == i)
if np.sum(new_layer) > threshold:
#new_layer = np.invert(new_layer)
middle_imgs.append(new_layer)
layered_output_image = layered_output_image + new_layer * (11 + i)
for i in range(0, np.max(conn_comps_layer2))[:1]:
new_layer = (conn_comps_layer2 == i)
if np.sum(new_layer) > threshold:
#new_layer = np.invert(new_layer)
top_imgs.append(new_layer)
layered_output_image = layered_output_image + new_layer * (21 + i)
###Return all values
return final_picture, layered_output_image, bottom_imgs, middle_imgs, top_imgs
img_nuc_dilated) # expand x, y, z
for n in range(20): # ~ 1 um in x, y
for z in range(img_nuc_dilated.shape[2]):
img_nuc_dilated[:, :, z] = morphology.binary_dilation(
img_nuc_dilated[:, :, z]) # expand x, y only
region_peri = np.where(
np.logical_and(
img_nuc_dilated > region_nuc,
np.logical_or(img_fiber_only.astype(bool),
nuclei_binary.astype(bool))), 1, 0)
region_cyt = np.where(img_fiber_only > img_nuc_dilated, 1, 0)
regions = {'nuc': region_nuc, 'cyt': region_cyt, 'peri': region_peri}
region_nuc_peri = np.where(region_peri + region_nuc >= 1, 1, 0)
labeled_nuc_peri, n_nucperi = morphology.label(region_nuc_peri,
return_num=True)
if should_plot:
su.animate_zstacks(
[
region_nuc, region_peri, region_cyt,
region_cyt + 2 * region_peri + 3 * region_nuc
],
titles=['nuclear', 'perinuclear', 'sarcoplasmic', 'all compartments'],
cmaps=['binary_r', 'binary_r', 'binary_r', 'gnuplot2'],
gif_name=os.path.join(outdir, 'anim', img_name + '_regions.gif'))
#-- RNA DETECTION AND ANALYSIS -----------------------------------------------#
# iterate over RNAs in image
for chan, gene in enumerate(genes):
import matplotlib.pyplot as plt
import numpy as np
from skimage.draw import ellipse
from skimage.morphology import label
from skimage.measure import regionprops
from skimage.transform import rotate
image = np.zeros((600, 600))
rr, cc = ellipse(300, 350, 100, 220)
image[rr, cc] = 1
image = rotate(image, angle=15, order=0)
label_img = label(image)
regions = regionprops(label_img)
fig, ax = plt.subplots()
ax.imshow(image, cmap=plt.cm.gray)
for props in regions:
y0, x0 = props.centroid
orientation = props.orientation
x1 = x0 + math.cos(orientation) * 0.5 * props.major_axis_length
y1 = y0 - math.sin(orientation) * 0.5 * props.major_axis_length
x2 = x0 - math.sin(orientation) * 0.5 * props.minor_axis_length
y2 = y0 - math.cos(orientation) * 0.5 * props.minor_axis_length
ax.plot((x0, x1), (y0, y1), '-r', linewidth=2.5)
ax.plot((x0, x2), (y0, y2), '-r', linewidth=2.5)
dice_scores_i.append(
T.constant(2) * intersect[i] / (denominator[i] + T.constant(1e-6)))
dice_scores = (T.constant(w[0])*dice_scores_i[0]+T.constant(w[1])*dice_scores_i[1]\
+T.constant(w[2])*dice_scores_i[2]+T.constant(w[3])*dice_scores_i[3])
x = T.matrix('total')
z = x / 8
divide = theano.function([x], z)
dice_scores = divide(dice_scores)
return dice_scores
x = np.array([[[0, 0, 0], [0, 0, 0], [0, 0, 0]],
[[1, 0, 1], [2, 0, 0], [3, 1, 0]]])
mask = np.array(x != 0).astype(int)
lbls = label(mask, 4)
lbls_sizes = [np.sum(lbls == i) for i in np.unique(lbls)]
largest_region = np.argmax(
lbls_sizes[1:]) + 1 # from 1 because need excluding the background
x[lbls != largest_region] = 0
print(x)
print(np.argmax(x))
print(x)
print(label(x, 4))
# data = np.array([1,2,3])
# print(data)
# data = np.vstack([data]*3)
#
#
# w = np.zeros(4, dtype=np.float32)
def topo_metric(gt, pred, thresh, n_paths):
# 0, 1 and 2 mean, respectively, that path is infeasible, shorter/larger and correct
result = []
# binarize pred according to thresh
pred_bw = (pred > thresh).astype(int)
pred_cc = morphology.label(pred_bw)
# get centerlines of gt and pred
gt_cent = morphology.skeletonize(gt > 0.5)
gt_cent_cc = morphology.label(gt_cent)
pred_cent = morphology.skeletonize(pred_bw)
pred_cent_cc = morphology.label(pred_cent)
# costs matrices
gt_cost = np.ones(gt_cent.shape)
gt_cost[gt_cent == 0] = 10000
pred_cost = np.ones(pred_cent.shape)
pred_cost[pred_cent == 0] = 10000
# build graph and find shortest paths
for i in range(n_paths):
# pick randomly a first point in the centerline
R_gt_cent, C_gt_cent = np.where(gt_cent == 1)
idx1 = randint(0, len(R_gt_cent) - 1)
label = gt_cent_cc[R_gt_cent[idx1], C_gt_cent[idx1]]
ptx1 = (R_gt_cent[idx1], C_gt_cent[idx1])
# pick a second point that is connected to the first one
R_gt_cent_label, C_gt_cent_label = np.where(gt_cent_cc == label)
idx2 = randint(0, len(R_gt_cent_label) - 1)
ptx2 = (R_gt_cent_label[idx2], C_gt_cent_label[idx2])
# if points have different labels in pred image, no path is feasible
if (pred_cc[ptx1] != pred_cc[ptx2]) or pred_cc[ptx1] == 0:
result.append(0)
else:
# find corresponding centerline points in pred centerlines
R_pred_cent, C_pred_cent = np.where(pred_cent == 1)
poss_corr = np.zeros((len(R_pred_cent), 2))
poss_corr[:, 0] = R_pred_cent
poss_corr[:, 1] = C_pred_cent
poss_corr = np.transpose(np.asarray([R_pred_cent, C_pred_cent]))
dist2_ptx1 = np.sum((poss_corr - np.asarray(ptx1))**2, axis=1)
dist2_ptx2 = np.sum((poss_corr - np.asarray(ptx2))**2, axis=1)
corr1 = poss_corr[np.argmin(dist2_ptx1)]
corr2 = poss_corr[np.argmin(dist2_ptx2)]
# find shortest path in gt and pred
gt_path, cost1 = graph.route_through_array(gt_cost, ptx1, ptx2)
gt_path = np.asarray(gt_path)
pred_path, cost2 = graph.route_through_array(
pred_cost, corr1, corr2)
pred_path = np.asarray(pred_path)
# compare paths length
path_gt_length = np.sum(
np.sqrt(np.sum(np.diff(gt_path, axis=0)**2, axis=1)))
path_pred_length = np.sum(
np.sqrt(np.sum(np.diff(pred_path, axis=0)**2, axis=1)))
if pred_path.shape[0] < 2:
result.append(2)
else:
if ((path_gt_length / path_pred_length) < 0.9) or (
(path_gt_length / path_pred_length) > 1.1):
result.append(1)
else:
result.append(2)
return result.count(0), result.count(1), result.count(2)
def partition_instances(raw_bodies, raw_markers=None, raw_edges=None):
threshold=config['param'].getfloat('threshold')
threshold_edge = config['param'].getfloat('threshold_edge')
threshold_marker = config['param'].getfloat('threshold_mark')
policy = config['post']['policy']
min_object_size = config['post'].getint('min_object_size')
# Random Walker fails for a 1-pixel seed, which is exactly on top of a 1-pixel semantic mask.
# https://github.com/scikit-image/scikit-image/issues/1875
# Workaround by eliminating 1-pixel semantic mask first.
bodies = raw_bodies > threshold
bodies = drop_small_blobs(bodies, 2) # bodies must be larger than 1-pixel
markers = None if raw_markers is None else (raw_markers > threshold_marker)
edges = None if raw_edges is None else (raw_edges > threshold_edge)
if markers is not None and edges is not None:
markers = (markers & ~edges) & bodies
# remove artifacts caused by non-perfect (mask - contour)
markers = drop_small_blobs(markers, min_object_size)
markers = label(markers)
elif markers is not None:
markers = markers & bodies
markers = label(markers)
elif edges is not None:
# to remedy error-dropped edges around the image border (1 or 2 pixels holes)
box_bodies = bodies.copy()
h, w = box_bodies.shape
box_bodies[0:2, :] = box_bodies[h-2:, :] = box_bodies[:, 0:2] = box_bodies[:, w-2:] = 0
markers = box_bodies & ~edges
markers = drop_small_blobs(markers, min_object_size)
markers = label(markers)
else:
threshold=config['param'].getfloat('threshold')
size_scale=config['post'].getfloat('seg_scale')
ratio=config['post'].getfloat('seg_ratio')
size_index = mean_blob_size(bodies, ratio)
"""
Add noise to fix min_distance bug:
If multiple peaks in the specified region have identical intensities,
the coordinates of all such pixels are returned.
"""
noise = np.random.randn(bodies.shape[0], bodies.shape[1]) * 0.1
distance = ndi.distance_transform_edt(bodies)+noise
# 2*min_distance+1 is the minimum distance between two peaks.
local_maxi = peak_local_max(distance, min_distance=(size_index*size_scale), exclude_border=False,
indices=False, labels=bodies)
markers = label(local_maxi)
if policy == 'ws':
seg_labels = watershed(-ndi.distance_transform_edt(bodies), markers, mask=bodies)
elif policy == 'rw':
markers[bodies == 0] = -1
if np.sum(markers > 0) > 0:
seg_labels = random_walker(bodies, markers)
else:
seg_labels = np.zeros_like(markers, dtype=np.int32)
seg_labels[seg_labels <= 0] = 0
markers[markers <= 0] = 0
else:
raise NotImplementedError("Policy not implemented")
final_labels = add_missed_blobs(bodies, seg_labels, edges)
return final_labels, markers
def step(self, gradient, step_size):
mask_out_restrictions = gradient * self.restrictions
self.w[0] = self.proposed_design_step(mask_out_restrictions, step_size)
self.current_iteration += 1
if (self.current_iteration %
self.num_free_iterations_between_patches) > 0:
# Update the variable stack including getting the permittivity at the w[-1] position
self.update_permittivity()
return
#
# How far do we have to move? Should we include the gradient information in there as well (i.e. - weight also by the gradient?)?
#
costs = self.topological_correction_value - self.w[0]
#
# For now, let's assume the density does not vary over each layer and that we can just patch up on sublayer in a layer
# and use that solution for the whole layer
#
topological_patch_start = time.time()
get_layer_idxs = self.layering_z_1.get_layer_idxs(self.w[0].shape)
for layer in range(0, self.layering_z_1.num_layers):
get_layer_idx = get_layer_idxs[layer]
next_layer_idx = self.w[0].shape[2]
if layer < (self.layering_z_1.num_layers - 1):
next_layer_idx = get_layer_idxs[layer + 1]
bridges(self.w[0][:, :, get_layer_idx],
self.restrictions[:, :, get_layer_idx],
costs[:, :,
get_layer_idx], self.topological_correction_value)
for sublayer_idx in range(1 + get_layer_idx, next_layer_idx):
self.w[0][:, :, sublayer_idx] = self.w[0][:, :, get_layer_idx]
self.restrictions[:, :,
sublayer_idx] = self.restrictions[:, :,
sublayer_idx]
topological_patch_elapsed = time.time() - topological_patch_start
# Update the variable stack including getting the permittivity at the w[-1] position
self.update_permittivity()
# The substrate on the top changes this padding
cur_fabrication_target = self.fabricate_mask()
pad_cur_fabrication_target = np.pad(cur_fabrication_target,
((1, 1), (1, 1), (1, 1)),
mode='constant')
pad_cur_fabrication_target[:, :,
pad_cur_fabrication_target.shape[2] - 1] = 1
[solid_labels,
num_solid_labels] = skim.label(pad_cur_fabrication_target,
neighbors=4,
return_num=True)
[void_labels,
num_void_labels] = skim.label(1 - pad_cur_fabrication_target,
neighbors=8,
return_num=True)
print("Topology Information:")
print("To patch all of the topology took " +
str(topological_patch_elapsed) + " seconds")
print("The current number of total solid components is " +
str(num_solid_labels))
print("The current number of total void components is " +
str(num_void_labels))
for layer in range(0, self.layering_z_1.num_layers):
get_layer_idx = get_layer_idxs[layer]
[solid_labels, num_solid_labels
] = skim.label(pad_cur_fabrication_target[:, :,
1 + get_layer_idx],
neighbors=4,
return_num=True)
[void_labels, num_void_labels] = skim.label(
1 - pad_cur_fabrication_target[:, :, 1 + get_layer_idx],
neighbors=8,
return_num=True)
print("The current number of solid components on layer " +
str(layer) + " is " + str(num_solid_labels))
print("The current number of void components on layer " +
str(layer) + " is " + str(num_void_labels))
print("\n\n")
self.restrictions[0:blur_half_width_voxels, :, :] = 0
self.restrictions[:, 0:blur_half_width_voxels, :] = 0
self.restrictions[(self.restrictions.shape[0] -
blur_half_width_voxels):(
self.restrictions.shape[0]), :, :] = 0
self.restrictions[:, (self.restrictions.shape[1] -
blur_half_width_voxels):(
self.restrictions.shape[1]), :] = 0
def crop_cell(image, min_size=20000, max_size=90000, ar_thres=0.6):
max_proj = np.max(image, axis=0)
mask_image = max_proj > np.mean(max_proj) + 0.5 * np.std(max_proj)
clean_mask = morphology.remove_small_objects(mask_image, min_size=min_size)
label_mask = morphology.label(clean_mask)
fig, ax = plt.subplots(figsize=(10, 10))
ax.imshow(max_proj, cmap=plt.cm.gray)
bounding_box = []
num_1 = 0 # number of cells that are too close to the image borders
num_2 = 0 # number of cells that are too elongated
num_3 = 0 # number of cells that are too big
num_4 = 0 # number of cells that are being analyzed
for aCell in measure.regionprops(label_mask):
min_row, min_col, max_row, max_col = aCell.bbox
aspect_ratio = aCell.minor_axis_length / aCell.major_axis_length
if min_row - 30 <= 0 or min_col - 30 <= 0 or max_row + 30 >= max_proj.shape[
0] or max_col + 30 >= max_proj.shape[1]:
num_1 = num_1 + 1
rect_r = mpatches.Rectangle((min_col, min_row),
max_col - min_col,
max_row - min_row,
fill=False,
edgecolor='#989898',
linewidth=3)
ax.add_patch(rect_r)
elif aspect_ratio < ar_thres:
num_2 = num_2 + 1
rect_r = mpatches.Rectangle((min_col, min_row),
max_col - min_col,
max_row - min_row,
fill=False,
edgecolor='#989898',
linewidth=3)
ax.add_patch(rect_r)
else:
if aCell.area > max_size:
num_3 = num_3 + 1
rect_r = mpatches.Rectangle((min_col, min_row),
max_col - min_col,
max_row - min_row,
fill=False,
edgecolor='#989898',
linewidth=3)
ax.add_patch(rect_r)
else:
num_4 = num_4 + 1
cell_boundaries = [
min_row - 30, min_col - 30, max_row + 30, max_col + 30
]
bounding_box.append(cell_boundaries)
rect = mpatches.Rectangle((min_col, min_row),
max_col - min_col,
max_row - min_row,
fill=False,
edgecolor='green',
linewidth=3)
ax.add_patch(rect)
ax.text(max_col - 5,
min_row + 5,
'Cell num ' + str(num_4),
horizontalalignment='right',
verticalalignment='top',
fontsize=12,
family='sans-serif',
color='green')
ax.set_axis_off()
plt.show()
print('Summary: ')
print(str(len(measure.regionprops(label_mask))) + ' cells are identified.')
if num_1 > 0:
print(str(num_1) + ' cells are too close to the boundary.')
if num_2 > 0:
print(str(num_2) + ' cells are too elongated.')
if num_3 > 0:
print(str(num_3) + ' segmented cells are too big.')
print(str(num_4) + ' cells will be analyzed.')
return (len(bounding_box), label_mask, bounding_box)
┃ ┻ ┃
┗━┓ ┏━┛
┃ ┗II━II┓
┃ 神兽保佑 ┣┓
┃ 永无BUG！ ┏┛
┗┓┓┏━┳┓┏┛
┃┫┫ ┃┫┫
┗┻┛ ┗┻┛
@Belong = 'F**k' @MadeBy = 'PyCharm'
@Author = 'steven' @DateTime = '2019/2/23 14:56'
'''
import os
from natsort import natsorted
from glob import glob
from skimage import io as skio
import numpy as np
from skimage.morphology import label
from skimage.measure import regionprops
from skimage.color import label2rgb
suvp=r'E:\pyWorkspace\CAE\res\cp250\0\suv'
imgps=natsorted(glob(os.path.join(suvp,'*.tif')))
suvs=np.stack([skio.imread(_p) for _p in imgps])
op=r'E:\pyWorkspace\CAE\try0\tryThres2.5'
thresholdV=2.5
ts=label2rgb(label(suvs>thresholdV))
from skimage import color
for i in range(ts.shape[0]):
skio.imsave(os.path.join(op,str(i)+'.bmp'),np.round(ts[i,:,:,:]*255).astype(np.uint8))
from skimage.measure import regionprops
from skimage.color import label2rgb
image = data.coins()[50:-50, 50:-50]
# apply threshold
thresh = threshold_otsu(image)
bw = closing(image > thresh, square(3))
# remove artifacts connected to image border
cleared = bw.copy()
clear_border(cleared)
# label image regions
label_image = label(cleared)
borders = np.logical_xor(bw, cleared)
label_image[borders] = -1
image_label_overlay = label2rgb(label_image, image=image)
fig, ax = plt.subplots(ncols=1, nrows=1, figsize=(6, 6))
ax.imshow(image_label_overlay)
for region in regionprops(label_image):
# skip small images
if region.area < 100:
continue
# draw rectangle around segmented coins
minr, minc, maxr, maxc = region.bbox
def __init__(self, nucs_lbls, spts_ctrs, spts):
zlen, xlen, ylen = nucs_lbls.shape
nucs_er = np.zeros(nucs_lbls.shape, dtype=int)
for z in range(zlen):
nucs_er[z, :, :] = label(binary_erosion(nucs_lbls[z, :, :],
iterations=6),
connectivity=1)
nucs_er[z, :, :] = remove_small_objects(nucs_er[z, :, :], 120)
j_max = np.argmax(np.sign(nucs_er).sum(2).sum(1))
nucs_prj = np.copy(nucs_er[j_max, :, :])
new_idx = 1000
for z in range(1, zlen):
idxs = np.unique(nucs_er[z, :, :])[1:]
for k in idxs:
smpl = ((nucs_er[z, :, :] == k) * nucs_prj).reshape(
(xlen * ylen))
if smpl.sum() == 0:
nucs_prj += new_idx * (nucs_er[z, :, :] == k)
new_idx += 1
else:
smpl = np.delete(smpl, np.where(smpl == 0)[0])
smpl = np.median(smpl).astype(int)
nucs_prj += smpl * (nucs_er[z, :, :]
== k) * (1 - np.sign(nucs_prj))
nucs_prj = np.copy(nucs_er[j_max, :, :])
nucs_prj = label(nucs_prj)
cpu_owe = multiprocessing.cpu_count()
nucs_dil = np.copy(nucs_prj)
while (nucs_dil == 0).sum() > 0:
print((nucs_dil == 0).sum())
idxs = np.unique(nucs_dil)[1:]
tags = np.split(idxs, (int(idxs.size / cpu_owe + 1)) *
np.arange(1, cpu_owe, dtype=np.int))
args = []
for jj in range(len(tags)):
args.append([tags[jj], nucs_dil])
pool = multiprocessing.Pool()
results = pool.map(DilationFunction.DilationFunction, args)
pool.close()
for j in range(len(results)):
nucs_dil += results[j].msk * (1 - np.sign(nucs_dil))
nucs_dil = label(nucs_dil)
ref_spts = np.zeros(spts_ctrs.shape[1])
for k in range(spts_ctrs.shape[1]):
ref_spts[k] = nucs_dil[spts_ctrs[1, k], spts_ctrs[0, k]]
fls_clrd = np.zeros(np.append(nucs_prj.shape, 3))
for j in range(ref_spts.size):
fls_clrd[:, :, 0] += (nucs_prj == ref_spts[j]) * 1
fls_clrd[:, :, 2] = np.sign(nucs_prj) * (
1 - np.sign(fls_clrd[:, :, 0])) * fls_clrd[:, :, 0].max()
fls_clrd[:, :, 1] = spts.sum(0) * fls_clrd[:, :, 0].max()
nucs_dil = RemoveBorderNuclei.RemoveBorderNuclei(nucs_dil).nucs_dil
self.nucs_lbls = nucs_lbls
self.nucs_dil = nucs_dil
self.fls_clrd = fls_clrd
patch = image[400:500, 217:317].copy()
image = image[324:824, 87:387]
#image = gaussian_gradient_magnitude(image, sigma=2)
#patch = gaussian_gradient_magnitude(patch, sigma=2)
print('image shape', image.shape)
print('patch shape', patch.shape)
# result = match_template(image, patch, pad_input=True, mode='constant', constant_values=(0,0),)
result = match_template(image, patch)
thresh = 0.7
res = result > thresh
c = label(res, background=0)
reprop = regionprops(c)
print('number', len(reprop))
print('result shape', result.shape)
print('MIN - MAX', np.min(result), np.max(result))
ij = np.unravel_index(np.argmax(result), result.shape)
print(type(ij))
x, y = ij[::-1]
x += patch.shape[0] / 2
y += patch.shape[1] / 2
print(x, y)
plt.imshow(np.clip(result, 0, 1), cmap='gray')
plt.show()
avH += hs
print("Average DSC: ", avD / length)
print("Average MSD: ", avS / length)
print("Average HS: ", avH / length)
#Driver()
image = io.imread('images/image_0090.png')
I = util.img_as_float(image)
J = util.img_as_bool(io.imread('groundtruth/threshimage_0090.png'))
#print(otsu(I))
A = segleaf(I)
#plt.imshow(A)
#plt.show()
#boundaries = seg.find_boundaries(A, connectivity=2, mode='inner ')
L = morph.label(A, connectivity=2)
boundaries = seg.find_boundaries(L, connectivity=2, mode='inner ')
#L = np.transpose(np.vstack(np.where(seg.find_boundaries(A == True))))
img_w_b = seg.mark_boundaries(image, L, color=(1, 1, 0))
plt.imshow(img_w_b)
plt.show(img_w_b)
#Driver()
#print(DSC(A,J))
#print(MSD(A,J))
#Driver()
#print greyscale histogram
#g_img = color.rgb2gray(I)
#hist = plt.hist(g_img, bins='auto')
#plt.plot(hist)
#plt.show()
def calculate_ROC(self, slice_dirname, tag, chosen, p_thresh=0.5):
'''
计算每张切片的pixel级的ROC
:param slice_dirname: slice的路径，现在不需要了，直接读取Mask的存盘文件
:param tag: input size of Slide Filter
:param chosen: list of slide ID
:param p_thresh: tumor probability threshold
:return:
'''
project_root = self._params.PROJECT_ROOT
save_path = "{}/results".format(project_root)
mask_path = "{}/data/true_masks".format(self._params.PROJECT_ROOT)
result_auc = []
if tag == 0:
code = "_history.npz"
else:
code = "_history_v{}.npz".format(tag)
K = len(code)
print(
"slice_id, area, count, p_thresh, dice, accu, recall, f1, roc_auc")
for result_file in os.listdir(save_path):
ext_name = os.path.splitext(result_file)[1]
slice_id = result_file[:-K]
if chosen is not None and slice_id not in chosen:
continue
if ext_name == ".npz" and code in result_file:
print("loading data : {}, {}".format(slice_id, result_file))
result = np.load("{}/{}".format(save_path, result_file),
allow_pickle=True)
x1 = result["x1"]
y1 = result["y1"]
x2 = result["x2"]
y2 = result["y2"]
coordinate_scale = result["scale"]
assert coordinate_scale == 1.25, "Scale is Error!"
history = result["history"].item()
cmb = CancerMapBuilder(self._params,
extract_scale=40,
patch_size=256)
cancer_map = cmb.generating_probability_map(
history, x1, y1, x2, y2, 1.25)
h, w = cancer_map.shape
mask_filename = "{}/{}_true_mask.npz".format(
mask_path, slice_id)
if os.path.exists(mask_filename):
result = np.load(mask_filename, allow_pickle=True)
mask_img = result["mask"]
mask_img = mask_img[y1:y1 + h, x1:x1 + w]
area = np.sum(mask_img)
_, count = morphology.label(mask_img,
neighbors=8,
connectivity=2,
return_num=True)
else:
mask_img = np.zeros((h, w), dtype=np.bool)
area = 0
count = 0
false_positive_rate, true_positive_rate, thresholds = metrics.roc_curve(
mask_img.ravel(), cancer_map.ravel())
roc_auc = metrics.auc(false_positive_rate, true_positive_rate)
pred = np.array(cancer_map > p_thresh).astype(np.int)
mask_img = np.array(mask_img).astype(np.int)
dice = Evaluation.calculate_dice_coef(mask_img, pred)
accu = metrics.accuracy_score(mask_img, pred)
recall = metrics.recall_score(mask_img, pred, average='micro')
# print(set(np.unique(mask_img)) - set(np.unique(pred)))
f1 = metrics.f1_score(
mask_img, pred,
average='weighted') # Here, f1 = dice，average='micro'
temp = "{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}".format(
slice_id, area, count, p_thresh, dice, accu, recall, f1,
roc_auc)
result_auc.append(temp)
print(temp)
print("############################################")
for item in result_auc:
print(item)
return
cur_design_variable = np.load( projects_directory_location_base + "/cur_design_variable.npy" ) bayer_filter.w[0] = cur_design_variable bayer_filter.update_filters(num_epochs - 1) bayer_filter.update_permittivity() cur_fabrication_target = ( bayer_filter.get_permittivity() > 0.5 ) pad_cur_fabrication_target = np.pad( cur_fabrication_target, ( ( 1, 1 ), ( 1, 1 ), ( 1, 1 ) ), mode='constant' ) pad_cur_fabrication_target[ :, :, pad_cur_fabrication_target.shape[ 2 ] - 1 ] = 1 [solid_labels, num_solid_labels] = skim.label( pad_cur_fabrication_target, connectivity=1, return_num=True ) [void_labels, num_void_labels] = skim.label( 1 - pad_cur_fabrication_target, connectivity=1, return_num=True ) layer_step = int( cur_fabrication_target.shape[ 2 ] / num_vertical_layers ) new_device = np.zeros( cur_fabrication_target.shape ) for layer_idx in range( 0, num_vertical_layers ): pull_data = void_labels[ 1 : void_labels.shape[ 0 ] - 1, 1 : void_labels.shape[ 1 ] - 1, layer_idx * layer_step + 1 ] for internal_layer in range( 0, layer_step ): new_device[ :, :, layer_idx * layer_step + internal_layer ] = 1.0 * np.greater( cur_fabrication_target[ :, :, layer_idx * layer_step + 1 ], 0.5 ) new_device[ :, :, layer_idx * layer_step + internal_layer ] += 1.0 * np.greater( pull_data, 1 ) new_device[ :, :, new_device.shape[ 2 ] - 1 ] = new_device[ :, :, new_device.shape[ 2 ] - 2 ]
def show_groundtruth(uid, x, y, y_c, y_m, gt, gt_s, gt_c, gt_m, save=False):
threshold = config['param'].getfloat('threshold')
threshold_edge = config['param'].getfloat('threshold_edge')
threshold_mark = config['param'].getfloat('threshold_mark')
segmentation = config['post'].getboolean('segmentation')
remove_objects = config['post'].getboolean('remove_objects')
remove_fiber = config['post'].getboolean('filter_fiber')
min_object_size = config['post'].getint('min_object_size')
only_contour = config['contour'].getboolean('exclusive')
view_color_equalize = config['valid'].getboolean('view_color_equalize')
print_table = config['valid'].getboolean('print_table')
fig, (ax1, ax2, ax3) = plt.subplots(3, 4, sharey=True, figsize=(12, 8))
fig.suptitle(uid, y=1)
y_s = y # to show pure semantic predict later
if view_color_equalize:
x = clahe(x)
ax1[0].set_title('Image')
ax1[0].imshow(x, aspect='auto')
if segmentation :
y, markers = partition_instances(y, y_m, y_c)
if remove_objects:
y = remove_small_objects(y, min_size=min_object_size)
if remove_fiber:
y = filter_fiber(y)
_, count = label(y, return_num=True)
ax1[1].set_title('Final Pred, #={}'.format(count))
ax1[1].imshow(y, cmap='gray', aspect='auto')
# overlay contour to semantic ground truth (another visualized view for instance ground truth, eg. gt)
_, count = label(gt, return_num=True)
ax1[2].set_title('Instance Lbls, #={}'.format(count))
ax1[2].imshow(gt_s, cmap='gray', aspect='auto')
gt_c2, cmap = _make_overlay(gt_c)
ax1[2].imshow(gt_c2, cmap=cmap, alpha=0.7, aspect='auto')
if only_contour: # can not tell from instances in this case
iou = iou_metric(y, label(gt > 0), print_table)
else:
iou = iou_metric(y, gt, print_table)
ax1[3].set_title('Overlay, IoU={:.3f}'.format(iou))
ax1[3].imshow(gt_s, cmap='gray', aspect='auto')
y, cmap = _make_overlay(y)
ax1[3].imshow(y, cmap=cmap, alpha=0.3, aspect='auto')
y_s = y_s > threshold
_, count = label(y_s, return_num=True)
ax2[0].set_title('Semantic Predict, #={}'.format(count))
ax2[0].imshow(y_s, cmap='gray', aspect='auto')
_, count = label(gt_s, return_num=True)
ax2[1].set_title('Semantic Lbls, #={}'.format(count))
ax2[1].imshow(gt_s, cmap='gray', aspect='auto')
if y_c is not None:
y_c = y_c > threshold_edge
_, count = label(y_c, return_num=True)
ax2[2].set_title('Contour Predict, #={}'.format(count))
ax2[2].imshow(y_c, cmap='gray', aspect='auto')
_, count = label(gt_c, return_num=True)
ax2[3].set_title('Contour Lbls, #={}'.format(count))
ax2[3].imshow(gt_c, cmap='gray', aspect='auto')
_, count = label(markers, return_num=True)
ax3[0].set_title('Final Markers, #={}'.format(count))
ax3[0].imshow(markers, cmap='gray', aspect='auto')
if y_m is not None:
y_m = y_m > threshold_mark
_, count = label(y_m, return_num=True)
ax3[1].set_title('Marker Predict, #={}'.format(count))
ax3[1].imshow(y_m, cmap='gray', aspect='auto')
_, count = label(gt_m, return_num=True)
ax3[2].set_title('Marker Lbls, #={}'.format(count))
ax3[2].imshow(gt_m, cmap='gray', aspect='auto')
plt.tight_layout()
if save:
dir = predict_save_folder()
fp = os.path.join(dir, uid + '.png')
plt.savefig(fp)
else:
show_figure()
def extractFile(self, filename):
image = imread(filename, 1)
# apply threshold in order to make the image binary
bw = (image < 120).astype(np.float)
# remove artifacts connected to image border
cleared = bw.copy()
# clear_border(cleared)
# label image regions
label_image = label(cleared, neighbors=8)
borders = np.logical_xor(bw, cleared)
label_image[borders] = -1
letters = list()
order = list()
for region in regionprops(label_image):
minr, minc, maxr, maxc = region.bbox
# skip small images
if maxr - minr > len(
image) / 250: # better to use height rather than area.
rect = mpatches.Rectangle((minc, minr),
maxc - minc,
maxr - minr,
fill=False,
edgecolor='red',
linewidth=2)
order.append(region.bbox)
# sort the detected characters left->right, top->bottom
lines = list()
first_in_line = ''
counter = 0
# worst case scenario there can be 1 character per line
for x in range(len(order)):
lines.append([])
for character in order:
if first_in_line == '':
first_in_line = character
lines[counter].append(character)
elif abs(character[0] - first_in_line[0]) < (first_in_line[2] -
first_in_line[0]):
lines[counter].append(character)
elif abs(character[0] - first_in_line[0]) > (first_in_line[2] -
first_in_line[0]):
first_in_line = character
counter += 1
lines[counter].append(character)
for x in range(len(lines)):
lines[x].sort(key=lambda tup: tup[1])
final = list()
prev_tr = 0
prev_line_br = 0
for i in range(len(lines)):
for j in range(len(lines[i])):
tl_2 = lines[i][j][1]
bl_2 = lines[i][j][0]
if tl_2 > prev_tr and bl_2 > prev_line_br:
tl, tr, bl, br = lines[i][j]
letter_raw = bw[tl:bl, tr:br]
letter_norm = resize(letter_raw, (20, 20))
final.append(letter_norm)
prev_tr = lines[i][j][3]
if j == (len(lines[i]) - 1):
prev_line_br = lines[i][j][2]
prev_tr = 0
tl_2 = 0
# print ('Characters recognized: ' + str(len(final)))
return final
def prob_to_rles(x):
lab_img = label(x > 0.5)
for i in range(1, lab_img.max() + 1):
yield rle_encoding(lab_img == i)
def extractFile(self, filename):
image = imread(filename, 1)
#apply threshold in order to make the image binary
bw = image < 120
# remove artifacts connected to image border
cleared = bw.copy()
#clear_border(cleared)
# label image regions
label_image = label(cleared, neighbors=8)
borders = np.logical_xor(bw, cleared)
label_image[borders] = -1
# fig = plt.figure()
#ax = fig.add_subplot(131)
#ax.imshow(bw, cmap='jet')
image0 = imread(filename)
fig, ax = plt.subplots(ncols=1, nrows=1, figsize=(20, 20))
ax.imshow(image0, cmap='jet')
letters = list()
order = list()
for region in regionprops(label_image):
minr, minc, maxr, maxc = region.bbox
# skip small images
if maxc - minc > len(
image) / 250: # better to use height rather than area.
rect = mpatches.Rectangle((minc, minr),
maxc - minc,
maxr - minr,
fill=False,
edgecolor='red',
linewidth=2)
order.append(region.bbox)
ax.add_patch(rect)
Character_found_dir = '/'.join(
filename.replace('/', '/Character_found/').split('/')[0:-1])
if not os.path.exists(Character_found_dir):
os.makedirs(Character_found_dir)
plt.savefig(filename.replace('/', '/Character_found/'))
#sort the detected characters left->right, top->bottom
lines = list()
first_in_line = ''
counter = 0
#worst case scenario there can be 1 character per line
for x in range(len(order)):
lines.append([])
for character in order:
if first_in_line == '':
first_in_line = character
lines[counter].append(character)
elif abs(character[0] - first_in_line[0]) < (first_in_line[2] -
first_in_line[0]):
lines[counter].append(character)
elif abs(character[0] - first_in_line[0]) > (first_in_line[2] -
first_in_line[0]):
first_in_line = character
counter += 1
lines[counter].append(character)
for x in range(len(lines)):
lines[x].sort(key=lambda tup: tup[1])
final = list()
prev_tr = 0
prev_line_br = 0
for i in range(len(lines)):
for j in range(len(lines[i])):
tl_2 = lines[i][j][1]
bl_2 = lines[i][j][0]
if tl_2 > prev_tr and bl_2 > prev_line_br:
tl, tr, bl, br = lines[i][j]
letter_raw = bw[tl:bl, tr:br]
letter_norm = resize(letter_raw, (20, 20))
final.append(letter_norm)
prev_tr = lines[i][j][3]
if j == (len(lines[i]) - 1):
prev_line_br = lines[i][j][2]
prev_tr = 0
tl_2 = 0
print('Characters recognized: ' + str(len(final)))
return final
def main():
args = parse_arguments()
# --------------------------------- 1. Load Plugin for inference engine ---------------------------------
logger.info("Loading plugin")
plugin = IEPlugin(args.target_device)
config = dict()
if 'CPU' in args.target_device:
if args.path_to_extension:
plugin.add_cpu_extension(args.path_to_extension)
if args.number_threads is not None:
config.update({'CPU_THREADS_NUM': str(args.number_threads)})
else:
raise AttributeError("Device {} do not support of 3D convolution. Please use CPU or HETERO:*CPU*")
if 'GPU' in args.target_device:
if args.path_to_cldnn_config:
config.update({'CONFIG_FILE': args.path_to_cldnn_config})
logger.info("GPU extensions is loaded %s", args.path_to_cldnn_config)
plugin.set_config(config)
logger.info("Device is %s ", plugin.device)
logger.info("Plugin version is %s", plugin.version)
# --------------------- 2. Read IR Generated by ModelOptimizer (.xml and .bin files) ---------------------
xml_filename = os.path.abspath(args.path_to_model)
bin_filename = os.path.abspath(os.path.splitext(xml_filename)[0] + '.bin')
ie_network = IENetwork(xml_filename, bin_filename)
input_info = ie_network.inputs
if not input_info:
raise AttributeError("No inputs info is provided")
if len(input_info) != 1:
raise AttributeError("Only one input layer network is supported")
input_name = next(iter(input_info))
out_name = next(iter(ie_network.outputs))
print(input_name, out_name)
# ---------------------------------------- 4. Preparing input data ----------------------------------------
logger.info("Preparing inputs")
if len(input_info[input_name].shape) != 5:
raise AttributeError("Incorrect shape {} for 3d convolution network".format(args.shape))
n, _, d, h, w = input_info[input_name].shape
ie_network.batch_size = n
# ------------------------------------- 4. Loading model to the plugin -------------------------------------
# logger.info("Reshape of network from {} to {}".format(input_info[input_name].shape, image_crop_pad.shape))
#ie_network.reshape({input_name: image_crop_pad.shape})
#input_info = ie_network.inputs
# logger.info("Loading model to the plugin")
executable_network = plugin.load(network=ie_network)
del ie_network
files = os.listdir(args.path_to_input_data)
files = [f for f in files if (f.startswith('Patient') and os.path.isfile(os.path.join(args.path_to_input_data, f)))]
files.sort()
for f in files:
header = read_nii_header(os.path.join(args.path_to_input_data, f))
image = np.array(header.get_data()).astype(np.float32)
original_shape = image.shape
start_time = datetime.now()
image = median_filter(image, 3)
bbox = lung_bbox(image)
image_crop = image[bbox[0, 0]:bbox[1, 0], bbox[0, 1]:bbox[1, 1], bbox[0, 2]:bbox[1, 2]]
new_shape_pad = (d, h, w)
diff = np.array(new_shape_pad) - np.array(image_crop.shape)
pad_left = diff // 2
pad_right = diff - pad_left
image_crop_pad = np.pad(image_crop, pad_width=tuple([(pad_left[i], pad_right[i]) for i in range(3)]),
mode='reflect')
# dataset statistics
mean = -303.0502877950004
mean2 = 289439.0029958802
std = np.sqrt(mean2 - mean * mean)
image_crop_pad = (image_crop_pad - mean) / std
image_crop_pad = image_crop_pad[None, None]
preprocess_time = datetime.now() - start_time
test_im = {input_name: image_crop_pad}
# ---------------------------------------------- 5. Do inference --------------------------------------------
start_time = datetime.now()
res = executable_network.infer(test_im)
infer_time = datetime.now() - start_time
# ---------------------------- 6. Processing of the received inference results ------------------------------
result = res[out_name]
start_time = datetime.now()
output_crop = result[0, :, pad_left[0]:-pad_right[0] or None, pad_left[1]:-pad_right[1] or None,
pad_left[2]:-pad_right[2] or None]
new_label = np.zeros(shape=(4,) + image.shape)
new_label[:, bbox[0, 0]:bbox[1, 0], bbox[0, 1]:bbox[1, 1], bbox[0, 2]:bbox[1, 2]] = output_crop
scale_factor = np.array(original_shape) / np.array(image.shape)
old_labels = [zoom(new_label[i], scale_factor, order=1, mode='constant', cval=0)[None] for i in range(4)]
old_label = np.concatenate(tuple(old_labels), axis=0)
old_label = ((np.argmax(old_label, axis=0) + 1) *
np.max((old_label > np.array([0.5, 0.5, 0.5, 0.5]).reshape((-1, 1, 1, 1))).astype(np.int32),
axis=0)).astype(np.int32)
eso_connectivity = morphology.label(old_label == 1)
heart_connectivity = morphology.label(old_label == 2)
trachea_connectivity = morphology.label(old_label == 3)
aorta_connectivity = morphology.label(old_label == 4)
eso_connectivity = reject_small_regions(eso_connectivity, ratio=0.2)
heart_connectivity = leave_biggest_region(heart_connectivity)
trachea_connectivity = leave_biggest_region(trachea_connectivity)
aorta_connectivity = leave_biggest_region(aorta_connectivity)
old_label[np.logical_and(old_label == 1, eso_connectivity == 0)] = 0
old_label[np.logical_and(old_label == 2, heart_connectivity == 0)] = 0
old_label[np.logical_and(old_label == 3, trachea_connectivity == 0)] = 0
old_label[np.logical_and(old_label == 4, aorta_connectivity == 0)] = 0
postprocess_time = datetime.now() - start_time
logger.info("Pre-processing time is %s; Inference time is %s; Post-processing time is %s",
preprocess_time, infer_time, postprocess_time)
# --------------------------------------------- 7. Save output -----------------------------------------------
output_header = nii.Nifti1Image(old_label, header.affine)
nii.save(output_header, os.path.join(args.path_to_output, f[:-7]+'.nii'))
def __call__(self, subjects):
subject_names = [subject['name'] for subject in subjects]
subject_stats = LabeledTensor(
dim_names=['subject', 'stat'],
dim_keys=[subject_names, self.stats_to_output])
for subject in subjects:
pred_data = subject[self.prediction_label_map_name].data > 0
target_data = subject[self.target_label_map_name].data > 0
label_params = {
'return_num': True,
'connectivity': self.connectivity
}
pred_components, num_pred_components = label(
pred_data[0].numpy(), **label_params)
target_components, num_target_components = label(
target_data[0].numpy(), **label_params)
N, M = num_target_components, num_pred_components,
pred_components = torch.from_numpy(pred_components)
target_components = torch.from_numpy(target_components)
# Trick to encode the overlap of target components i and predicted components j as (i + j * factor)
# Then torch.unique can be used to count the occurrences of each overlap
# Alternative would be to stack them and call unique on the flattened spatial dimensions,
# however that is extremely slow while for some reason this approach is very fast.
factor = 1000000
overlap_components = target_components + (pred_components * factor)
unique_overlap, overlap_counts = torch.unique(overlap_components,
sorted=True,
return_counts=True)
overlap_histogram = torch.zeros(N + 1, M + 1)
for overlap_component, count in zip(unique_overlap,
overlap_counts):
i = overlap_component % factor
j = overlap_component // factor
overlap_histogram[i, j] = count
target_detected = self.detection_test(overlap_histogram,
**self.detection_test_params)
prediction_detected = self.detection_test(
overlap_histogram.T, **self.detection_test_params)
detection_recall = target_detected.sum() / N
detection_precision = prediction_detected.sum() / M
detection_f1 = 2 * (detection_recall * detection_precision) / (
detection_recall + detection_precision)
TP = overlap_histogram[1:, 1:].sum()
FP = overlap_histogram[0, 1:].sum()
TN = overlap_histogram[0, 0].sum()
FN = overlap_histogram[1:, 0].sum()
stats = {
'target_components': N,
'predicted_components': M,
'target_detections': target_detected.sum(),
'predicted_detections': prediction_detected.sum(),
'detection_recall': detection_recall,
'detection_precision': detection_precision,
'detection_f1': detection_f1,
'target_volume': TP + FN,
'prediction_volume': TP + FP,
'TP': TP,
'FP': FP,
'TN': TN,
'FN': FN,
'dice': 2 * TP / (2 * TP + FP + FN),
'jaccard': TP / (TP + FP + FN),
'precision': TP / (TP + FP),
'recall': TP / (TP + FN),
}
for stat_name in self.stats_to_output:
value = stats[stat_name]
if isinstance(value, torch.Tensor):
value = value.item()
subject_stats[subject['name'], stat_name] = value
summary_stats = subject_stats.compute_summary_stats(
self.summary_stats_to_output)
out_dict = {
'subject_stats': subject_stats.to_dataframe(),
'summary_stats': summary_stats
}
return out_dict
def prob_to_rles(x, cutoff=0.5):
lab_img = label(x > cutoff)
for i in range(1, lab_img.max() + 1):
yield rle_encoding(lab_img == i)
def prob_to_rles(x, cut_off=0.5):
lab_img = label(x > cut_off)
if lab_img.max() < 1:
lab_img[0, 0] = 1 # ensure at least one prediction per image
for i in range(1, lab_img.max() + 1):
yield rle_encoding(lab_img == i)
def segment(self,
img,
well_radius=800,
well_mask_radius=765,
include_intermediate_results=False,
**kwargs):
# Assume image is single plane z-stack and grab first 2D image to process
assert img.ndim == 3
assert img.shape[0] == 1
img = img[0]
logger.debug(
'Running 2x segmentation on image with shape %s, type %s (args: well_radius = %s, well_mask_radius = %s, include_intermediate_results=%s)',
img.shape, img.dtype, well_radius, well_mask_radius,
include_intermediate_results)
# Remove outliers, convert to float
img = ndi.median_filter(img, size=(3, 3))
img = img_as_float(img)
# Apply bandpass and compute gradients
img_bp = ndi.gaussian_filter(img, sigma=6) - ndi.gaussian_filter(
img, sigma=10)
img_gr = ndi.generic_gradient_magnitude(img_bp, ndi.sobel)
# Get and apply well mask translation
img_well = get_circle_mask(well_radius, img_gr.shape)
shifts = feature.register_translation(img_gr, img_well)[0]
img_well = get_circle_mask(well_mask_radius,
img_gr.shape,
translation=shifts)
img_gm = img_gr * img_well
# Apply local threshold and cleanup binary result
img_bm = img_gm > filters.threshold_local(img_gm, 255)
img_bm = ndi.binary_fill_holes(img_bm, structure=morphology.disk(1))
img_bm = morphology.binary_opening(img_bm, selem=morphology.disk(8))
# Run segmentation
img_dt = ndi.distance_transform_edt(img_bm)
img_dt = ndi.gaussian_filter(img_dt, sigma=1)
img_pk = morphology.label(
feature.peak_local_max(img_dt, indices=False, min_distance=8))
img_obj = segmentation.watershed(-img_dt, img_pk,
mask=img_bm).astype(np.uint16)
img_bnd = img_obj * segmentation.find_boundaries(
img_obj, mode='inner', background=0)
# Compile list of object image results (and append intermediates if necessary)
img_seg = [img_obj, img_obj, img_bnd, img_bnd]
if include_intermediate_results:
to_uint16 = lambda im: exposure.rescale_intensity(
im, out_range='uint16').astype(np.uint16)
img_seg += [
to_uint16(img_bp),
segmentation.find_boundaries(img_well,
mode='inner',
background=0).astype(np.uint16),
to_uint16(img_gm),
to_uint16(img_dt),
img_pk.astype(np.uint16)
]
# Stack and add new axis to give to (z, ch, h, w)
img_seg = np.stack(img_seg)[np.newaxis]
assert img_seg.dtype == np.uint16, 'Expecting 16bit result, got type {}'.format(
img_seg.dtype)
assert img_seg.ndim == 4, 'Expecting 4D result, got shape {}'.format(
img_seg.shape)
return img_seg
def multi_rle_encode(img):
labels = label(img[:, :, 0])
return [rle_encode(labels==k) for k in np.unique(labels[labels>0])]
#aplicamos filtros
med = filters.median(image)
# Thresholding using THRESH_TOZERO_OTSU
th6, dst6 = cv2.threshold(med, min, max, cv2.THRESH_OTSU)
contours, hierarchy = cv2.findContours(dst6, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
cv2.drawContours(imag1, contours, -1, (200, 0, 0), 1)
#Clear objects connected to the label image border.
img_bin = clear_border(closing(imag1 > 120, square(20)))
#etiqueta los objetos
labels = label(img_bin)
plt.subplot(2, 3, 1)
plt.imshow(image, cmap='gray')
obj_ttl = plt.title('Original Image')
plt.setp(obj_ttl, color='b')
plt.axis("off")
plt.subplot(2, 3, 2)
plt.plot(hist, color='gray')
obj_xl = plt.xlabel('Intensidad Iluminacion')
plt.setp(obj_xl, color='g')
obj_yl = plt.ylabel('Numero Pixeles')
plt.setp(obj_yl, color='g')
obj_ttl = plt.title("Histograma")
plt.setp(obj_ttl, color='b')
ds_new = xr.Dataset({'chla': chlanew, 'flags': flagnew})
xx = np.zeros((1, 64, 64), dtype=bool)
k = 0
while (k < nombre_images):
i = np.random.randint(0, np.shape(ds_new.index.values)[0])
# pour chaque image
x = np.zeros(np.shape(ds_new.chla[i, :, :]),
dtype=bool) # initialisation par une matrice de False
y = np.argwhere(np.isnan(ds_new.chla.values[
i, :, :])) # coords des nan ie des nuages dans l'image
x[y[:, 0], y[:,
1]] = True # on remplace les nan ie les nuages par des "True"
m = morphology.label(
x, connectivity=2
) # Selection des regions (nuage) a contours fermé et les remplir par un chiffre donné
print(i, k)
for j in range(
np.max(m)): # mex pour parcourir toutes les régions (nuages)
# pour chaque region fermé (nuage entier)
c = np.where(m == j) # Selectionne les coords
# condition de selection du nuage sur la proximité p/r aux bords et la taille du nuage
if (((np.shape(c[0])[0]) > surface_min)
and ((np.shape(c[0])[0]) < surface_max) and (np.min(c) > dx)
and (np.max(c) < 63 - dx)):
aa = np.zeros((1, 64, 64), dtype=bool) # initialisation du mask
aa[0, c[0], c[1]] = True # Mise en place du mask
xx = np.append(xx, aa, axis=0) # pourquoi pas "extend"?
k = k + 1
data_mask = xr.DataArray(xx[1:]) # Sauvegarde dans le data array
def bridges(density, restrictions, costs, topological_correction_value):
binary_map = np.greater(density, 0.5)
save_binary_map = binary_map.copy()
pad_density = np.pad(density, ((1, 1), (1, 1)), mode='constant')
pad_binary_map = np.greater(pad_density, 0.5)
density_shape = density.shape
width = density_shape[0]
height = density_shape[1]
pad_costs = np.pad(costs, ((1, 1), (1, 1)), mode='constant')
[solid_labels, num_solid_labels] = skim.label(pad_binary_map,
neighbors=4,
return_num=True)
if num_solid_labels <= 1:
return density
density_graph = nx.MultiDiGraph()
for x_idx in range(0, width):
for y_idx in range(0, height):
center_node_id = (x_idx + 1) * (pad_density.shape[1]) + (y_idx + 1)
for x_offset in range(0, 3):
for y_offset in range(0, 3):
if ((x_offset == 1) and (y_offset == 1)) or (
(np.abs(x_offset - 1) + np.abs(y_offset - 1)) > 1):
continue
next_x_idx = x_idx + x_offset
next_y_idx = y_idx + y_offset
if ((next_x_idx == 0) or (next_y_idx == 0)
or (next_x_idx == (pad_density.shape[0] - 1))
or (next_y_idx == (pad_density.shape[1] - 1))):
continue
next_node_id = next_x_idx * (
pad_density.shape[1]) + next_y_idx
next_density_value = pad_binary_map[next_x_idx, next_y_idx]
cost_value = pad_costs[next_x_idx, next_y_idx]
if next_density_value:
cost_value = 0
density_graph.add_edge(center_node_id,
next_node_id,
weight=cost_value)
label_to_representative_pt = {}
for x_idx in range(0, width):
for y_idx in range(0, height):
density_value = pad_density[1 + x_idx, 1 + y_idx]
component_label = solid_labels[1 + x_idx, 1 + y_idx]
if (component_label in label_to_representative_pt.keys()) or (
not density_value):
continue
label_to_representative_pt[component_label] = [x_idx, y_idx]
mst_graph = nx.Graph()
for label_idx_start in range(0, num_solid_labels):
component_start = 1 + label_idx_start
source_pt = label_to_representative_pt[component_start]
source_node_id = (source_pt[0] + 1) * (pad_density.shape[1]) + (
source_pt[1] + 1)
min_path_all = nx.shortest_path(density_graph,
source=source_node_id,
weight='weight')
for label_idx_end in range(1 + label_idx_start, num_solid_labels):
component_end = 1 + label_idx_end
target_pt = label_to_representative_pt[component_end]
target_node_id = (target_pt[0] + 1) * (pad_density.shape[1]) + (
target_pt[1] + 1)
min_path = min_path_all[target_node_id]
min_path_distance = 0
for path_idx in range(1, (len(min_path) - 1)):
node_id = min_path[path_idx]
source_x = int(node_id / pad_density.shape[1]) - 1
source_y = node_id % pad_density.shape[1] - 1
min_path_distance += pad_costs[source_x, source_y]
mst_graph.add_edge(component_start,
component_end,
weight=min_path_distance)
mst = nx.minimum_spanning_tree(mst_graph)
mst_edges = nx.edges(mst)
for edge in mst.edges():
edge_start, edge_end = edge
source_pt = label_to_representative_pt[edge_start]
target_pt = label_to_representative_pt[edge_end]
source_node_id = (source_pt[0] + 1) * (pad_density.shape[1]) + (
source_pt[1] + 1)
target_node_id = (target_pt[0] + 1) * (pad_density.shape[1]) + (
target_pt[1] + 1)
min_path = nx.shortest_path(density_graph,
source=source_node_id,
target=target_node_id,
weight='weight')
for path_idx in range(1, (len(min_path) - 1)):
node_id = min_path[path_idx]
source_x = int(node_id / pad_density.shape[1]) - 1
source_y = node_id % pad_density.shape[1] - 1
density[source_x, source_y] = topological_correction_value
pad_density[1 + source_x,
1 + source_y] = topological_correction_value
binary_map[source_x, source_y] = True
pad_binary_map[1 + source_x, 1 + source_y] = True
restrictions = np.logical_not(np.logical_xor(binary_map, save_binary_map))
