def crop_along_one_axis(ops, data, intervals, axis_type):
"""Crop along a single axis using Views.
Parameters
----------
intervals : List with two values specifying the start and the end of the interval.
axis_type : Along which axis to crop. Can be ["X", "Y", "Z", "TIME", "CHANNEL"]
"""
axis = get_axis(axis_type)
interval_start = [
data.min(d) if d != data.dimensionIndex(axis) else intervals[0]
for d in range(0, data.numDimensions())
]
interval_end = [
data.max(d) if d != data.dimensionIndex(axis) else intervals[1]
for d in range(0, data.numDimensions())
]
interval = interval_start + interval_end
interval = Intervals.createMinMax(*interval)
output = ops.run("transform.crop", data, interval, True)
return output
def crop_along_one_axis(ops, data, intervals, axis_type):
"""Crop along a single axis using Views.
Parameters
----------
intervals : List with two values specifying the start and the end of the interval.
axis_type : Along which axis to crop. Can be ["X", "Y", "Z", "TIME", "CHANNEL"]
"""
axis = get_axis(axis_type)
interval_start = [data.min(d) if d != data.dimensionIndex(axis) else intervals[0] for d in range(0, data.numDimensions())]
interval_end = [data.max(d) if d != data.dimensionIndex(axis) else intervals[1] for d in range(0, data.numDimensions())]
interval = interval_start + interval_end
interval = Intervals.createMinMax(*interval)
output = ops.run("transform.crop", data, interval, True)
return output
def crop(ops, data, intervals):
"""Crop along a one or more axis.
Parameters
----------
intervals : Dict specifying which axis to crop and with what intervals.
Example :
intervals = {'X' : [0, 50],
'Y' : [0, 50]}
"""
intervals_start = [data.min(d) for d in range(0, data.numDimensions())]
intervals_end = [data.max(d) for d in range(0, data.numDimensions())]
for axis_type, interval in intervals.items():
index = data.dimensionIndex(get_axis(axis_type))
intervals_start[index] = interval[0]
intervals_end[index] = interval[1]
intervals = Intervals.createMinMax(*intervals_start + intervals_end)
output = ops.run("transform.crop", data, intervals, True)
return output
def crop(ops, data, intervals):
"""Crop along a one or more axis.
Parameters
----------
intervals : Dict specifying which axis to crop and with what intervals.
Example :
intervals = {'X' : [0, 50],
'Y' : [0, 50]}
"""
intervals_start = [data.min(d) for d in range(0, data.numDimensions())]
intervals_end = [data.max(d) for d in range(0, data.numDimensions())]
for axis_type, interval in intervals.items():
index = data.dimensionIndex(get_axis(axis_type))
intervals_start[index] = interval[0]
intervals_end[index] = interval[1]
intervals = Intervals.createMinMax(*intervals_start + intervals_end)
output = ops.run("transform.crop", data, intervals, True)
return output
from net.imglib2.util import Intervals
from net.imagej.axis import Axes
from net.imglib2.type.numeric.real import FloatType
from java.lang.Math import floor
# crop PSF to desired size, this makes decon run faster with little effect on final quality
psfX = psf.dimension(data.dimensionIndex(Axes.X))
psfY = psf.dimension(data.dimensionIndex(Axes.Y))
psfZ = psf.dimension(2)
psf_ = ops.transform().crop(
psf.getImgPlus(),
Intervals.createMinMax(psfX / 2 - psfXSize / 2, psfY / 2 - psfYSize / 2, 0,
psfX / 2 + psfXSize / 2 - 1,
psfY / 2 + psfYSize / 2 - 1, psfZ - 1))
psf_ = ops.convert().float32(psf_)
maxPSF = ops.stats().max(psf_).getRealFloat()
psfBackground = psfBackgroundPercent * maxPSF
# subtract background from psf
for t in psf_:
val = t.getRealFloat() - psfBackground
if val < 0:
val = 0
t.setReal(val)
# normalize psf
# first take a look at the size and type of each dimension
for d in range(data.numDimensions()):
print "axis d: type: " + str(data.axis(d).type()) + " length: " + str(
data.dimension(d))
img = data.getImgPlus()
xLen = data.dimension(data.dimensionIndex(Axes.X))
yLen = data.dimension(data.dimensionIndex(Axes.Y))
zLen = data.dimension(data.dimensionIndex(Axes.Z))
cLen = data.dimension(data.dimensionIndex(Axes.CHANNEL))
# crop a channel
c0 = ops.transform().crop(
img, Intervals.createMinMax(0, 0, 0, 0, xLen - 1, yLen - 1, 0, zLen - 1))
c0.setName("c0")
# crop both channels at z=12
z12 = ops.transform().crop(
img, Intervals.createMinMax(0, 0, 0, 12, xLen - 1, yLen - 1, cLen - 1, 12))
z12.setName("z12")
# crop channel 0 at z=12
c0z12 = ops.transform().crop(
img, Intervals.createMinMax(0, 0, 0, 12, xLen - 1, yLen - 1, 0, 12))
c0z12.setName("c0z12")
# crop an roi at channel 0, z=12
roiC0z12 = ops.transform().crop(
img, Intervals.createMinMax(150, 150, 0, 12, 200, 200, 0, 12))
from net.imglib2.util import Intervals
from net.imagej.axis import Axes
# first take a look at the size and type of each dimension
for d in range(data.numDimensions()):
print "axis d: type: "+str(data.axis(d).type())+" length: "+str(data.dimension(d))
img=data.getImgPlus()
xLen = data.dimension(data.dimensionIndex(Axes.X))
yLen = data.dimension(data.dimensionIndex(Axes.Y))
zLen = data.dimension(data.dimensionIndex(Axes.Z))
cLen = data.dimension(data.dimensionIndex(Axes.CHANNEL))
# crop a channel
c0=ops.transform().crop(img, Intervals.createMinMax(0, 0, 0,0,xLen-1, yLen-1, 0, zLen-1))
c0.setName("c0")
# crop both channels at z=12
z12=ops.transform().crop(img, Intervals.createMinMax(0,0,0,12, xLen-1, yLen-1, cLen-1, 12))
z12.setName("z12")
# crop channel 0 at z=12
c0z12=ops.transform().crop(img, Intervals.createMinMax(0,0,0,12, xLen-1, yLen-1, 0, 12))
c0z12.setName("c0z12")
# crop an roi at channel 0, z=12
roiC0z12=ops.transform().crop(img, Intervals.createMinMax(150,150,0,12, 200, 200, 0, 12))
roiC0z12.setName("roiC0z12")
from net.imglib2 import Point
from net.imglib2.algorithm.region.hypersphere import HyperSphere
from net.imglib2.util import Intervals
# crop PSF to desired size, this makes conv and decon run faster with little effect on final quality
croppedX = 64
croppedY = 64
kernelX = kernel.dimension(0)
kernelY = kernel.dimension(1)
kernelZ = kernel.dimension(2)
kernel_ = ops.transform().crop(
kernel,
Intervals.createMinMax(kernelX / 2 - croppedX / 2,
kernelY / 2 - croppedY / 2, 0,
kernelX / 2 + croppedX / 2 - 1,
kernelY / 2 + croppedY / 2 - 1, kernelZ - 1))
# convolve kernel with phantom
convolved = ops.filter().convolve(img, kernel)
# make convolved an ImgPlus
convolved = ops.create().imgPlus(convolved)
convolved.setName("convolved")
deconvolved = ops.create().img(convolved)
deconvolved = ops.deconvolve().richardsonLucy(deconvolved, convolved, kernel,
[0, 0, 0], None, None, None,
None, 30, True, True)
def smooth_temporal_gradient(ops, img, sigma_xy, sigma_t, frame_start,
frame_end, normalize_output):
"""
Smooth input image (imglib2 array) xyt with Gaussian and build temporal gradient
from frame_start to frame_end
"""
n = img.numDimensions()
assert n == 3, "Input data needs to be 3-dimensional, 2D + time"
dims = [img.dimension(d) for d in range(n)]
dim_x, dim_y, dim_t = dims
if frame_end == -1:
frame_end = dim_t
if frame_end > dim_t:
frame_end = dim_t
assert frame_start < frame_end, "'Frame start' must be smaller than 'Frame end'"
## crop image temporally by using a View
# img_crop = Views.interval(img, [0, 0, frame_start], [dim_x-1, dim_y-1, frame_end-1])
# or by cropping without view
img_crop = ops.transform().crop(
img,
Intervals.createMinMax(0, 0, frame_start, dim_x - 1, dim_y - 1,
frame_end - 1))
# create output for smoothing
img_smooth = ArrayImgFactory(FloatType()).create(img_crop)
# update dimensions (after cropping)
dims = [img_crop.dimension(d) for d in range(n)]
# smooth with Gaussian (use mirror as border treatment)
Gauss3.gauss([sigma_xy, sigma_xy, sigma_t], Views.extendBorder(img_crop),
img_smooth)
# compute gradient along (time) axis 2
gradient = ArrayImgFactory(FloatType()).create(dims)
PartialDerivative.gradientBackwardDifference(
Views.extendBorder(img_smooth), gradient, 2)
# separate response into growing and shrinking part by thresholding and multiplying that mask
thresholded = ops.run("threshold.apply", gradient, FloatType(0.))
mask = ops.convert().float32(thresholded)
grow = ops.run("math.multiply", gradient, mask)
# same for shrinking, but negate befor to obtain negative part
gradient_neg = ops.run("math.multiply", gradient, -1)
thresholded = ops.run("threshold.apply", gradient_neg, FloatType(0.))
mask = ops.convert().float32(thresholded)
shrink = ops.run("math.multiply", gradient, mask)
# allign growth and shrink by offset of 1 in t dimesnion
shrink = Views.interval(shrink, [0, 0, 0],
[dims[0] - 1, dims[1] - 1, dims[2] - 2])
grow = Views.interval(grow, [0, 0, 1],
[dims[0] - 1, dims[1] - 1, dims[2] - 1])
img_smooth = Views.interval(img_smooth, [0, 0, 0],
[dims[0] - 1, dims[1] - 1, dims[2] - 2])
# concatenate output
if normalize_output:
shrink = rescale_uint8(ops, shrink)
grow = rescale_uint8(ops, grow)
img_smooth = rescale_uint8(ops, img_smooth)
out = Views.stack([shrink, grow, img_smooth])
# permute channel with time to make time last dim (for back-conversion)
out = Views.permute(out, 2, 3)
# crop view 1st time point result (empty since using backwardDifferences)
out = Views.interval(out, [0, 0, 0, 1],
[out.dimension(d) - 1 for d in range(4)])
# get ImagePlus back and set correct dimensions
out_imp = IJF.wrap(out, "Grow and shrink")
# resize IMP now one frame less (see crop view)
out_imp.setDimensions(3, 1, frame_end - frame_start - 2)
out_imp.setDisplayMode(IJ.COMPOSITE)
# IJ.save(out_imp, "H:/projects/032_loose_speckle/grow_and_shrink_ij.tif")
return out_imp
# @Dataset data
# @UIService ui
# @DisplayService display
# to run this tutorial run 'file->Open Samples->Confocal Series' and make sure that
# confocal-series.tif is the active image
from net.imglib2.util import Intervals
from net.imagej.axis import Axes
# first take a look at the size and type of each dimension
for d in range(data.numDimensions()):
print "axis d: type: " + str(data.axis(d).type()) + " length: " + str(
data.dimension(d))
img = data.getImgPlus()
cropDims = []
for d in range(data.numDimensions()):
print "axis d: type: " + str(data.axis(d).type()) + " length: " + str(
data.dimension(d))
for d in range(data.numDimensions()):
cropDims.append(data.dimension(d) / 4)
for d in range(data.numDimensions()):
cropDims.append(3 * (data.dimension(d) / 4) - 1)
cropped = ops.image().crop(img, Intervals.createMinMax(cropDims))
ui.show(cropped)
from net.imglib2.util import Intervals
from net.imagej.axis import Axes
# first take a look at the size and type of each dimension
for d in range(data.numDimensions()):
print "axis d: type: "+str(data.axis(d).type())+" length: "+str(data.dimension(d))
img=data.getImgPlus()
xLen = data.dimension(data.dimensionIndex(Axes.X))
yLen = data.dimension(data.dimensionIndex(Axes.Y))
zLen = data.dimension(data.dimensionIndex(Axes.Z))
cLen = data.dimension(data.dimensionIndex(Axes.CHANNEL))
# crop a channel
c0=ops.image().crop(img, Intervals.createMinMax(0, 0, 0,0,xLen-1, yLen-1, 0, zLen-1))
c0.setName("c0")
# crop both channels at z=12
z12=ops.image().crop(img, Intervals.createMinMax(0,0,0,12, xLen-1, yLen-1, cLen-1, 12))
z12.setName("z12")
# crop channel 0 at z=12
c0z12=ops.image().crop(img, Intervals.createMinMax(0,0,0,12, xLen-1, yLen-1, 0, 12))
c0z12.setName("c0z12")
# crop an roi at channel 0, z=12
roiC0z12=ops.image().crop(img, Intervals.createMinMax(150,150,0,12, 200, 200, 0, 12))
roiC0z12.setName("roiC0z12")
for i, z in enumerate(range(z_start, z_end)):
log.info(
"Processing frame %i/%i for ROIs #%i and #%i (%i total detected ROIs)"
% (z_start + i, z_end, j, j + 1, len(rois)))
# Compute the translation
dx = int(x_shift + total_x_shift) * -1
dy = int(y_shift + total_y_shift) * -1
total_x_shift += x_shift
total_y_shift += y_shift
# Get only the frame cooresponding to the actual Z/T position
intervals = Intervals.createMinMax(0, 0, z,
ds.getWidth() - 1,
ds.getHeight() - 1, z)
single_frame = ops.transform().crop(img, intervals)
# Pad the frame so the outisde of the image dimensions values are set to 0
padded_frame = ops.transform().extendZero(single_frame)
# Do the translation
translated_frame = ops.transform().translate(padded_frame, [dx, dy])
# Cleanup
interval2d = Intervals.createMinMax(0, 0,
ds.getWidth() - 1,
ds.getHeight() - 1)
translated_frame = Views.interval(translated_frame, interval2d)
translated_frame = ops.transform().dropSingletonDimensions(
# create an empty image
phantom = ops.create().img([xSize, ySize, zSize])
# make phantom an ImgPlus
phantom = ops.create().imgPlus(phantom)
location = Point(phantom.numDimensions())
location.setPosition([xSize / 2, ySize / 2, zSize / 2])
hyperSphere = HyperSphere(phantom, location, 10)
for value in hyperSphere:
value.setReal(100)
phantom.setName("phantom")
affine = AffineTransform3D()
affine.scale(1, 1, 0.4)
interpolatedImg = Views.interpolate(Views.extendZero(phantom),
NLinearInterpolatorFactory())
phantom = Views.interval(
Views.raster(RealViews.affine(interpolatedImg, affine)),
Intervals.createMinMax(0, 0, 18, 255, 255, 82))
# make phantom an ImgPlus
phantom = ops.create().imgPlus(ops.copy().iterableInterval(
Views.zeroMin(phantom)))
phantom.setName('phantom')
converted = ops.convert().float32(data)
# Get the first frame (TODO: find a more convenient way !)
t_dim = data.dimensionIndex(Axes.TIME)
interval_start = []
interval_end = []
for d in range(0, data.numDimensions()):
if d != t_dim:
interval_start.append(0)
interval_end.append(data.dimension(d) - 1)
else:
interval_start.append(0)
interval_end.append(0)
intervals = interval_start + interval_end
intervals = Intervals.createMinMax(*intervals)
first_frame = ops.transform().crop(converted, intervals)
# Allocate output memory (wait for hybrid CF version of slice)
subtracted = ops.create().img(converted)
# Create the op
sub_op = ops.op("math.subtract", first_frame, first_frame)
# Setup the fixed axis
fixed_axis = [d for d in range(0, data.numDimensions()) if d != t_dim]
# Run the op
ops.slice(subtracted, converted, sub_op, fixed_axis)
converted = ops.convert().float32(data)
# Get the first frame (TODO: find a more convenient way !)
t_dim = data.dimensionIndex(Axes.TIME)
interval_start = []
interval_end = []
for d in range(0, data.numDimensions()):
if d != t_dim:
interval_start.append(0)
interval_end.append(data.dimension(d) - 1)
else:
interval_start.append(0)
interval_end.append(0)
intervals = interval_start + interval_end
intervals = Intervals.createMinMax(*intervals)
first_frame = ops.transform().crop(converted, intervals)
# Allocate output memory (wait for hybrid CF version of slice)
subtracted = ops.create().img(converted)
# Create the op
sub_op = ops.op("math.subtract", first_frame, first_frame)
# Setup the fixed axis
fixed_axis = [d for d in range(0, data.numDimensions()) if d != t_dim]
# Run the op
ops.slice(subtracted, converted, sub_op, fixed_axis)
