def rotatedView(img, angle, enlarge=True, extend=Views.extendBorder):
""" Return a rotated view of the image, around the Z axis,
with an expanded (or reduced) interval view so that all pixels are exactly included.
img: a RandomAccessibleInterval
angle: in degrees
"""
cx = img.dimension(0) / 2.0
cy = img.dimension(1) / 2.0
toCenter = AffineTransform2D()
toCenter.translate(-cx, -cy)
rotation = AffineTransform2D()
# Step 1: place origin of rotation at the center of the image
rotation.preConcatenate(toCenter)
# Step 2: rotate around the Z axis
rotation.rotate(radians(angle))
# Step 3: undo translation to the center
rotation.preConcatenate(toCenter.inverse())
rotated = RV.transform(Views.interpolate(extend(img),
NLinearInterpolatorFactory()), rotation)
if enlarge:
# Bounds:
bounds = repeat((sys.maxint, 0)) # initial upper- and lower-bound values
# for min, max to compare against
transformed = zeros(2, 'f')
for corner in product(*zip(repeat(0), Intervals.maxAsLongArray(img))):
rotation.apply(corner, transformed)
bounds = [(min(vmin, int(floor(v))), max(vmax, int(ceil(v))))
for (vmin, vmax), v in zip(bounds, transformed)]
minC, maxC = map(list, zip(*bounds)) # transpose list of 2 pairs
# into 2 lists of 2 values
imgRot = Views.zeroMin(Views.interval(rotated, minC, maxC))
else:
imgRot = Views.interval(rotated, img)
return imgRot
def asNormalizedUnsignedByteArrayImg(interval, invert, blockRadius, n_bins,
slope, matrices, copy_threads, index,
imp):
sp = imp.getProcessor() # ShortProcessor
sp.setRoi(interval.min(0), interval.min(1),
interval.max(0) - interval.min(0) + 1,
interval.max(1) - interval.min(1) + 1)
sp = sp.crop()
if invert:
sp.invert()
CLAHE.run(
ImagePlus("", sp), blockRadius, n_bins, slope, None
) # far less memory requirements than NormalizeLocalContrast, and faster.
minimum, maximum = autoAdjust(sp)
# Transform and convert image to 8-bit, mapping to display range
img = ArrayImgs.unsignedShorts(
sp.getPixels(), [sp.getWidth(), sp.getHeight()])
sp = None
affine = AffineTransform2D()
affine.set(matrices[index])
imgI = Views.interpolate(Views.extendZero(img),
NLinearInterpolatorFactory())
imgA = RealViews.transform(imgI, affine)
imgT = Views.zeroMin(Views.interval(imgA, img))
imgMinMax = convert(imgT, RealUnsignedByteConverter(minimum, maximum),
UnsignedByteType)
aimg = ArrayImgs.unsignedBytes(Intervals.dimensionsAsLongArray(img))
ImgUtil.copy(ImgView.wrap(imgMinMax, aimg.factory()), aimg,
copy_threads)
img = imgI = imgA = imgT = imgMinMax = None
return aimg
def getViewFromImp(imp, r=None):
# r is a java.awt.rectangle
im = IL.wrapByte(imp)
if r is None:
r = Rectangle(0, 0, imp.getWidth(), imp.getHeight())
v = Views.zeroMin(
Views.interval(im, [r.x, r.y],
[r.x + r.width - 1, r.y + r.height - 1]))
return v
def prepareImgForDeconvolution(img, affine3D, interval):
"""
Transform the img for deconvolution, taking care of pixels with zero value within the image
and setting the appropriate values for outside the image, and cropping to the interval.
"""
return Views.zeroMin(TransformView.transformView(img, affine3D, interval,
MultiViewDeconvolution.minValueImg,
MultiViewDeconvolution.outsideValueImg,
1)) # 1: linear interpolation
"""
def get(self, path): transform = self.transformsDict[path] img = self.loader.get(path) imgE = Views.extendZero(img) imgI = Views.interpolate(imgE, NLinearInterpolatorFactory()) imgT = RealViews.transform(imgI, transform) minC = self.roi[0] if self.roi else [0] * img.numDimensions() maxC = self.roi[1] if self.roi else [img.dimension(d) -1 for d in xrange(img.numDimensions())] imgO = Views.zeroMin(Views.interval(imgT, minC, maxC)) return ImgView.wrap(imgO, img.factory()) if self.asImg else imgO
def makeCell(self, index):
self.preloadCells(index) # preload others in the background
img = self.loadImg(self.filepaths[index])
affine = AffineTransform2D()
affine.set(self.matrices[index])
imgI = Views.interpolate(Views.extendZero(img),
NLinearInterpolatorFactory())
imgA = RealViews.transform(imgI, affine)
imgT = Views.zeroMin(Views.interval(imgA, self.interval))
aimg = img.factory().create(self.interval)
ImgUtil.copy(ImgView.wrap(imgT, aimg.factory()), aimg)
return Cell(self.cell_dimensions, [0, 0, index], aimg.update(None))
def keyPressed(self, ke):
keyCode = ke.getKeyCode()
if ke.isControlDown() and keyCode in Navigator.moves:
d, sign = Navigator.moves[keyCode]
inc = 200 if ke.isShiftDown() else 20
mins[d] += sign * inc
maxs[d] += sign * inc
# Replace source with shifted cropped volume
fsource.set(stack, Views.zeroMin(Views.interval(imgE, FinalInterval(mins, maxs))))
imp.updateVirtualSlice()
return
# Else, pass the event onto other listeners
for kl in kls:
kl.keyPressed(ke)
def crop(event):
global cropped, cropped_imp
coords = [int(float(tf.getText())) for tf in textfields]
minC = [max(0, c) for c in coords[0:3]]
maxC = [min(d -1, c) for d, c in izip(Intervals.dimensionsAsLongArray(images[0]), coords[3:6])]
storeRoi(minC, maxC)
print "ROI min and max coordinates"
print minC
print maxC
cropped = [Views.zeroMin(Views.interval(img, minC, maxC)) for img in images]
cropped_imp = showAsStack(cropped, title="cropped")
cropped_imp.setDisplayRange(imp.getDisplayRangeMin(), imp.getDisplayRangeMax())
if cropContinuationFn:
cropContinuationFn(images, minC, maxC, cropped, cropped_imp)
def asNormalizedUnsignedByteArrayImg(interval, invert, blockRadius, n_bins,
slope, matrices, index, imp):
sp = imp.getProcessor() # ShortProcessor
# Crop to interval if needed
x = interval.min(0)
y = interval.min(1)
width = interval.max(0) - interval.min(0) + 1
height = interval.max(1) - interval.min(1) + 1
if 0 != x or 0 != y or sp.getWidth() != width or sp.getHeight(
) != height:
sp.setRoi(x, y, width, height)
sp = sp.crop()
if invert:
sp.invert()
CLAHE.run(
ImagePlus("", sp), blockRadius, n_bins, slope, None
) # far less memory requirements than NormalizeLocalContrast, and faster.
minimum, maximum = autoAdjust(sp)
# Transform and convert image to 8-bit, mapping to display range
img = ArrayImgs.unsignedShorts(
sp.getPixels(), [sp.getWidth(), sp.getHeight()])
sp = None
imp = None
# Must use linear interpolation for subpixel precision
affine = AffineTransform2D()
affine.set(matrices[index])
imgI = Views.interpolate(Views.extendZero(img),
NLinearInterpolatorFactory())
imgA = RealViews.transform(imgI, affine)
imgT = Views.zeroMin(Views.interval(imgA, img))
# Convert to 8-bit
imgMinMax = convert2(imgT,
RealUnsignedByteConverter(minimum, maximum),
UnsignedByteType,
randomAccessible=False) # use IterableInterval
aimg = ArrayImgs.unsignedBytes(Intervals.dimensionsAsLongArray(img))
# ImgUtil copies multi-threaded, which is not appropriate here as there are many other images being copied too
#ImgUtil.copy(ImgView.wrap(imgMinMax, aimg.factory()), aimg)
# Single-threaded copy
copier = createBiConsumerTypeSet(UnsignedByteType)
LoopBuilder.setImages(imgMinMax, aimg).forEachPixel(copier)
img = imgI = imgA = imgMinMax = imgT = None
return aimg
def twoStep(index=0):
# The current way:
img = klb.readFull(filepaths[index]) # klb_loader.get(filepaths[index])
imgE = Views.extendZero(img)
imgI = Views.interpolate(imgE, NLinearInterpolatorFactory())
imgT = RealViews.transform(imgI, cmIsotropicTransforms[index])
imgB = Views.zeroMin(Views.interval(imgT, roi[0],
roi[1])) # bounded: crop with ROI
imgBA = ArrayImgs.unsignedShorts(Intervals.dimensionsAsLongArray(imgB))
ImgUtil.copy(ImgView.wrap(imgB, imgBA.factory()), imgBA)
imgP = prepareImgForDeconvolution(
imgBA,
affine3D(fineTransformsPostROICrop[index]).inverse(),
FinalInterval([0, 0, 0], [imgB.dimension(d) - 1 for d in xrange(3)]))
# Copy transformed view into ArrayImg for best performance in deconvolution
imgA = ArrayImgs.floats(Intervals.dimensionsAsLongArray(imgP))
ImgUtil.copy(ImgView.wrap(imgP, imgA.factory()), imgA)
IL.wrap(imgA, "two step").show()
def filterBankRotations(img,
angles=xrange(0, 46, 9), # sequence, in degrees
filterBankFn=filterBank, # function that takes an img as sole positional argument
outputType=FloatType()):
""" img: a RandomAccessibleInterval.
filterBankFn: the function from which to obtain a sequence of ImgMath ops.
angles: a sequence of angles in degrees.
outputType: for materializing rotated operations and rotating them back.
For every angle, will prepare a rotated view of the image,
then create a list of ops on the basis of that rotated view,
then materialize each op into an image so that an unrotated view
can be returned back.
returns a list of unrotated views, each containing the values of applying
each op to the rotated view.
"""
ops_rotations = []
for angle in angles:
imgRot = img if 0 == angle else rotatedView(img, angle)
ops = filterBankFn(imgRot)
# Materialize these two combination ops and rotate them back (rather, a rotated view)
interval = Intervals.translate(img, [(imgRot.dimension(d) - img.dimension(d)) / 2
for d in xrange(img.numDimensions())])
for op in ops:
imgOpRot = compute(op).intoArrayImg(outputType)
if 0 == angle:
ops_rotations.append(imgOpRot)
continue
# Rotate them back and crop view
imgOpUnrot = rotatedView(imgOpRot, -angle, enlarge=False)
imgOp = Views.zeroMin(Views.interval(imgOpUnrot, interval))
#if angle == 0 or angle == 45:
# IL.wrap(imgOpRot, "imgOpRot angle=%i" % angle).show()
# IL.wrap(imgOpUnrot, "imgOpUnrot angle=%i" % angle).show()
# IL.wrap(imgOp, "imgOp angle=%i" % angle).show()
ops_rotations.append(imgOp)
return ops_rotations
# by using the 'transformed' float array.
# We compute the bounds by, for every corner, checking if the floor of each dimension
# of a corner coordinate is smaller than the previously found minimum value,
# and by checking if the ceil of each corner coordinate is larger than the
# previously found value, packing the new pair of minimum and maximum values
# into the list of pairs that is 'bounds'.
# Notice the min coordinates can have negative values, as the rotated image
# has pixels now somewhere to the left and up from the top-left 0,0,0 origin
# of coordinates. That's why we use Views.zeroMin, to ensure that downstream
# uses of the transformed image see it as fitting within bounds that start at 0,0,0.
bounds = repeat(
(sys.maxint, 0)
) # initial upper- and lower-bound values for min, max to compare against
transformed = zeros(img.numDimensions(), 'f')
for corner in product(*zip(repeat(0), Intervals.maxAsLongArray(img))):
rotation.apply(corner, transformed)
bounds = [(min(vmin, int(floor(v))), max(vmax, int(ceil(v))))
for (vmin, vmax), v in zip(bounds, transformed)]
minC, maxC = map(list, zip(*bounds)) # transpose list of lists
imgRot2dFit = IL.wrap(Views.zeroMin(Views.interval(rotated, minC, maxC)),
imp.getTitle() + " - rot2dFit")
imgRot2dFit.show()
matrix = rotation.getRowPackedCopy()
pprint([list(matrix[i:i + 4]) for i in xrange(0, 12, 4)])
from itertools import imap, izip, product, combinations
from jarray import array, zeros
import os, csv
from java.util.concurrent import Executors, Callable
from java.util import ArrayList
from ij import IJ
from net.imglib2.algorithm.math import ImgMath, ImgSource
from net.imglib2.img.array import ArrayImgs
from net.imglib2.realtransform import RealViews, AffineTransform3D
from net.imglib2.interpolation.randomaccess import NLinearInterpolatorFactory
from net.imglib2.util import Intervals
img = IL.wrap(IJ.getImage())
# Cut out a cube
img1 = Views.zeroMin(
Views.interval(img, [39, 49, 0], [39 + 378 - 1, 49 + 378 - 1, 378 - 1]))
print[img1.dimension(d) for d in xrange(img1.numDimensions())]
# Rotate the cube on the Y axis to the left
img2 = Views.rotate(img1, 2, 0)
# copy into ArrayImg
img1a = ArrayImgs.unsignedShorts([378, 378, 378])
ImgMath.compute(ImgSource(img1)).into(img1a)
img2a = ArrayImgs.unsignedShorts([378, 378, 378])
ImgMath.compute(ImgSource(img2)).into(img2a)
img1 = img1a
img2 = img2a
from net.imglib2.img.display.imagej import ImageJFunctions as IL
from ij import IJ
# Open Nile Bend sample image
imp = IJ.getImage()
#imp = IJ.openImage("https://imagej.nih.gov/ij/images/NileBend.jpg")
img = IL.wrapRGBA(imp)
# Extract red channel: alpha:0, red:1, green:2, blue:3
red = Converters.argbChannel(img, 1)
# Cut out two overlapping ROIs
r1 = Rectangle(1708, 680, 1792, 1760)
r2 = Rectangle(520, 248, 1660, 1652)
cut1 = Views.zeroMin(
Views.interval(red, [r1.x, r1.y],
[r1.x + r1.width - 1, r1.y + r1.height - 1]))
cut2 = Views.zeroMin(
Views.interval(red, [r2.x, r2.y],
[r2.x + r2.width - 1, r2.y + r2.height - 1]))
# Thread pool
exe = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors())
try:
# PCM: phase correlation matrix
pcm = PhaseCorrelation2.calculatePCM(cut1, cut2,
ArrayImgFactory(FloatType()),
FloatType(),
ArrayImgFactory(ComplexFloatType()),
ComplexFloatType(), exe)
# Test
# Prepare test data
def dropSlices(img, nth):
""" Drop every nth slice. Calibration is to be multipled by nth for Z.
Counts slices 1-based so as to preserve the first slice (index zero).
"""
return Views.stack([Views.hyperSlice(img, 2, i)
for i in xrange(img.dimension(2)) if 0 == (i+1) % nth])
# Grap the current image
img = IL.wrap(IJ.getImage())
# Cut out a cube
img1 = Views.zeroMin(Views.interval(img, [39, 49, 0],
[39 + 378 -1, 49 + 378 -1, 378 -1]))
# Rotate the cube on the Y axis to the left
img2 = Views.zeroMin(Views.rotate(img1, 2, 0)) # zeroMin is CRITICAL
# Rotate the cube on the X axis to the top
img3 = Views.zeroMin(Views.rotate(img1, 2, 1))
# Reduce Z resolution: make them anisotropic but in a different direction
nth = 2
img1 = dropSlices(img1, nth)
img2 = dropSlices(img2, nth)
img3 = dropSlices(img3, nth)
# The sequence of images to transform, each relative to the previous
images = [img1, img2, img3]
imp.setRoi(roi)
# Now, iterate each peak, defining a small interval centered at each peak,
# and measure the sum of total pixel intensity,
# and display the results in an ImageJ ResultTable.
table = ResultsTable()
for peak in peaks:
# Read peak coordinates into an array of integers
peak.localize(p)
# Define limits of the interval around the peak:
# (sigmaSmaller is half the radius of the embryo)
minC = [int(p[i] - sigmaSmaller) for i in xrange(img.numDimensions())]
maxC = [int(p[i] + sigmaSmaller) for i in xrange(img.numDimensions())]
# View the interval around the peak, as a flat iterable (like an array)
square = Views.flatIterable(Views.zeroMin(Views.interval(img, minC, maxC)))
s1 = sum(t.getInteger() for t in square)
area1 = Intervals.numElements(square)
# Use a sphere instead
radius = sqrt(area1 / pi) # same area for both
print sigmaSmaller, radius
circle = Masks.toIterableRegion(GeomMasks.closedSphere(p, radius))
s2 = sum(t.getInteger() for t in Regions.sample(circle, imgE))
area2 = Intervals.numElements(circle)
print area1, area2
# Compute sum of pixel intensity values of the interval
# (The t is the Type that mediates access to the pixels, via its get* methods)
# Add to results table
def cropView(img): return Views.zeroMin(Views.interval(img, [1, 228, 0], [1 + 406 -1, 228 + 465 -1, 325 -1]))
def getViewFromImglib2Im(img, r):
v = Views.zeroMin(
Views.interval(img, [r.x, r.y],
[r.x + r.width - 1, r.y + r.height - 1]))
return v
# 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')
def cropView(img, minCoords, maxCoords):
return Views.zeroMin(Views.interval(img, minCoords, maxCoords))
