def test_bbox():
img = np.zeros((10, 10), np.uint16)
a0, b0, a1, b1 = bbox(img)
assert a0 == b0
assert a1 == b1
img[4, 2] = 1
a0, b0, a1, b1 = bbox(img)
assert a0 == 4
assert b0 == 5
assert a1 == 2
assert b1 == 3
img[6, 8] = 1
a0, b0, a1, b1 = bbox(img)
assert a0 == 4
assert b0 == 7
assert a1 == 2
assert b1 == 9
img[7, 7] = 1
a0, b0, a1, b1 = bbox(img)
assert a0 == 4
assert b0 == 8
assert a1 == 2
assert b1 == 9
def nozeros_test(f):
result = mh.labeled.bbox(f)
result_as = mh.labeled.bbox(f, as_slice=True)
assert not np.all(result == 0)
for ix in range(4):
assert np.all(result[ix] == mh.bbox(f == ix))
assert np.all(result_as[ix] == mh.bbox(f == ix, as_slice=True))
def nozeros_test(f):
result = mh.labeled.bbox(f)
result_as = mh.labeled.bbox(f, as_slice=True)
assert not np.all(result == 0)
for ix in range(4):
assert np.all(result[ix] == mh.bbox(f == ix))
assert np.all(result_as[ix] == mh.bbox(f == ix, as_slice=True))
def test_bbox():
img = np.zeros((10, 10), np.uint16)
a0, b0, a1, b1 = bbox(img)
assert a0 == b0
assert a1 == b1
img[4, 2] = 1
a0, b0, a1, b1 = bbox(img)
assert a0 == 4
assert b0 == 5
assert a1 == 2
assert b1 == 3
img[6, 8] = 1
a0, b0, a1, b1 = bbox(img)
assert a0 == 4
assert b0 == 7
assert a1 == 2
assert b1 == 9
img[7, 7] = 1
a0, b0, a1, b1 = bbox(img)
assert a0 == 4
assert b0 == 8
assert a1 == 2
assert b1 == 9
def test_labeled_bbox():
f = np.random.random((128, 128))
f = f > .8
f, n = mh.label(f)
result = mh.labeled.bbox(f)
result_as = mh.labeled.bbox(f, as_slice=True)
for _ in range(32):
ix = np.random.randint(n + 1)
assert np.all(result[ix] == mh.bbox(f == ix))
assert np.all(result_as[ix] == mh.bbox(f == ix, as_slice=True))
def test_labeled_bbox():
f = np.random.random((128,128))
f = f > .8
f,n = mh.label(f)
result = mh.labeled.bbox(f)
result_as = mh.labeled.bbox(f, as_slice=True)
for _ in range(32):
ix = np.random.randint(n+1)
assert np.all(result[ix] == mh.bbox(f == ix))
assert np.all(result_as[ix] == mh.bbox(f == ix, as_slice=True))
def test_slice_border():
'Test bbox(slice=True, border=6) in 2D & 3D'
f = np.zeros((32,32), bool)
f[8:8] = 1
m0,M0, m1,M1 = mh.bbox(f, border=6, as_slice=False)
sl = mh.bbox(f, border=6, as_slice=True)
assert np.all(f[sl] == f[m0:M0, m1:M1])
f = np.zeros((32,32, 32), bool)
f[8:8,12:15] = 1
m0,M0, m1,M1, m2, M2 = mh.bbox(f, border=6, as_slice=False)
sl = mh.bbox(f, border=6, as_slice=True)
assert np.all(f[sl] == f[m0:M0, m1:M1, m2:M2])
def test_slice_border():
'Test bbox(slice=True, border=6) in 2D & 3D'
f = np.zeros((32, 32), bool)
f[8:8] = 1
m0, M0, m1, M1 = mh.bbox(f, border=6, as_slice=False)
sl = mh.bbox(f, border=6, as_slice=True)
assert np.all(f[sl] == f[m0:M0, m1:M1])
f = np.zeros((32, 32, 32), bool)
f[8:8, 12:15] = 1
m0, M0, m1, M1, m2, M2 = mh.bbox(f, border=6, as_slice=False)
sl = mh.bbox(f, border=6, as_slice=True)
assert np.all(f[sl] == f[m0:M0, m1:M1, m2:M2])
def __init__(self, length, radius, curvature, pad_width=5, name=None):
a2 = curvature
xl = radius + pad_width
xr = fsolve(calc_length, length, args=(xl, a2, length)).squeeze()
a1 = -a2 * (xr + xl)
r = radius
xm = (xl + xr) / 2
y_mid = a1*xm + a2*xm**2
a0 = 4*radius - y_mid + pad_width
y_max = a0 + a1 * xr + a2 * xr ** 2
shape = tuple(np.ceil([y_max + 10 + r, xr + 2 * r + 10]).astype(int))
coords = Coordinates(None, a0=a0, a1=a1, a2=a2, xl=xl, xr=xr, r=r, shape=shape, initialize=False)
binary = coords.rc < r
min1, max1, min2, max2 = mh.bbox(binary)
min1p, max1p, min2p, max2p = min1 - pad_width, max1 + pad_width, min2 - pad_width, max2 + pad_width
full = np.zeros((np.max([max1p, binary.shape[0]]), np.max([max2p, binary.shape[1]])))
full[0:binary.shape[0], 0:binary.shape[1]] = binary
res = full[min1p:max1p, 0:max2p]
data = Data()
data.add_data(res.astype(int), 'binary')
super(SynthCell, self).__init__(data, name=name)
self.coords.a0 = a0 - min1p
self.coords.a1 = a1
self.coords.a2 = a2
self.coords.xl = xl
self.coords.xr = xr
self.coords.r = r
def test_as_slice():
YXZ = np.indices((32,32,64), float)
YXZ -= 8
Y,X,Z = YXZ
ball = ((X**2+Y**2+Z**2) < 64).astype(np.uint8)
s = bbox(ball, as_slice=True)
assert ball[s].sum() == ball.sum()
def test_as_slice():
YXZ = np.indices((32, 32, 64), float)
YXZ -= 8
Y, X, Z = YXZ
ball = ((X**2 + Y**2 + Z**2) < 64).astype(np.uint8)
s = bbox(ball, as_slice=True)
assert ball[s].sum() == ball.sum()
def split(image, array, label):
'''
'''
large_label = Util.threshold(array, label)
label_bbox = mh.bbox(large_label)
label = large_label[label_bbox[0]:label_bbox[1],
label_bbox[2]:label_bbox[3]]
image = image[label_bbox[0]:label_bbox[1], label_bbox[2]:label_bbox[3]]
#
# smooth the image
#
image = mh.gaussian_filter(image, 3.5)
grad_x = np.gradient(image)[0]
grad_y = np.gradient(image)[1]
grad = np.add(np.abs(grad_x), np.abs(grad_y))
#grad = np.add(np.abs(grad_x), np.abs(grad_y))
grad -= grad.min()
grad /= grad.max()
grad *= 255
grad = grad.astype(np.uint8)
#imshow(grad)
# we need 4 labels as output
max_label = 0
#while max_label!=3:
coords = zip(*np.where(label == 1))
seed1 = random.choice(coords)
seed2 = random.choice(coords)
seeds = np.zeros(label.shape, dtype=np.uint64)
seeds[seed1] = 1
seeds[seed2] = 2
# imshow(seeds)
for i in range(10):
seeds = mh.dilate(seeds)
ws = mh.cwatershed(grad, seeds)
ws[label == 0] = 0
ws_relabeled = skimage.measure.label(ws.astype(np.uint64))
max_label = ws_relabeled.max()
#print max_label
large_label = np.zeros(large_label.shape, dtype=np.uint64)
large_label[label_bbox[0]:label_bbox[1],
label_bbox[2]:label_bbox[3]] = ws
return large_label
def test_bbox_3():
YXZ = np.indices((32,32,64), float)
YXZ -= 8
Y,X,Z = YXZ
ball = ((X**2+Y**2+Z**2) < 64).astype(np.uint8)
m0,M0,m1,M1,m2,M2 = mahotas.bbox(ball)
Y,X,Z = np.where(ball)
assert np.all(m0 <= Y)
assert np.all(m1 <= X)
assert np.all(m2 <= Z)
assert np.all(M0 > Y)
assert np.all(M1 > X)
assert np.all(M2 > Z)
def test_bbox_3():
YXZ = np.indices((32, 32, 64), float)
YXZ -= 8
Y, X, Z = YXZ
ball = ((X**2 + Y**2 + Z**2) < 64).astype(np.uint8)
m0, M0, m1, M1, m2, M2 = mahotas.bbox(ball)
Y, X, Z = np.where(ball)
assert np.all(m0 <= Y)
assert np.all(m1 <= X)
assert np.all(m2 <= Z)
assert np.all(M0 > Y)
assert np.all(M1 > X)
assert np.all(M2 > Z)
def read_dojo_data():
input_image = np.zeros((10, 1024, 1024))
input_rhoana = np.zeros((10, 1024, 1024))
input_gold = np.zeros((10, 1024, 1024))
input_prob = np.zeros((10, 1024, 1024))
input_rhoana = tif.imread(
'/Users/d/Projects/dojo_data_vis2014/labels_after_automatic_segmentation_multi.tif'
)
input_gold = tif.imread(
'/Users/d/Projects/dojo_data_vis2014/groundtruth_multi.tif')
for i in range(10):
input_prob[i] = tif.imread(
'/Users/d/Projects/dojo_data_vis2014/prob/' + str(i) +
'_syn.tif')
input_image[i] = tif.imread(
'/Users/d/Projects/dojo_data_vis2014/images/' + str(i) +
'.tif')
bbox = mh.bbox(input_image[0])
bbox_larger = [bbox[0] - 37, bbox[1] + 37, bbox[2] - 37, bbox[3] + 37]
prob_new = np.zeros(input_image.shape, dtype=np.uint8)
input_image = input_image[:, bbox_larger[0]:bbox_larger[1],
bbox_larger[2]:bbox_larger[3]]
input_rhoana = input_rhoana[:, bbox_larger[0]:bbox_larger[1],
bbox_larger[2]:bbox_larger[3]]
input_gold = input_gold[:, bbox_larger[0]:bbox_larger[1],
bbox_larger[2]:bbox_larger[3]]
# input_prob = input_prob[:, bbox_larger[0]:bbox_larger[1], bbox_larger[2]:bbox_larger[3]]
prob_new[:, bbox[0]:bbox[1],
bbox[2]:bbox[3]] = input_prob[:, bbox[0]:bbox[1],
bbox[2]:bbox[3]]
prob_new = prob_new[:, bbox_larger[0]:bbox_larger[1],
bbox_larger[2]:bbox_larger[3]]
for i in range(0, 10):
zeros_gold = Util.threshold(input_gold[i], 0)
input_gold[i] = Util.normalize_labels(
skimage.measure.label(input_gold[i]).astype(np.uint64))[0]
# restore zeros
input_gold[i][zeros_gold == 1] = 0
input_rhoana[i] = Util.normalize_labels(
skimage.measure.label(input_rhoana[i]).astype(np.uint64))[0]
return input_image.astype(np.uint8), prob_new.astype(
np.uint8), input_gold.astype(np.uint32), input_rhoana.astype(
np.uint32), bbox_larger
def read_dojo_section(num, keep_zeros=False, fill_zeros=False, crop=True):
DATA_PATH = '/Users/d/Projects/dojo_data_vis2014'
if not os.path.isdir(DATA_PATH):
DATA_PATH = '/n/regal/pfister_lab/haehn/dojo_data_vis2014/'
GOLD_PATH = os.path.join(DATA_PATH, 'groundtruth/')
RHOANA_PATH = os.path.join(DATA_PATH,
'labels_after_automatic_segmentation/')
IMAGE_PATH = os.path.join(DATA_PATH, 'images/')
PROB_PATH = os.path.join(DATA_PATH, 'prob/')
gold = tif.imread(GOLD_PATH + str(num) + '.tif')
rhoana = tif.imread(RHOANA_PATH + os.sep + str(num) + ".tif")
image = tif.imread(IMAGE_PATH + str(num) + '.tif')
prob = tif.imread(PROB_PATH + str(num) + '_syn.tif')
gold_original = np.array(gold)
gold = Util.normalize_labels(
skimage.measure.label(gold).astype(np.uint64))[0]
gold[gold == 0] = gold.max() + 1
rhoana = Util.normalize_labels(
skimage.measure.label(rhoana).astype(np.uint64))[0]
# do we want to subtract the zeros?
if keep_zeros:
gold[gold_original == 0] = 0
# rhoana[gold_original == 0] = 0
if fill_zeros:
gold[gold_original == 0] = 0
gold_zeros = Util.threshold(gold, 0)
gold = Util.fill(gold, gold_zeros.astype(np.bool))
if crop:
bbox = mh.bbox(image)
bbox_larger = [
bbox[0] - 37, bbox[1] + 37, bbox[2] - 37, bbox[3] + 37
]
prob_new = prob
else:
bbox = bbox_larger = [0, 1024, 0, 1024]
prob_new = np.zeros(image.shape, dtype=np.uint8)
prob_new[bbox[0]:bbox[1], bbox[2]:bbox[3]] = prob[bbox[0]:bbox[1],
bbox[2]:bbox[3]]
return Util.crop_by_bbox(image, bbox_larger), Util.crop_by_bbox(
prob_new, bbox_larger), Util.crop_by_bbox(
gold, bbox_larger), Util.crop_by_bbox(rhoana, bbox_larger)
def merge_label(image,
prob,
segmentation,
label1,
label2,
crop=True,
patch_size=(100, 100)):
'''
'''
copy_segmentation = np.array(segmentation)
border = mh.labeled.border(segmentation, label1, label2)
copy_segmentation[copy_segmentation == label2] = label1
binary = Util.threshold(copy_segmentation, label1)
if crop:
bbox = mh.bbox(Util.threshold(copy_segmentation, label1))
bbox = [
bbox[0] - patch_size[0], bbox[1] + patch_size[0],
bbox[2] - patch_size[1], bbox[3] + patch_size[1]
]
cropped_image = Util.crop_by_bbox(image, bbox)
cropped_binary = Util.crop_by_bbox(binary, bbox)
cropped_prob = Util.crop_by_bbox(prob, bbox)
cropped_segmentation = Util.crop_by_bbox(copy_segmentation, bbox)
return cropped_image, cropped_prob, cropped_segmentation, cropped_binary, bbox, Util.crop_by_bbox(
border, bbox)
else:
return image, prob, copy_segmentation, binary, [
0, segmentation.shape[0], 0, segmentation.shape[1]
]
def get_bbox_for_object(labeled_mask, object_idx=1, padding=0):
"""
get the rectangular border of a specific object in a labeled mask.
:param labeled_mask: a 2D numpy array of type `int` consisting of labeled segmented objects.
:param object_idx: the label of the object to extract from the mask (default 1).
:param padding: the amount of padding to add to each side of the box (default 0).
:return: a tuple (min_x, min_y, max_x, max_y) representing the top left and bottom right corners of the bounding
box.
"""
# extract desired object from mask
obj_msk = (labeled_mask == object_idx).astype(int)
# find bbox
min_y, max_y, min_x, max_x = __mh.bbox(obj_msk)
# add padding
min_y, max_y, min_x, max_x = min_y - padding, max_y + padding, min_x - padding, max_x + padding
# assert that the box boundaries are within the mask's boundaries
rows, cols = labeled_mask.shape
min_y, max_y = __np.max((0, min_y)), __np.min((rows, max_y))
min_x, max_x = __np.max((0, min_x)), __np.min((cols, max_x))
return min_x, min_y, max_x, max_y
def test_bbox():
img = np.zeros((10, 10), np.uint16)
a0, b0, a1, b1 = bbox(img)
assert a0 == b0
assert a1 == b1
img[4, 2] = 1
a0, b0, a1, b1 = bbox(img)
assert a0 == 4
assert b0 == 5
assert a1 == 2
assert b1 == 3
img[6, 8] = 1
a0, b0, a1, b1 = bbox(img)
assert a0 == 4
assert b0 == 7
assert a1 == 2
assert b1 == 9
img[7, 7] = 1
a0, b0, a1, b1 = bbox(img)
assert a0 == 4
assert b0 == 8
assert a1 == 2
assert b1 == 9
c0, d0, c1, d1 = bbox(img, 0)
assert c0 == a0
assert b0 == d0
assert c1 == a1
assert b1 == d1
c0, d0, c1, d1 = bbox(img, 1)
assert c0 != a0
assert b0 != d0
assert c1 != a1
assert b1 != d1
def test_bbox():
img = np.zeros((10,10), np.uint16)
a0,b0,a1,b1 = bbox(img)
assert a0 == b0
assert a1 == b1
img[4,2]=1
a0,b0,a1,b1=bbox(img)
assert a0 == 4
assert b0 == 5
assert a1 == 2
assert b1 == 3
img[6,8]=1
a0,b0,a1,b1=bbox(img)
assert a0 == 4
assert b0 == 7
assert a1 == 2
assert b1 == 9
img[7,7]=1
a0,b0,a1,b1=bbox(img)
assert a0 == 4
assert b0 == 8
assert a1 == 2
assert b1 == 9
c0,d0,c1,d1=bbox(img, 0)
assert c0 == a0
assert b0 == d0
assert c1 == a1
assert b1 == d1
c0,d0,c1,d1=bbox(img, 1)
assert c0 != a0
assert b0 != d0
assert c1 != a1
assert b1 != d1
def fix_single_merge(cnn, cropped_image, cropped_prob, cropped_binary, N=10, invert=True, dilate=True,
border_seeds=True, erode=False, debug=False, before_merge_error=None,
real_border=np.zeros((1,1)), oversampling=False, crop=True):
'''
invert: True/False for invert or gradient image
'''
bbox = mh.bbox(cropped_binary)
orig_cropped_image = np.array(cropped_image)
orig_cropped_prob = np.array(cropped_prob)
orig_cropped_binary = np.array(cropped_binary)
speed_image = None
if invert:
speed_image = Legacy.invert(cropped_image, smooth=True, sigma=2.5)
else:
speed_image = Legacy.gradient(cropped_image)
Util.view(speed_image, large=False, color=False)
dilated_binary = np.array(cropped_binary, dtype=np.bool)
if dilate:
for i in range(20):
dilated_binary = mh.dilate(dilated_binary)
Util.view(dilated_binary, large=False, color=False)
borders = np.zeros(cropped_binary.shape)
best_border_prediction = np.inf
best_border_image = np.zeros(cropped_binary.shape)
original_border = mh.labeled.border(cropped_binary, 1, 0, Bc=mh.disk(3))
results_no_border = []
predictions = []
borders = []
results = []
for n in range(N):
ws = Legacy.random_watershed(dilated_binary, speed_image, border_seeds=border_seeds, erode=erode)
if ws.max() == 0:
continue
ws_label1 = ws.max()
ws_label2 = ws.max()-1
border = mh.labeled.border(ws, ws_label1, ws_label2)
# Util.view(ws, large=True)
# Util.view(border, large=True)
# print i, len(border[border==True])
#
# remove parts of the border which overlap with the original border
#
ws[cropped_binary == 0] = 0
# Util.view(ws, large=False, color=False)
ws_label1_array = Util.threshold(ws, ws_label1)
ws_label2_array = Util.threshold(ws, ws_label2)
eroded_ws1 = np.array(ws_label1_array, dtype=np.bool)
eroded_ws2 = np.array(ws_label2_array, dtype=np.bool)
if erode:
for i in range(5):
eroded_ws1 = mh.erode(eroded_ws1)
# Util.view(eroded_ws, large=True, color=False)
dilated_ws1 = np.array(eroded_ws1)
for i in range(5):
dilated_ws1 = mh.dilate(dilated_ws1)
for i in range(5):
eroded_ws2 = mh.erode(eroded_ws2)
# Util.view(eroded_ws, large=True, color=False)
dilated_ws2 = np.array(eroded_ws2)
for i in range(5):
dilated_ws2 = mh.dilate(dilated_ws2)
new_ws = np.zeros(ws.shape, dtype=np.uint8)
new_ws[dilated_ws1 == 1] = ws_label1
new_ws[dilated_ws2 == 1] = ws_label2
ws = new_ws
# Util.view(new_ws, large=True, color=True)
# ws[original_border == 1] = 0
prediction = Patch.grab_group_test_and_unify(cnn, cropped_image, cropped_prob, ws, ws_label1, ws_label2, oversampling=oversampling)
if prediction == -1 or prediction >= .5:
# invalid
continue
# here we have for one border
# the border
# the prediction
# borders.append(border)
# predictions.append(prediction)
results.append((prediction, border))
return results
def grab_patch(image,
prob,
segmentation,
l,
n,
patch_size=(75, 75),
skip_boundaries=False,
sample_rate=1):
borders = mh.labeled.border(segmentation, l, n)
#
# treat interrupted borders separately
#
borders_labeled = skimage.measure.label(borders)
border_bbox = mh.bbox(borders)
patch_centers = []
border_yx = indices = zip(*np.where(borders == 1))
if len(border_yx) < 2:
return []
# always sample the middle point
border_center = (border_yx[len(border_yx) / (2)][0],
border_yx[len(border_yx) / (2)][1])
patch_centers.append(border_center)
if sample_rate > 1 or sample_rate == -1:
if sample_rate > len(border_yx) or sample_rate == -1:
samples = 1
else:
samples = len(border_yx) / sample_rate
for i, s in enumerate(border_yx):
if i % samples == 0:
sample_point = s
if distance.euclidean(patch_centers[-1],
sample_point) < patch_size[0]:
# sample to close
# print 'sample to close', patch_centers[-1], sample_point
continue
patch_centers.append(sample_point)
borders_w_center = np.array(borders.astype(np.uint8))
for i, c in enumerate(patch_centers):
borders_w_center[c[0], c[1]] = 10 * (i + 1)
# print 'marking', c, borders_w_center.shape
# if debug:
# fig = plt.figure(figsize=(5,5))
# fig.text(0,1,'\n\n\n\n\nAll borders '+str(l)+','+str(n))#+'\n\n'+str(np.round(_matrices[u], 2)))
# plt.imshow(borders_labeled[border_bbox[0]:border_bbox[1], border_bbox[2]:border_bbox[3]], interpolation='nearest')
# fig = plt.figure(figsize=(5,5))
# fig.text(0,1,'\n\n\n\n\nWith center(s) '+str(l)+','+str(n))#+'\n\n'+str(np.round(_matrices[u], 2)))
# plt.imshow(borders_w_center[border_bbox[0]:border_bbox[1], border_bbox[2]:border_bbox[3]], interpolation='nearest')#, cmap='ocean')
patches = []
for i, c in enumerate(patch_centers):
# for border_center in patch_centers:
# check if border_center is too close to the 4 edges
new_border_center = [c[0], c[1]]
if new_border_center[0] < patch_size[0] / 2:
# print 'oob1', new_border_center
# return None
continue
if new_border_center[0] + patch_size[0] / 2 >= segmentation.shape[0]:
# print 'oob2', new_border_center
# return None
continue
if new_border_center[1] < patch_size[1] / 2:
# print 'oob3', new_border_center
# return None
continue
if new_border_center[1] + patch_size[1] / 2 >= segmentation.shape[1]:
# print 'oob4', new_border_center
# return None
continue
# print new_border_center, patch_size[0]/2, border_center[0] < patch_size[0]/2
# continue
bbox = [
new_border_center[0] - patch_size[0] / 2,
new_border_center[0] + patch_size[0] / 2,
new_border_center[1] - patch_size[1] / 2,
new_border_center[1] + patch_size[1] / 2
]
### workaround to not sample white border of probability map
if skip_boundaries:
if bbox[0] <= 33:
continue
if bbox[1] >= segmentation.shape[0] - 33:
continue
if bbox[2] <= 33:
continue
if bbox[3] >= segmentation.shape[1] - 33:
continue
# threshold for label1
array1 = _metrics.Util.threshold(segmentation, l).astype(np.uint8)
# threshold for label2
array2 = _metrics.Util.threshold(segmentation, n).astype(np.uint8)
merged_array = array1 + array2
# dilate for overlap
dilated_array1 = np.array(array1)
dilated_array2 = np.array(array2)
for o in range(10):
dilated_array1 = mh.dilate(dilated_array1.astype(np.uint64))
dilated_array2 = mh.dilate(dilated_array2.astype(np.uint64))
overlap = np.logical_and(dilated_array1, dilated_array2)
overlap[merged_array == 0] = 0
output = {}
output['id'] = str(uuid.uuid4())
output['image'] = image[bbox[0]:bbox[1] + 1, bbox[2]:bbox[3] + 1]
output['prob'] = prob[bbox[0]:bbox[1] + 1, bbox[2]:bbox[3] + 1]
output['l'] = l
output['n'] = n
output['bbox'] = bbox
output['border'] = border_yx
output['border_center'] = new_border_center
output['binary1'] = array1[bbox[0]:bbox[1] + 1,
bbox[2]:bbox[3] + 1].astype(np.bool)
# output['binary2'] = array2[bbox[0]:bbox[1] + 1, bbox[2]:bbox[3] + 1].astype(np.bool)
output['overlap'] = overlap[bbox[0]:bbox[1] + 1,
bbox[2]:bbox[3] + 1].astype(np.bool)
output['borders_labeled'] = borders_labeled[
border_bbox[0]:border_bbox[1], border_bbox[2]:border_bbox[3]]
output['borders_w_center'] = borders_w_center[
border_bbox[0]:border_bbox[1], border_bbox[2]:border_bbox[3]]
patches.append(output)
return patches
def fix_single_merge(cnn,
cropped_image,
cropped_prob,
cropped_binary,
N=10,
invert=True,
dilate=True,
border_seeds=True,
erode=False,
debug=False,
before_merge_error=None,
real_border=np.zeros((1, 1)),
oversampling=False,
crop=True):
'''
invert: True/False for invert or gradient image
'''
bbox = mh.bbox(cropped_binary)
orig_cropped_image = np.array(cropped_image)
orig_cropped_prob = np.array(cropped_prob)
orig_cropped_binary = np.array(cropped_binary)
speed_image = None
if invert:
speed_image = Util.invert(cropped_image, smooth=True, sigma=2.5)
else:
speed_image = Util.gradient(cropped_image)
dilated_binary = np.array(cropped_binary, dtype=np.bool)
if dilate:
for i in range(20):
dilated_binary = mh.dilate(dilated_binary)
# Util.view(dilated_binary, large=True)
borders = np.zeros(cropped_binary.shape)
best_border_prediction = np.inf
best_border_image = np.zeros(cropped_binary.shape)
original_border = mh.labeled.border(cropped_binary,
1,
0,
Bc=mh.disk(3))
results_no_border = []
predictions = []
for n in range(N):
ws = Util.random_watershed(dilated_binary,
speed_image,
border_seeds=border_seeds,
erode=erode)
if ws.max() == 0:
continue
ws_label1 = ws.max()
ws_label2 = ws.max() - 1
border = mh.labeled.border(ws, ws_label1, ws_label2)
# Util.view(ws, large=True)
# Util.view(border, large=True)
# print i, len(border[border==True])
#
# remove parts of the border which overlap with the original border
#
ws[cropped_binary == 0] = 0
# Util.view(ws, large=False, color=False)
ws_label1_array = Util.threshold(ws, ws_label1)
ws_label2_array = Util.threshold(ws, ws_label2)
eroded_ws1 = np.array(ws_label1_array, dtype=np.bool)
eroded_ws2 = np.array(ws_label2_array, dtype=np.bool)
if erode:
for i in range(5):
eroded_ws1 = mh.erode(eroded_ws1)
# Util.view(eroded_ws, large=True, color=False)
dilated_ws1 = np.array(eroded_ws1)
for i in range(5):
dilated_ws1 = mh.dilate(dilated_ws1)
for i in range(5):
eroded_ws2 = mh.erode(eroded_ws2)
# Util.view(eroded_ws, large=True, color=False)
dilated_ws2 = np.array(eroded_ws2)
for i in range(5):
dilated_ws2 = mh.dilate(dilated_ws2)
new_ws = np.zeros(ws.shape, dtype=np.uint8)
new_ws[dilated_ws1 == 1] = ws_label1
new_ws[dilated_ws2 == 1] = ws_label2
ws = new_ws
# Util.view(new_ws, large=True, color=True)
# ws[original_border == 1] = 0
prediction = Patch.grab_group_test_and_unify(
cnn,
cropped_image,
cropped_prob,
ws,
ws_label1,
ws_label2,
oversampling=oversampling)
if prediction == -1:
# invalid
continue
# if (prediction < best_border_prediction):
# best_border_prediction = prediction
# best_border_image = border
# print 'new best', n, prediction
best_border_image = border
borders += (border * prediction)
result = np.array(cropped_binary)
best_border_image[result == 0] = 0
result[best_border_image == 1] = 2
result = skimage.measure.label(result)
result_no_border = np.array(result)
result_no_border[best_border_image == 1] = 0
predictions.append(prediction)
results_no_border.append(result_no_border)
# result = np.array(cropped_binary)
# best_border_image[result==0] = 0
# result[best_border_image==1] = 2
# result = skimage.measure.label(result)
# result_no_border = np.array(result)
# result_no_border[best_border_image==1] = 0
# result_no_border = mh.croptobbox(result_no_border)
# if before_merge_error == None:
# continue
# print result_no_border.shape, before_merge_error.shape
# if before_merge_error.shape[0] != result_no_border.shape[0] or before_merge_error.shape[1] != result_no_border.shape[1]:
# result_no_border = np.resize(result_no_border, before_merge_error.shape)
# print 'vi', Util.vi(before_merge_error.astype(np.uint8), result_no_border.astype(np.uint8))
# if debug:
# Util.view(ws, text=str(i) + ' ' + str(prediction))
result = np.array(cropped_binary)
best_border_image[result == 0] = 0
result[best_border_image == 1] = 2
result = skimage.measure.label(result)
result_no_border = np.array(result)
result_no_border[best_border_image == 1] = 0
return borders, best_border_image, result, result_no_border, results_no_border, predictions
def analyze_border(image,
prob,
segmentation,
l,
n,
patch_size=(75, 75),
sample_rate=10):
borders = mh.labeled.border(segmentation, l, n)
#
# treat interrupted borders separately
#
borders_labeled = skimage.measure.label(borders)
border_bbox = mh.bbox(borders)
patches = []
patch_centers = []
border_yx = indices = zip(*np.where(borders == 1))
if len(border_yx) < 2:
# somehow border detection did not work
return patches
# always sample the middle point
border_center = (border_yx[len(border_yx) / (2)][0],
border_yx[len(border_yx) / (2)][1])
patch_centers.append(border_center)
if sample_rate > 1 or sample_rate == -1:
if sample_rate > len(border_yx) or sample_rate == -1:
samples = 1
else:
samples = len(border_yx) / sample_rate
for i, s in enumerate(border_yx):
if i % samples == 0:
sample_point = s
if distance.euclidean(patch_centers[-1],
sample_point) < patch_size[0]:
# sample to close
# print 'sample to close', patch_centers[-1], sample_point
continue
patch_centers.append(sample_point)
borders_w_center = np.array(borders.astype(np.uint8))
for i, c in enumerate(patch_centers):
borders_w_center[c[0], c[1]] = 10 * (i + 1)
# print 'marking', c, borders_w_center.shape
# if len(patch_centers) > 1:
# print 'PC', patch_centers
for i, c in enumerate(patch_centers):
# print 'pc',c
# for border_center in patch_centers:
# check if border_center is too close to the 4 edges
new_border_center = [c[0], c[1]]
if new_border_center[0] < patch_size[0] / 2:
# print 'oob1', new_border_center
# return None
continue
if new_border_center[0] + patch_size[0] / 2 >= segmentation.shape[
0]:
# print 'oob2', new_border_center
# return None
continue
if new_border_center[1] < patch_size[1] / 2:
# print 'oob3', new_border_center
# return None
continue
if new_border_center[1] + patch_size[1] / 2 >= segmentation.shape[
1]:
# print 'oob4', new_border_center
# return None
continue
# print new_border_center, patch_size[0]/2, border_center[0] < patch_size[0]/2
# continue
bbox = [
new_border_center[0] - patch_size[0] / 2,
new_border_center[0] + patch_size[0] / 2,
new_border_center[1] - patch_size[1] / 2,
new_border_center[1] + patch_size[1] / 2
]
### workaround to not sample white border of probability map
# if skip_boundaries:
if bbox[0] <= 33:
# return None
# print 'ppb'
continue
if bbox[1] >= segmentation.shape[0] - 33:
# return None
# print 'ppb'
continue
if bbox[2] <= 33:
# return None
# print 'ppb'
continue
if bbox[3] >= segmentation.shape[1] - 33:
# return None
# print 'ppb'
continue
# threshold for label1
array1 = Util.threshold(segmentation, l).astype(np.uint8)
# threshold for label2
array2 = Util.threshold(segmentation, n).astype(np.uint8)
merged_array = array1 + array2
# dilate for overlap
dilated_array1 = np.array(array1)
dilated_array2 = np.array(array2)
for o in range(10):
dilated_array1 = mh.dilate(dilated_array1.astype(np.uint64))
dilated_array2 = mh.dilate(dilated_array2.astype(np.uint64))
overlap = np.logical_and(dilated_array1, dilated_array2)
overlap[merged_array == 0] = 0
# overlap_labeled = skimage.measure.label(overlap)
# overlap_value = overlap_labeled[37,37]
# print overlap_value
# overlap_thresholded = np.zeros(overlap.shape)
# overlap_thresholded[overlap_labeled == overlap_value] = 1
# overlap = overlap_thresholded
output = {}
output['id'] = str(uuid.uuid4())
output['image'] = image[bbox[0]:bbox[1] + 1, bbox[2]:bbox[3] + 1]
output['prob'] = prob[bbox[0]:bbox[1] + 1, bbox[2]:bbox[3] + 1]
output['l'] = l
output['n'] = n
output['bbox'] = bbox
output['border'] = border_yx
output['border_center'] = new_border_center
output['binary1'] = array1[bbox[0]:bbox[1] + 1,
bbox[2]:bbox[3] + 1].astype(np.bool)
output['binary2'] = array2[bbox[0]:bbox[1] + 1,
bbox[2]:bbox[3] + 1].astype(np.bool)
output['overlap'] = overlap[bbox[0]:bbox[1] + 1,
bbox[2]:bbox[3] + 1].astype(np.bool)
output['borders_labeled'] = borders_labeled[
border_bbox[0]:border_bbox[1], border_bbox[2]:border_bbox[3]]
output['borders_w_center'] = borders_w_center[
border_bbox[0]:border_bbox[1], border_bbox[2]:border_bbox[3]]
patches.append(output)
return patches
def process_image(im, d, test=False, remove_bordering=False):
plt.figure(1, frameon=False)
sigma = 75
blurred = mh.gaussian_filter(im.astype(float), sigma)
T_mean = blurred.mean()
bin_image = im > T_mean
maxima = mh.regmax(mh.stretch(blurred))
maxima, _ = mh.label(maxima)
dist = mh.distance(bin_image)
dist = 255 - mh.stretch(dist)
watershed = mh.cwatershed(dist, maxima)
_, old_nr_objects = mh.labeled.relabel(watershed)
sizes = mh.labeled.labeled_size(watershed)
min_size = 100000
filtered = mh.labeled.remove_regions_where(
watershed * bin_image, sizes < min_size)
_, nr_objects = mh.labeled.relabel(filtered)
print('Removed', old_nr_objects - nr_objects, 'small regions')
old_nr_objects = nr_objects
if (remove_bordering):
filtered = mh.labeled.remove_bordering(filtered)
labeled, nr_objects = mh.labeled.relabel(filtered)
print('Removed', old_nr_objects - nr_objects, 'bordering cells')
print("Number of cells: {}".format(nr_objects))
fin_weights = mh.labeled_sum(im.astype(np.uint32), labeled)
fin_sizes = mh.labeled.labeled_size(labeled)
fin_result = fin_weights / fin_sizes
if (test):
f, axarr = plt.subplots(2, 2)
for i in range(2):
for j in range(2):
axarr[i][j].axis('off')
axarr[0, 0].imshow(im)
axarr[0, 0].set_title('Source')
axarr[0, 1].imshow(labeled)
axarr[0, 1].set_title('Labeled')
axarr[1, 0].imshow(watershed)
axarr[1, 0].set_title('Watershed')
axarr[1, 1].imshow(blurred)
axarr[1, 1].set_title('Blurred')
for i in range(1, nr_objects + 1):
print("Cell {} average luminescence is {}".format(
i, fin_result[i]))
bbox = mh.bbox((labeled == i))
plt.text((bbox[2] + bbox[3]) / 2, (bbox[0] + bbox[1]
) / 2, str(i), fontsize=20, color='black')
# plt.show()
plt.savefig("test" + str(nr_objects) + ".svg",
format='svg', bbox_inches='tight', dpi=1200)
else:
for i in range(1, nr_objects + 1):
bbox = mh.bbox((labeled == i))
cell = (im * (labeled == i))[bbox[0]:bbox[1], bbox[2]:bbox[3]]
hashed = hashlib.sha1(im).hexdigest()
imsave(d + data_dir + hashed + '-' + str(i) +
'.png', imresize(cell, (img_rows, img_cols)))
def test_bbox_empty():
assert mahotas.bbox(np.zeros((), np.bool)).shape == (0, )
def split_new(image, binary):
'''
'''
bbox = mh.bbox(binary)
sub_image = np.array(image[bbox[0]:bbox[1], bbox[2]:bbox[3]])
sub_binary = np.array(binary[bbox[0]:bbox[1], bbox[2]:bbox[3]])
sub_binary_border = mh.labeled.borders(sub_binary, Bc=mh.disk(3))
sub_binary = mh.erode(sub_binary.astype(np.bool))
for e in range(5):
sub_binary = mh.erode(sub_binary)
# sub_binary = mh.erode(sub_binary)
if sub_image.shape[0] < 2 or sub_image.shape[1] < 2:
return np.zeros(binary.shape, dtype=np.bool), np.zeros(binary.shape, dtype=np.bool)
#
# smooth the image
#
sub_image = mh.gaussian_filter(sub_image, 3.5)
grad_x = np.gradient(sub_image)[0]
grad_y = np.gradient(sub_image)[1]
grad = np.add(np.abs(grad_x), np.abs(grad_y))
grad -= grad.min()
grad /= grad.max()
grad *= 255
grad = grad.astype(np.uint8)
coords = zip(*np.where(sub_binary==1))
if len(coords) < 2:
print 'STRAAAAANGE'
return np.zeros(binary.shape, dtype=np.bool), np.zeros(binary.shape, dtype=np.bool)
seed1 = random.choice(coords)
seed2 = random.choice(coords)
seeds = np.zeros(sub_binary.shape, dtype=np.uint64)
seeds[seed1] = 1
seeds[seed2] = 2
for i in range(10):
seeds = mh.dilate(seeds)
ws = mh.cwatershed(grad, seeds)
ws[sub_binary==0] = 0
# ws_relabeled = skimage.measure.label(ws.astype(np.uint8))
# ws_relabeled[sub_binary==0] = 0
# max_label = ws_relabeled.max()
# plt.figure()
# imshow(ws)
binary_mask = Util.threshold(ws, ws.max())
border = mh.labeled.border(ws, ws.max(), ws.max()-1, Bc=mh.disk(2))
# border[sub_binary_border == 1] = 0 # remove any "real" border pixels
# plt.figure()
# imshow(binary_mask)
# plt.figure()
# imshow(border)
large_label = np.zeros(binary.shape, dtype=np.bool)
large_border = np.zeros(binary.shape, dtype=np.bool)
large_label[bbox[0]:bbox[1], bbox[2]:bbox[3]] = binary_mask
large_border[bbox[0]:bbox[1], bbox[2]:bbox[3]] = border
return large_label, large_border
print len(small_labels)
results = []
for count, l in enumerate(small_labels[0:30]):
labelA, labelB, merged, new_seg, n = create_merge_error(gold_normalized, l)
if labelA == None:
# didnt find a small pair of label neighbors
continue
print 'Introduced error between', l, n
BBOX = mh.bbox(_metrics.Util.threshold(new_seg, l))
patches = create_patches_from_label_id(image, prob, new_seg, l)
print '-' * 80
print 'Working on', l
print 'Generated', len(patches), 'patches'
print 'Testing them now...'
smallest_prediction = np.inf
detected = []
for i, p in enumerate(patches):
split_patches = create_merge_splits(p)
for j, p in enumerate(split_patches):
def test_bbox_empty():
assert mahotas.bbox(np.zeros((), np.bool)).shape == (0,)
def grab_patch(image,
prob,
segmentation,
l,
n,
patch_size=(75, 75),
skip_boundaries=False,
sample_rate=1,
debug=False):
borders = mh.labeled.border(segmentation, l, n)
#
# treat interrupted borders separately
#
borders_labeled = skimage.measure.label(borders)
# print borders_labeled.max()
# for b in range(1,borders_labeled.max()+1):
# borders = _metrics.Util.threshold(borders_labeled, b)
border_bbox = mh.bbox(borders)
patch_centers = []
border_yx = indices = zip(*np.where(borders == 1))
# always sample the middle point
border_center = (border_yx[len(border_yx) / (2)][0],
border_yx[len(border_yx) / (2)][1])
patch_centers.append(border_center)
if sample_rate > 1 or sample_rate == -1:
if sample_rate > len(border_yx) or sample_rate == -1:
samples = 1
else:
samples = len(border_yx) / sample_rate
for i, s in enumerate(border_yx):
if i % samples == 0:
sample_point = s
# print border_center[0]-border_bbox[0], border_center[1]-border_bbox[2]
patch_centers.append(sample_point)
# sample_count = 0
# while sample_rate>sample_count:
# sample_count += 1
# borders_labeled = skimage.measure.label(borders)
# border_centers = []
# for b in range(1,borders_labeled.max()+1):
# border = _metrics.Util.threshold(borders_labeled, b)
# border_yx = indices = zip(*np.where(border==1))
# # border_center = get_border_center(border, border_yx)
# #print border_yx
# border_center = (border_yx[len(border_yx)/2][0], border_yx[len(border_yx)/2][1])
# print border_center[0]-border_bbox[0], border_center[1]-border_bbox[2]
# border_centers.append(border_center)
# # split the borders into two
# for c in border_centers:
# if c[0]-1 > 0:
# borders[c[0]-1, c[1]] = 0
# if c[0]+1 < borders.shape[0]:
# borders[c[0]+1, c[1]] = 0
# borders[c[0], c[1]] = 0
# if c[1]-1 > 0:
# borders[c[0], c[1]-1] = 0
# if c[1]+1 < borders.shape[1]:
# borders[c[0], c[1]+1] = 0
# # recalculate the labeled borders
# borders_labeled = skimage.measure.label(borders)
borders_w_center = np.array(borders.astype(np.uint8))
for i, c in enumerate(patch_centers):
borders_w_center[c[0], c[1]] = 10 * (i + 1)
# print 'marking', c, borders_w_center.shape
if debug:
fig = plt.figure(figsize=(5, 5))
fig.text(0, 1, '\n\n\n\n\nAll borders ' + str(l) + ',' +
str(n)) #+'\n\n'+str(np.round(_matrices[u], 2)))
plt.imshow(borders_labeled[border_bbox[0]:border_bbox[1],
border_bbox[2]:border_bbox[3]],
interpolation='nearest')
fig = plt.figure(figsize=(5, 5))
fig.text(0, 1, '\n\n\n\n\nWith center(s) ' + str(l) + ',' +
str(n)) #+'\n\n'+str(np.round(_matrices[u], 2)))
plt.imshow(borders_w_center[border_bbox[0]:border_bbox[1],
border_bbox[2]:border_bbox[3]],
interpolation='nearest') #, cmap='ocean')
patches = []
# # print 'bmax',borders_labeled.max()
# # check if we need multiple patches because of multiple borders
# for b in range(1,borders_labeled.max()+1):
# # print 'patch for border', b
# border = _metrics.Util.threshold(borders_labeled, b)
# border_yx = indices = zip(*np.where(border==1))
# # fault check if no border is found
# if len(border_yx) == 0:
# print 'no border', l, n, 'border', b
# continue
# #
# # calculate border center properly
# #
# border_center = get_border_center(border, border_yx)
# # # now we have the border center, this will be our first patch
# # patch_centers = []
# # patch_centers.append(border_center)
# # # we also want to have to more patches
# # border[border_center[0]-1, border_center[1]] = 0
# # border[border_center[0]+1, border_center[1]] = 0
# # border[border_center[0], border_center[1]] = 0
# # border[border_center[0], border_center[1]-1] = 0
# # border[border_center[0], border_center[1]+1] = 0
# # borders_labeled2 = skimage.measure.label(border)
# # other_center1 = _metrics.Util.threshold(borders_labeled2, 1)
# # other_border_yx1 = zip(*np.where(other_center1==1))
# # other_center1 = get_border_center(other_center1, other_border_yx1)
# # other_center2 = _metrics.Util.threshold(borders_labeled2, 2)
# # other_border_yx2 = zip(*np.where(other_center2==1))
# # other_center2 = get_border_center(other_center2, other_border_yx2)
# # patch_centers.append(other_center1)
# # patch_centers.append(other_center2)
for i, c in enumerate(patch_centers):
# for border_center in patch_centers:
# check if border_center is too close to the 4 edges
new_border_center = [c[0], c[1]]
if new_border_center[0] < patch_size[0] / 2:
# print 'oob1', new_border_center
# return None
continue
if new_border_center[0] + patch_size[0] / 2 >= segmentation.shape[0]:
# print 'oob2', new_border_center
# return None
continue
if new_border_center[1] < patch_size[1] / 2:
# print 'oob3', new_border_center
# return None
continue
if new_border_center[1] + patch_size[1] / 2 >= segmentation.shape[1]:
# print 'oob4', new_border_center
# return None
continue
# print new_border_center, patch_size[0]/2, border_center[0] < patch_size[0]/2
# continue
bbox = [
new_border_center[0] - patch_size[0] / 2,
new_border_center[0] + patch_size[0] / 2,
new_border_center[1] - patch_size[1] / 2,
new_border_center[1] + patch_size[1] / 2
]
### workaround to not sample white border of probability map
if skip_boundaries:
if bbox[0] <= 33:
# return None
# print 'ppb'
continue
if bbox[1] >= segmentation.shape[0] - 33:
# return None
# print 'ppb'
continue
if bbox[2] <= 33:
# return None
# print 'ppb'
continue
if bbox[3] >= segmentation.shape[1] - 33:
# return None
# print 'ppb'
continue
# threshold for label1
array1 = _metrics.Util.threshold(segmentation, l).astype(np.uint8)
# threshold for label2
array2 = _metrics.Util.threshold(segmentation, n).astype(np.uint8)
merged_array = array1 + array2
# dilate for overlap
dilated_array1 = np.array(array1)
dilated_array2 = np.array(array2)
for o in range(10):
dilated_array1 = mh.dilate(dilated_array1.astype(np.uint64))
dilated_array2 = mh.dilate(dilated_array2.astype(np.uint64))
overlap = np.logical_and(dilated_array1, dilated_array2)
overlap[merged_array == 0] = 0
output = {}
output['id'] = str(uuid.uuid4())
output['image'] = image[bbox[0]:bbox[1] + 1, bbox[2]:bbox[3] + 1]
output['prob'] = prob[bbox[0]:bbox[1] + 1, bbox[2]:bbox[3] + 1]
output['l'] = l
output['n'] = n
output['bbox'] = bbox
output['border'] = border_yx
output['border_center'] = new_border_center
output['binary1'] = array1[bbox[0]:bbox[1] + 1,
bbox[2]:bbox[3] + 1].astype(np.bool)
output['binary2'] = array2[bbox[0]:bbox[1] + 1,
bbox[2]:bbox[3] + 1].astype(np.bool)
output['overlap'] = overlap[bbox[0]:bbox[1] + 1,
bbox[2]:bbox[3] + 1].astype(np.bool)
output['borders_labeled'] = borders_labeled[
border_bbox[0]:border_bbox[1], border_bbox[2]:border_bbox[3]]
output['borders_w_center'] = borders_w_center[
border_bbox[0]:border_bbox[1], border_bbox[2]:border_bbox[3]]
patches.append(output)
return patches
def split_label(image, binary):
bbox = mh.bbox(binary)
sub_image = np.array(image[bbox[0]:bbox[1], bbox[2]:bbox[3]])
sub_binary = np.array(binary[bbox[0]:bbox[1], bbox[2]:bbox[3]])
sub_binary_border = mh.labeled.borders(sub_binary, Bc=mh.disk(3))
sub_binary = mh.erode(sub_binary.astype(np.bool))
for e in range(15):
sub_binary = mh.erode(sub_binary)
# # sub_binary = mh.erode(sub_binary)
if sub_binary.shape[0] < 2 or sub_binary.shape[1] < 2:
return np.zeros(binary.shape,
dtype=np.bool), np.zeros(binary.shape,
dtype=np.bool)
#
# smooth the image
#
sub_image = mh.gaussian_filter(sub_image, 3.5)
grad_x = np.gradient(sub_image)[0]
grad_y = np.gradient(sub_image)[1]
grad = np.add(np.abs(grad_x), np.abs(grad_y))
grad -= grad.min()
grad /= grad.max()
grad *= 255
grad = grad.astype(np.uint8)
coords = zip(*np.where(sub_binary == 1))
if len(coords) < 2:
# print 'STRAAAAANGE'
return np.zeros(binary.shape,
dtype=np.bool), np.zeros(binary.shape,
dtype=np.bool)
seed1 = random.choice(coords)
seed2 = random.choice(coords)
seeds = np.zeros(sub_binary.shape, dtype=np.uint64)
seeds[seed1] = 1
seeds[seed2] = 2
for i in range(10):
seeds = mh.dilate(seeds)
ws = mh.cwatershed(grad, seeds)
ws[sub_binary == 0] = 0
# ws_relabeled = skimage.measure.label(ws.astype(np.uint8))
# ws_relabeled[sub_binary==0] = 0
# max_label = ws_relabeled.max()
# plt.figure()
# imshow(ws)
binary_mask = Util.threshold(ws, ws.max())
border = mh.labeled.border(ws, ws.max(), ws.max() - 1, Bc=mh.disk(2))
border[sub_binary_border == 1] = 0 # remove any "real" border pixels
# plt.figure()
# imshow(binary_mask)
# plt.figure()
# imshow(border)
# at this point, there can be multiple borders and labels
labeled_border = skimage.measure.label(border)
labeled_binary_mask = skimage.measure.label(binary_mask)
# .. and we are going to select only the largest
largest_border_label = Util.get_largest_label(
labeled_border.astype(np.uint16), True)
largest_binary_mask_label = Util.get_largest_label(
labeled_binary_mask.astype(np.uint16), True)
# .. filter out everything else
border[labeled_border != largest_border_label] = 0
binary_mask[labeled_binary_mask != largest_binary_mask_label] = 0
large_label = np.zeros(binary.shape, dtype=np.bool)
large_border = np.zeros(binary.shape, dtype=np.bool)
large_label[bbox[0]:bbox[1], bbox[2]:bbox[3]] = binary_mask
large_border[bbox[0]:bbox[1], bbox[2]:bbox[3]] = border
return large_label, large_border
def attributes(img_path):
r = mh.bbox(mh.imread(img_path))[1]/2
return zernike(img_path,r).tolist() + haralick(img_path).flatten('K').tolist()
def get_merge_error_image(input_image, input_rhoana, label, border):
binary = Util.threshold(input_rhoana, label)
binary_dilated = mh.dilate(binary.astype(np.bool))
for dilate in range(30):
binary_dilated = mh.dilate(binary_dilated)
binary_bbox = mh.bbox(binary_dilated)
binary_border = mh.labeled.borders(binary)
b = np.zeros((input_image.shape[0],input_image.shape[1],4), dtype=np.uint8)
b[:,:,0] = input_image[:]
b[:,:,1] = input_image[:]
b[:,:,2] = input_image[:]
b[:,:,3] = 255
c = np.zeros((input_image.shape[0],input_image.shape[1],4), dtype=np.uint8)
c[:,:,0] = input_image[:]
c[:,:,1] = input_image[:]
c[:,:,2] = input_image[:]
c[:,:,3] = 255
c[binary_border == 1] = (0,255,0,255)
e = np.zeros((input_image.shape[0],input_image.shape[1],4), dtype=np.uint8)
e[:,:,0] = input_image[:]
e[:,:,1] = input_image[:]
e[:,:,2] = input_image[:]
e[:,:,3] = 255
f = np.zeros((input_image.shape[0],input_image.shape[1],4), dtype=np.uint8)
f[:,:,0] = input_image[:]
f[:,:,1] = input_image[:]
f[:,:,2] = input_image[:]
f[:,:,3] = 255
f[binary == 1] = (0,255,0,255)
g = np.zeros((input_image.shape[0],input_image.shape[1],4), dtype=np.uint8)
g[:,:,0] = input_image[:]
g[:,:,1] = input_image[:]
g[:,:,2] = input_image[:]
g[:,:,3] = 255
border[binary==0] = 0
b[border == 1] = (255,0,0,255)
b[binary_border == 1] = (0,255,0,255)
cropped_image = Util.crop_by_bbox(input_image, binary_bbox)
cropped_binary_border = Util.crop_by_bbox(c, binary_bbox)
cropped_combined_border = Util.crop_by_bbox(b, binary_bbox)
cropped_border_only = Util.crop_by_bbox(border, binary_bbox)
corrected_binary = Legacy.correct_merge(input_rhoana, label, border)
corrected_binary_original = np.array(corrected_binary)
result = np.array(input_rhoana)
corrected_binary += result.max()
corrected_binary[corrected_binary_original == 0] = 0
result[corrected_binary != 0] = 0
result += corrected_binary.astype(np.uint64)
cropped_result = Util.crop_by_bbox(corrected_binary, binary_bbox)
g[corrected_binary_original==2] = (255,0,0,255)
g[corrected_binary_original==1] = (0,255,0,255)
cropped_fusion = Util.crop_by_bbox(g, binary_bbox)
e[binary_bbox[0]:binary_bbox[1], binary_bbox[2]] = (255,255,0,255)
e[binary_bbox[0]:binary_bbox[1], binary_bbox[3]] = (255,255,0,255)
e[binary_bbox[0], binary_bbox[2]:binary_bbox[3]] = (255,255,0,255)
e[binary_bbox[1], binary_bbox[2]:binary_bbox[3]] = (255,255,0,255)
sliceoverview = e
cropped_binary = Util.crop_by_bbox(f, binary_bbox)
return cropped_image, cropped_binary_border, cropped_combined_border, cropped_border_only, cropped_result, result, sliceoverview, cropped_binary, cropped_fusion
