def _minima_seeds(pmap, start_id):
minima = mahotas.regmin(pmap)
seeds, num_seeds = mahotas.label(minima)
seeds += start_id
#seeds[seeds==start_id] = 0 # TODO I don't get this
return seeds, num_seeds
def get_seeds(boundary, method='grid', next_id=1):
if method == 'grid':
height = boundary.shape[0]
width = boundary.shape[1]
seed_positions = np.ogrid[0:height:seed_distance,
0:width:seed_distance]
num_seeds_y = seed_positions[0].size
num_seeds_x = seed_positions[1].size
num_seeds = num_seeds_x * num_seeds_y
seeds = np.zeros_like(boundary).astype(np.int32)
seeds[seed_positions] = np.arange(next_id,
next_id + num_seeds).reshape(
(num_seeds_y, num_seeds_x))
if method == 'minima':
minima = mahotas.regmin(boundary)
seeds, num_seeds = mahotas.label(minima)
seeds += next_id
seeds[seeds == next_id] = 0
if method == 'maxima_distance':
distance = mahotas.distance(boundary < 0.5)
maxima = mahotas.regmax(distance)
seeds, num_seeds = mahotas.label(maxima)
seeds += next_id
seeds[seeds == next_id] = 0
return seeds, num_seeds
def watershed(probs, radius):
if probs.ndim == 3:
shed = np.zeros(probs.shape)
for n in xrange(probs.shape[0]):
sel = disk(radius)
minima = mh.regmin(probs[n], Bc=sel)
markers, nr_markers = mh.label(minima)
shed[n] = mh.cwatershed(probs[n], markers)
else:
sel = disk(radius)
minima = mh.regmin(probs, Bc=sel)
markers, nr_markers = mh.label(minima)
shed = mh.cwatershed(probs, markers)
return shed
def test_float_input():
"[watershed]: Compare floating point input with integer input"
f = np.random.random((128, 64))
f = mh.gaussian_filter(f, 8.)
f = mh.gaussian_filter(f, 8.)
markers, _ = mh.label(mh.regmin(f))
f = np.round(f * 2**30)
wf = mh.cwatershed(f / 2**30., markers)
w32 = mh.cwatershed(f.astype(np.int32), markers)
assert (wf == w32).mean() > .999
def test_float_input():
"[watershed]: Compare floating point input with integer input"
f = np.random.random((128,64))
f = mh.gaussian_filter(f, 8.)
f = mh.gaussian_filter(f, 8.)
markers,_ = mh.label(mh.regmin(f))
f = np.round(f * 2**30)
wf = mh.cwatershed(f / 2**30., markers)
w32 = mh.cwatershed(f.astype(np.int32), markers)
assert (wf == w32).mean() > .999
def _segment(cell):
# takes a numpy array of a microscopy
# segments it based on filtering the image then applying a distance transform and
# a watershed method to get the proper segmentation
import mahotas as mh
filt_cell = mh.gaussian_filter(cell, 2)
T = mh.thresholding.otsu((np.rint(filt_cell).astype('uint8')))
dist = mh.stretch(mh.distance(filt_cell > T))
Bc = np.ones((3, 3))
rmax = mh.regmin((dist))
rmax = np.invert(rmax)
labels, num_cells = mh.label(rmax, Bc)
surface = (dist.max() - dist)
areas = mh.cwatershed(dist, labels)
areas *= T
return areas
def _segment(cell):
# takes a numpy array of a microscopy
# segments it based on filtering the image then applying a distance transform and
# a watershed method to get the proper segmentation
import mahotas as mh
filt_cell = mh.gaussian_filter(cell, 2)
T = mh.thresholding.otsu((np.rint(filt_cell).astype('uint8')))
dist = mh.stretch(mh.distance(filt_cell > T))
Bc = np.ones((3,3))
rmax = mh.regmin((dist))
rmax = np.invert(rmax)
labels, num_cells = mh.label(rmax, Bc)
surface = (dist.max() - dist)
areas = mh.cwatershed(dist, labels)
areas *= T
return areas
def watershedSegment(image, diskSize=20):
gradmag = gradientMagnitudue(image)
## compute foreground markers
# open image to create flat regions at cell centers
se_disk = pymorph.sedisk(diskSize)
image_opened = mahotas.open(image, se_disk);
# define foreground markers as regional maxes of cells
# this step is slow!
foreground_markers = mahotas.regmax(image_opened)
## compute background markers
# Threshold the image, cast it to the right datatype, and then calculate the distance image
image_black_white = image_opened > mahotas.otsu(image_opened)
image_black_white = image_black_white.astype('uint16')
# note the inversion here- a key difference from the matlab algorithm
# matlab distance is to nearest non-zero pixel
# python distance is to nearest 0 pixel
image_distance = pymorph.to_uint16(nd.distance_transform_edt(np.logical_not(image_black_white)))
eight_conn = pymorph.sebox()
distance_markers = mahotas.label(mahotas.regmin(image_distance, eight_conn))[0]
image_dist_wshed, image_dist_wshed_lines =mahotas.cwatershed(image_distance, distance_markers, eight_conn, return_lines=True)
background_markers = image_distance_watershed_lines - image_black_white
all_markers = np.logical_or(foreground_markers, background_markers)
# impose a min on the gradient image. assumes int64
gradmag2 = imimposemin(gradmag.astype(int), all_markers, eight_conn)
# call watershed
segmented_cells, segmented_cell_lines = mahotas.cwatershed(gradmag2, mahotas.label(all_markers)[0], eight_conn, return_lines=True)
# seperate watershed regions
segmented_cells[gradientMagnitudue(segmented_cells) > 0] = 0
return segmented_cells > 0, segmented_cells
def get_seeds(boundary,
method='grid',
next_id=1,
seed_distance=10,
boundary_thres=0.5,
label_nb=None):
if method == 'grid':
height = boundary.shape[0]
width = boundary.shape[1]
seed_positions = np.ogrid[0:height:seed_distance,
0:width:seed_distance]
num_seeds_y = seed_positions[0].size
num_seeds_x = seed_positions[1].size
num_seeds = num_seeds_x * num_seeds_y
seeds = np.zeros_like(boundary).astype(np.int32)
seeds[seed_positions] = np.arange(next_id,
next_id + num_seeds).reshape(
(num_seeds_y, num_seeds_x))
if method in ['minima', 'maxima_distance']:
if method == 'minima':
peak = mahotas.regmin(boundary)
elif method == 'maxima_distance':
# distance = mahotas.distance(boundary < boundary_thres)
distance = ndimage.morphology.distance_transform_cdt(
boundary < boundary_thres)
peak = mahotas.regmax(distance)
if label_nb is None:
seeds, num_seeds = mahotas.label(peak)
else:
seeds, num_seeds = mahotas.label(peak, label_nb)
seeds[seeds > 0] += next_id
return seeds, num_seeds
ws = mahotas.cwatershed(blur_prob, seeds)
with timer.Timer("gradient2"):
dx, dy = np.gradient(ws)
ws_boundary = np.logical_or(dx != 0, dy != 0)
## Identify possible extra-cellular space - distance method
#extra_cellular = np.logical_and(mahotas.distance(labels==0) > 100, seeds == np.min(seeds))
#extra_cellular = mahotas.morph.close(extra_cellular.astype(np.bool), disc)
#extra_cellular = mahotas.morph.open(extra_cellular.astype(np.bool), disc)
#extra_cellular_indices = np.nonzero(extra_cellular)
## Identify possible extra-cellular space - minima method
with timer.Timer("extra_cellular"):
with timer.Timer(" (sub)min"):
rmin = mahotas.regmin(blur_prob, min_disc)
extra_cellular = np.logical_and(rmin,
seeds == np.min(seeds))
extra_cellular_indices = np.nonzero(extra_cellular)
extra_cellular_id = np.max(seeds) + 1
seeds[extra_cellular_indices] = extra_cellular_id
with timer.Timer("second watershed"):
ws = mahotas.cwatershed(blur_prob, seeds)
dx, dy = np.gradient(ws)
ws_boundary = np.logical_or(dx != 0, dy != 0)
## Optional - mark the extra-cellular space as boundary
#ws_boundary[np.nonzero(ws == extra_cellular_id)] = 1
ws = mahotas.cwatershed(blur_prob, seeds)
with timer.Timer("gradient2"):
dx, dy = np.gradient(ws)
ws_boundary = np.logical_or(dx!=0, dy!=0)
## Identify possible extra-cellular space - distance method
#extra_cellular = np.logical_and(mahotas.distance(labels==0) > 100, seeds == np.min(seeds))
#extra_cellular = mahotas.morph.close(extra_cellular.astype(np.bool), disc)
#extra_cellular = mahotas.morph.open(extra_cellular.astype(np.bool), disc)
#extra_cellular_indices = np.nonzero(extra_cellular)
## Identify possible extra-cellular space - minima method
with timer.Timer("extra_cellular"):
with timer.Timer(" (sub)min"):
rmin = mahotas.regmin(blur_prob, min_disc)
extra_cellular = np.logical_and(rmin, seeds == np.min(seeds))
extra_cellular_indices = np.nonzero(extra_cellular)
extra_cellular_id = np.max(seeds)+1
seeds[extra_cellular_indices] = extra_cellular_id
with timer.Timer("second watershed"):
ws = mahotas.cwatershed(blur_prob, seeds)
dx, dy = np.gradient(ws)
ws_boundary = np.logical_or(dx!=0, dy!=0)
## Optional - mark the extra-cellular space as boundary
#ws_boundary[np.nonzero(ws == extra_cellular_id)] = 1
def main(infile):
img = mahotas.imread(infile)
infile = os.path.splitext(
os.path.basename(infile))[0]
blue_component = img[:,:,B]
pylab.gray()
k = 3
f = ndimage.gaussian_filter(blue_component, 12)
if DEBUG:
print 'Procesando imagen %s usando canal azul' % (infile)
mahotas.imsave('00%s-input.jpg' % infile, f)
clustered = segment_kmeans(f, k)
clustered[clustered == k-1] = 0
mask = ndimage.binary_fill_holes(clustered)
if DEBUG:
print 'Segmentacion inicial k-means con k=%d' % k
mahotas.imsave('01kmeans1%s.jpg' % infile, mask)
masked = f * mask
if DEBUG:
mahotas.imsave('02masked%s.jpg' % infile, masked)
k = 4
clustered2 = segment_kmeans(masked, k)
if DEBUG:
print 'Resegmentacion k-means con k=%d' % k
mahotas.imsave('03kmeans2%s.jpg' % infile, clustered2)
clustered2[(clustered2 != k-2)] = 0
clustered2[(clustered2 == k-2)] = 1
if DEBUG:
mahotas.imsave('04kmeans2binary%s.jpg' % infile, clustered2)
clustered2 = ndimage.binary_fill_holes(clustered2)
labeled, _ = mahotas.label(mask)
if DEBUG:
print 'Etiquetando imagen segmentacion inicial k-means'
mahotas.imsave('05kmeans2noholes%s.jpg' % infile, clustered2)
mahotas.imsave('06kmeans2labeled%s.jpg' % infile, labeled)
while True:
min_max = raw_input('label1 min,max? ')
try:
min_max = min_max.strip().split(',')
min_ = int(min_max[0])
max_ = int(min_max[1])
except:
break
labeled1 = remove_by_size(labeled, min_, max_)
mahotas.imsave('07labeled1f%d,%d%s.jpg' % (min_, max_, infile), labeled1)
labeled, _ = mahotas.label(clustered2)
labeled2 = remove_by_size(labeled, 1600, 23000)
if DEBUG:
print 'Etiquetando imagen re-segmentacion k-means'
mahotas.imsave('08labeled2f%s.jpg' % infile, labeled)
mahotas.imsave('09labeled2f%s.jpg' % infile, labeled2)
combined = labeled1 + labeled2
labeled_to_binary(combined)
if DEBUG:
mahotas.imsave('10combined%s.jpg' % infile, combined)
combined = ndimage.binary_fill_holes(combined)
if DEBUG:
mahotas.imsave('11combined_noholes%s.jpg' % infile, combined)
borders = mahotas.labeled.borders(mahotas.label(combined)[0])
cells = f * combined
cells[cells == 0] = 255
if DEBUG:
mahotas.imsave('12maskedcellsw%s.jpg' % infile, cells)
rmin = mahotas.regmin(cells)
seeds, nr_nuclei = mahotas.label(rmin)
if DEBUG:
mahotas.imsave(
'13gscale-final%s.jpg' % infile,
pymorph.overlay(blue_component, rmin,
borders)
)
img2 = np.copy(img)
img2[borders] = [0,0,0]
img2[rmin] = [5,250,42]
mahotas.imsave('14%s-outputcells.jpg' % (infile), img2)
#watershed
gradient = ndimage.morphology.morphological_gradient(combined, size=(3,3))
gradient = gradient.astype(np.uint8)
if DEBUG:
print 'Watershed'
mahotas.imsave('15%s-gradient.jpg' % infile, gradient)
wshed, lines = mahotas.cwatershed(gradient, seeds, return_lines=True)
pylab.jet()
if DEBUG:
mahotas.imsave('16wshed.jpg', wshed)
ncells = len(np.unique(wshed)) - 1
print '%d cells.' % ncells
borders = mahotas.labeled.borders(wshed)
img[borders] = [0,0,0]
img[rmin] = [5,250,42]
mahotas.imsave('17%s-output-%dcells.jpg' % (infile, ncells), img)
def watershedSegment(image, diskSize=20):
"""This routine implements the watershed example from
http://www.mathworks.com/help/images/examples/marker-controlled-watershed-segmentation.html,
but using pymorph and mahotas.
:param image: an image (2d numpy array) to be segemented
:param diskSize: an integer used as a size for a structuring element used
for morphological preprocessing.
:returns: tuple of binarized and labeled segmention masks
"""
def gradientMagnitudue(image):
sobel_x = nd.sobel(image.astype('double'), 0)
sobel_y = nd.sobel(image.astype('double'), 1)
return np.sqrt((sobel_x * sobel_x) + (sobel_y * sobel_y))
def imimposemin(image, mask, connectivity):
fm = image.copy()
fm[mask] = -9223372036854775800
fm[np.logical_not(mask)] = 9223372036854775800
fp1 = image + 1
g = np.minimum(fp1, fm)
j = infrec(fm, g)
return j
def infrec(f, g, Bc=None):
if Bc is None: Bc = pymorph.secross()
n = f.size
return fast_conditional_dilate(f, g, Bc, n)
def fast_conditional_dilate(f, g, Bc=None, n=1):
if Bc is None:
Bc = pymorph.secross()
f = pymorph.intersec(f, g)
for i in xrange(n):
prev = f
f = pymorph.intersec(mahotas.dilate(f, Bc), g)
if pymorph.isequal(f, prev):
break
return f
gradmag = gradientMagnitudue(image)
## compute foreground markers
# open image to create flat regions at cell centers
se_disk = pymorph.sedisk(diskSize)
image_opened = mahotas.open(image, se_disk)
# define foreground markers as regional maxes of cells
# this step is slow!
foreground_markers = mahotas.regmax(image_opened)
## compute background markers
# Threshold the image, cast it to the right datatype, and then calculate the distance image
image_black_white = image_opened > mahotas.otsu(image_opened)
image_black_white = image_black_white.astype('uint16')
# note the inversion here- a key difference from the matlab algorithm
# matlab distance is to nearest non-zero pixel
# python distance is to nearest 0 pixel
image_distance = pymorph.to_uint16(
nd.distance_transform_edt(np.logical_not(image_black_white)))
eight_conn = pymorph.sebox()
distance_markers = mahotas.label(mahotas.regmin(image_distance,
eight_conn))[0]
image_dist_wshed, image_dist_wshed_lines = mahotas.cwatershed(
image_distance, distance_markers, eight_conn, return_lines=True)
background_markers = image_dist_wshed_lines - image_black_white
all_markers = np.logical_or(foreground_markers, background_markers)
# impose a min on the gradient image. assumes int64
gradmag2 = imimposemin(gradmag.astype(int), all_markers, eight_conn)
# call watershed
segmented_cells, segmented_cell_lines = mahotas.cwatershed(
gradmag2, mahotas.label(all_markers)[0], eight_conn, return_lines=True)
segmented_cells -= 1
# seperate watershed regions
segmented_cells[gradientMagnitudue(segmented_cells) > 0] = 0
return segmented_cells > 0, segmented_cells
def watershedSegment(image, diskSize=20):
def gradientMagnitudue(image):
sobel_x = nd.sobel(image.astype('double'), 0)
sobel_y = nd.sobel(image.astype('double'), 1)
return np.sqrt((sobel_x * sobel_x) + (sobel_y * sobel_y))
def imimposemin(image, mask, connectivity):
fm = image.copy()
fm[mask] = -9223372036854775800
fm[np.logical_not(mask)] = 9223372036854775800
fp1 = image + 1
g = np.minimum(fp1, fm)
j = infrec(fm, g)
return j
def infrec(f, g, Bc=None):
if Bc is None: Bc = pymorph.secross()
n = f.size
return fast_conditional_dilate(f, g, Bc, n);
def fast_conditional_dilate(f, g, Bc=None, n=1):
if Bc is None:
Bc = pymorph.secross()
f = pymorph.intersec(f,g)
for i in xrange(n):
prev = f
f = pymorph.intersec(mahotas.dilate(f, Bc), g)
if pymorph.isequal(f, prev):
break
return f
gradmag = gradientMagnitudue(image)
## compute foreground markers
# open image to create flat regions at cell centers
se_disk = pymorph.sedisk(diskSize)
image_opened = mahotas.open(image, se_disk);
# define foreground markers as regional maxes of cells
# this step is slow!
foreground_markers = mahotas.regmax(image_opened)
## compute background markers
# Threshold the image, cast it to the right datatype, and then calculate the distance image
image_black_white = image_opened > mahotas.otsu(image_opened)
image_black_white = image_black_white.astype('uint16')
# note the inversion here- a key difference from the matlab algorithm
# matlab distance is to nearest non-zero pixel
# python distance is to nearest 0 pixel
image_distance = pymorph.to_uint16(nd.distance_transform_edt(np.logical_not(image_black_white)))
eight_conn = pymorph.sebox()
distance_markers = mahotas.label(mahotas.regmin(image_distance, eight_conn))[0]
image_dist_wshed, image_dist_wshed_lines = mahotas.cwatershed(image_distance, distance_markers, eight_conn, return_lines=True)
background_markers = image_dist_wshed_lines - image_black_white
all_markers = np.logical_or(foreground_markers, background_markers)
# impose a min on the gradient image. assumes int64
gradmag2 = imimposemin(gradmag.astype(int), all_markers, eight_conn)
# call watershed
segmented_cells, segmented_cell_lines = mahotas.cwatershed(gradmag2, mahotas.label(all_markers)[0], eight_conn, return_lines=True)
segmented_cells -= 1
# seperate watershed regions
segmented_cells[gradientMagnitudue(segmented_cells) > 0] = 0
return segmented_cells > 0, segmented_cells
def measure(origimage, cuts, gaussintensity, iteration):
image = cut(origimage, cuts)
adjustsize(origimage, image, cuts)
if not default and iteration in modifyselection:
limitmod = modifyselection[iteration]
else:
limitmod = 0
ignore = findrim(image, limitmod)
if rim and len(ignore) <= (cuts**2) * 0.33:
while len(ignore) <= (cuts**2) * 0.33:
limitmod += 3
ignore = findrim(image, limitmod)
elif len(ignore) >= (cuts**2) * 0.66:
while len(ignore) >= (cuts**2) * 0.66:
limitmod -= 3
ignore = findrim(image, limitmod)
avmod = len(ignore)
threshold = applyth(image)
if not default and iteration in increasegauss:
usedgaussintensity = gaussintensity**increasegauss[iteration]
else:
usedgaussintensity = gaussintensity
gauss = applygauss(image, usedgaussintensity)
totalcellarea = 0.0
subcount = int(math.sqrt(len(image)))
for r in range(len(image)):
printprogress(
(iteration * len(image) + r + 1), (len(inputimages) * len(image)),
prefix="processing " + str(len(inputimages) - len(badimages)) +
" images",
suffix="complete")
if len(ignore) == 0 or r != ignore[0]:
cellarea = 0.0
area = image[r].shape[0] * image[r].shape[1]
gaussth = gauss[r] > threshold[r]
for array in gaussth:
for pixel in array:
# variabel machen wenn Zellen hell
if pixel == 0:
cellarea += 1
cellperc = (cellarea / area)
inputimages[iteration][3] = cellperc * 100
rmin = mh.regmin(gaussth)
rmin = rmin.astype(np.uint8)
plt.subplot(subcount, subcount, r + 1)
plt.axis('off')
plt.imshow(mh.overlay(image[r], rmin))
totalcellarea += cellperc
else:
plt.subplot(subcount, subcount, r + 1)
plt.axis('off')
ignore.pop(0)
plt.text(
-7, 7,
str("ID: " + str(iteration) + ", day: " +
str(inputimages[iteration][1]) + ", " + str(substancename) +
" concentration: " + str(inputimages[iteration][2]) + " %"))
plt.text(
-7, 6.5,
str(cellname) + " coverage: " +
str(round((totalcellarea / ((len(image)) - avmod)) * 100, 2)) + " %")
plt.axis('off')
pp.savefig()
plt.gcf().clear()
def watershed(probs, radius):
sel = disk(radius)
minima = mh.regmin(probs, Bc=sel)
markers, nr_markers = mh.label(minima)
return mh.cwatershed(probs, markers)
