def process(self, image, seeds=None):
self.objects = None
self.labelImage = None
duplicator = Duplicator()
spots = duplicator.run(image)
IJ.setMinAndMax(spots, 0, 1)
IJ.run(spots, "16-bit", "")
spot3DImage = ImageHandler.wrap(spots)
if seeds != None:
seed3DImage = ImageHandler.wrap(seeds)
else:
seed3DImage = self.__computeSeeds(spots)
algorithm = Segment3DSpots(spot3DImage, seed3DImage)
algorithm.show = False
algorithm.setSeedsThreshold(self.seedsThreshold)
algorithm.setLocalThreshold(self.localBackground)
algorithm.setWatershed(self.watershed)
algorithm.setVolumeMin(self.volumeMin)
algorithm.setVolumeMax(self.volumeMax)
algorithm.setMethodLocal(Segment3DSpots.LOCAL_CONSTANT)
algorithm.setMethodSeg(Segment3DSpots.SEG_MAX)
algorithm.segmentAll()
self.objects = algorithm.getObjects()
self.labelImage = ImagePlus("OM_" + spots.getTitle(), algorithm.getLabelImage().getImageStack())
return self.labelImage
def find_maxima(cs, rad, thresh):
# type: (CellStack, int, float) -> list
"""
Find maxima in the entire stack with given radius. Exclude peaks below thresh
:param cs: CellStack
:param rad: Maxima search radius
:param thresh: Intensity threshold
:return: List of maxima 3D coordinates
"""
imh = ImageHandler.wrap(cs.duplicate())
radXY = rad
radZ = rad * cs.scaleZ
# in MaximaFinder thresh is the noise tolerance value
mf = MaximaFinder(imh, radXY, radZ, thresh)
peaks_array = mf.getListPeaks()
peaks = []
# check toArray() call functioning
for p in peaks_array.toArray():
if p.getValue() >= thresh:
point = p.getPosition()
peaks.append([l for l in point.getArray()])
peaks_list = list(map(lambda x: [int(i) for i in x], peaks))
peaks_list.append(cs.center)
return peaks_list
def neighborhood_mean(cs, r1, r0=0):
# type: (CellStack, int, int) -> float
"""
Returns the mean of the values inside a sphere (or sphere cap if r0 != 0 provided) around the center
Reference at: https://github.com/mcib3d/mcib3d-core/blob/master/src/main/java/mcib3d/image3d/ImageHandler.java
:param r1: external radius
:param r0: internal radius (if sphere cap it must be gt 0)
"""
imh = ImageHandler.wrap(cs)
if r0 == 0:
neigh = imh.getNeighborhoodSphere(cs.center[0], cs.center[1],
cs.center[2], r1, r1, r1 * cs.scaleZ)
mean = neigh.getMean()
else:
neigh = imh.getNeighborhoodLayer(cs.center[0], cs.center[1],
cs.center[2], r0, r1)
mean = neigh.getMean()
return mean
def __computeSeeds(self, spots):
seeds = FastFilters3D.filterIntImageStack(
spots.getImageStack(), FastFilters3D.MAXLOCAL, self.seedRadius, self.seedRadius, self.seedRadius, 0, False
)
return ImageHandler.wrap(seeds)
def mean_shift(cs, radius, peaks, sigma, thresh):
# type: (CellStack, int, list, float, float) -> list
"""
Perform mean shift algorithm starting from the peaks to determine the centroid of the cell
This implementation is slightly different from the naive algorithm since mean shift values are also weighted by
voxel intensity (mass of the points).
The kernel used is Gaussian Kernel.
:param cs: CellStack containing voxels
:param radius: Look-distance for mean shift seeds neighbors selection
:param peaks: Seeds of the algorithm
:param sigma: Gaussian kernel parameter
:param thresh: Voxel which intensity is below thresh are not considered
:return: Shifted seeds
"""
imh = ImageHandler.wrap(cs)
# copy peaks list
X = list(peaks)
past_X = []
n_iterations = 15
for it in range(n_iterations):
for i, x in enumerate(X):
point_x = Point3D(x[0], x[1], x[2])
# for each point x in X, find the neighboring points N(x) of x.
neighbors = imh.getNeighborhoodLayerList(x[0], x[1], x[2], 0,
radius)
# for each point x in X, calculate the mean shift m(x).
numerator = [0] * 3
denominator = 0
neigh_arr = neighbors.toArray()
for neighbor in neigh_arr:
# discard neighbors below certain thresh
if neighbor.getValue() >= thresh:
# neighbor is a Voxel3D Object, getPosition is a Point3D. For reference,
# see https://github.com/mcib3d/mcib3d-core/blob/master/src/main/java/mcib3d/geom/Voxel3D.java
neigh_pos = [p for p in neighbor.getPosition().getArray()]
distance = point_x.distance(neighbor, 1, cs.scaleZ)
weight = gaussian_kernel(distance, sigma)
inc = list(
map(lambda n: n * (weight * neighbor.getValue()),
neigh_pos))
numerator = list(map(lambda a, b: a + b, numerator, inc))
denominator += weight * neighbor.getValue()
# print("Denominator: " + str(denominator))
new_x = list(map(lambda n: int(n / denominator), numerator))
# for each point x in X, update x = m(x).
X[i] = new_x
past_X.append(list(X))
return X