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 translatedView(img, matrix): imgE = Views.extendZero(img) imgI = Views.interpolate(imgE, NLinearInterpolatorFactory()) # In negative: the inverse t = Translation3D(-matrix[3], -matrix[7], -matrix[11]) imgT = RealViews.transform(imgI, t) return Views.interval(imgT, [0, 0, 0], [img.dimension(d) for d in xrange(3)])
def translate_single_stack_using_imglib2(imp, dx, dy, dz):
# wrap into a float imglib2 and translate
# conversion into float is necessary due to "overflow of n-linear interpolation due to accuracy limits of unsigned bytes"
# see: https://github.com/fiji/fiji/issues/136#issuecomment-173831951
img = ImagePlusImgs.from(imp.duplicate())
extended = Views.extendZero(img)
converted = Converters.convert(extended, RealFloatSamplerConverter())
interpolant = Views.interpolate(converted, NLinearInterpolatorFactory())
# translate
if imp.getNDimensions()==3:
transformed = RealViews.affine(interpolant, Translation3D(dx, dy, dz))
elif imp.getNDimensions()==2:
transformed = RealViews.affine(interpolant, Translation2D(dx, dy))
else:
IJ.log("Can only work on 2D or 3D stacks")
return None
cropped = Views.interval(transformed, img)
# wrap back into bit depth of input image and return
bd = imp.getBitDepth()
if bd==8:
return(ImageJFunctions.wrapUnsignedByte(cropped,"imglib2"))
elif bd == 16:
return(ImageJFunctions.wrapUnsignedShort(cropped,"imglib2"))
elif bd == 32:
return(ImageJFunctions.wrapFloat(cropped,"imglib2"))
else:
return None
def viewTransformed(img, affine):
imgE = Views.extendZero(img)
imgI = Views.interpolate(imgE, NLinearInterpolatorFactory())
imgT = RealViews.transform(imgI, affine)
minC = [0, 0, 0]
maxC = [img.dimension(d) - 1 for d in xrange(img.numDimensions())]
imgB = Views.interval(imgT, minC, maxC)
return imgB
def transformedView(img, matrix): imgE = Views.extendZero(img) imgI = Views.interpolate(imgE, NLinearInterpolatorFactory()) aff = AffineTransform3D() aff.set(*matrix) aff = aff.inverse() imgT = RealViews.transform(imgI, aff) return Views.interval(imgT, [0, 0, 0], [img.dimension(d) for d in xrange(3)])
def updatePixels(self):
# Copy interval into pixels
view = Views.interval(
Views.extendZero(Views.hyperSlice(self.img3D, 2, self.indexZ)),
self.interval2D)
aimg = ArrayImgs.floats(
self.getPixels(),
[self.interval2D.dimension(0),
self.interval2D.dimension(1)])
ImgUtil.copy(view, aimg)
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 transformedView(img, transform, interval=None):
""" """
imgE = Views.extendZero(img)
imgI = Views.interpolate(imgE, NLinearInterpolatorFactory())
imgT = RealViews.transform(imgI, transform)
if interval:
return Views.interval(imgT, interval)
else:
return Views.interval(
imgT, [0, 0, 0],
[img.dimension(d) - 1 for d in xrange(img.numDimensions())])
def viewTransformed(img, matrix):
affine = AffineTransform3D()
affine.set(*matrix)
# It's a forward transform: invert
affine = affine.inverse()
imgE = Views.extendZero(img)
imgI = Views.interpolate(imgE, NLinearInterpolatorFactory())
imgT = RealViews.transform(imgI, affine)
# Same dimensions
imgB = Views.interval(imgT, img)
return imgB
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 scale3D(img, x=1.0, y=1.0, z=1.0):
scale3d = AffineTransform3D()
scale3d.set(x, 0, 0, 0,
0, y, 0, 0,
0, 0, z, 0)
imgE = Views.extendZero(img)
imgI = Views.interpolate(imgE, NLinearInterpolatorFactory())
imgT = RealViews.transform(imgI, scale3d)
# dimensions
minC = [0, 0, 0]
maxC = [int(img.dimension(d) * k + 0.5) -1 for d, k in enumerate([x, y, z])]
imgB = Views.interval(imgT, minC, maxC)
return imgB
def scale(img, calibration):
scale3d = AffineTransform3D()
scale3d.set(calibration[0], 0, 0, 0, 0, calibration[1], 0, 0, 0, 0,
calibration[2], 0)
imgE = Views.extendZero(img)
imgI = Views.interpolate(imgE, NLinearInterpolatorFactory())
imgT = RealViews.transform(imgI, scale3d)
# dimensions
minC = [0, 0, 0]
maxC = [
int(img.dimension(d) * cal) - 1 for d, cal in enumerate(calibration)
]
imgB = Views.interval(imgT, minC, maxC)
return imgB
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 get(self, path):
img = self.klb.readFull(path)
imgE = Views.extendZero(img)
imgI = Views.interpolate(imgE, NLinearInterpolatorFactory())
affine = AffineTransform3D()
affine.set(self.transforms[path])
affine = affine.inverse() # it's a forward transform: must invert
affine.concatenate(scale3d) # calibrated space: isotropic
imgT = RealViews.transform(imgI, affine)
minC = [0, 0, 0]
maxC = [
int(img.dimension(d) * cal) - 1
for d, cal in enumerate(calibration)
]
imgB = Views.interval(imgT, minC, maxC)
# View a RandomAccessibleInterval as an Img, required by Load.lazyStack
return ImgView.wrap(imgB, img.factory())
def viewTransformed(img, calibration, affine):
""" View img transformed to isotropy (via the calibration)
and transformed by the affine. """
scale3d = AffineTransform3D()
scale3d.set(calibration[0], 0, 0, 0,
0, calibration[1], 0, 0,
0, 0, calibration[2], 0)
transform = affine.copy()
transform.concatenate(scale3d)
imgE = Views.extendZero(img)
imgI = Views.interpolate(imgE, NLinearInterpolatorFactory())
imgT = RealViews.transform(imgI, transform)
# dimensions
minC = [0, 0, 0]
maxC = [int(img.dimension(d) * cal) -1 for d, cal in enumerate(calibration)]
imgB = Views.interval(imgT, minC, maxC)
return imgB
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 viewTransformed(img, calibration, matrix):
affine = AffineTransform3D()
affine.set(*matrix)
# It's a forward transform: invert
affine = affine.inverse()
# Correct calibration
scale3d = AffineTransform3D()
scale3d.set(calibration[0], 0, 0, 0,
0, calibration[1], 0, 0,
0, 0, calibration[2], 0)
affine.concatenate(scale3d)
imgE = Views.extendZero(img)
imgI = Views.interpolate(imgE, NLinearInterpolatorFactory())
imgT = RealViews.transform(imgI, affine)
# dimensions
minC = [0, 0, 0]
maxC = [int(img.dimension(d) * cal) -1 for d, cal in enumerate(calibration)]
imgB = Views.interval(imgT, minC, maxC)
return imgB
def viewTransformed(image,
transformation,
title=None,
interval=None,
show=True):
if isinstance(image, ImagePlus):
img = IL.wrap(
image
) # ImagePlus to ImgLib2 RandomAccessibleInterva & IterableInterval aka Img
elif isinstance(image, RandomAccessibleInterval):
img = image
else:
return None
# Make the image be defined anywhere by infinitely padding with zeros.
imgInfinite = Views.extendZero(img)
# Make the image be defined at arbitrarily precise subpixel coordinates
# by using n-dimensional linear interpolation
imgInterpolated = Views.interpolate(imgInfinite,
NLinearInterpolatorFactory())
# Make the image be seen as a transformed view of the source image
imgTransformed = RealViews.transform(imgInterpolated, transformation)
# Define an interval within which we want the transformed image to be defined
# (such as that of the source img itself; an img in ImgLib2 also happens to be an Interval
# and can therefore be used as an interval, which is convenient here because we
# expect the original field of view--the interval--to be where image data can still be found)
interval = interval if interval else img # every Img is also an Interval because each Img is bounded
# Make the image finite by defining it as the content within the interval
imgBounded = Views.interval(imgTransformed, interval) # same as original
# Optionally show the transformed, bounded image in an ImageJ VirtualStack
# (Note that anytime one of the VirtualStack's ImageProcessor will have to
# update its pixel data, it will incur in executing the transformation again;
# no pixel data is cached or copied anywhere other than for display purposes)
if show:
title = title if title else imp.getTitle()
imp = IL.wrap(imgBounded, title) # as an ImagePlus
imp.show() # in an ImageJ ImageWindow
return imgBounded
def transformedView(img, matrix): imgE = Views.extendZero(img)
def run():
t_start = datetime.now()
image_paths = glob(os.path.join(str(import_dir.getPath()), '*tif'))
print '\tread image metadata'
reader = ImageReader()
in_meta = MetadataTools.createOMEXMLMetadata()
reader.setMetadataStore(in_meta)
x_dims = []
y_dims = []
z_dims = []
c_dims = []
t_dims = []
eff = []
spp = []
for image_path in image_paths:
print '\t parse %s' % (image_path)
reader.setId(image_path)
x_dims.append(reader.getSizeX())
y_dims.append(reader.getSizeY())
z_dims.append(reader.getSizeZ())
c_dims.append(reader.getSizeC())
t_dims.append(reader.getSizeT())
eff.append(reader.imageCount / z_dims[-1] / t_dims[-1])
spp.append(reader.getSizeC() / eff[-1])
format = FormatTools.getPixelTypeString(reader.getPixelType())
series = reader.getSeries()
big_endian = Boolean.FALSE
order = reader.getDimensionOrder()
reader.close()
# Compute the dimensions of the output file
x_dim = max(x_dims)
y_dim = max(y_dims)
z_dim = max(z_dims)
c_dim = max(c_dims)
t_dim = max(t_dims)
print '\t series: %i' % series
print '\t format: %s' % format
print '\t dimension order: %s' % order
print '\t x: %s -> %i' % (x_dims, x_dim)
print '\t y: %s -> %i' % (y_dims, y_dim)
print '\t z: %s -> %i' % (z_dims, z_dim)
print '\t c: %s -> %i' % (c_dims, c_dim)
print '\t t: %s -> %i' % (t_dims, t_dim)
print '\t effective size c: %s' % eff
print '\t samples per pixel: %s' % spp
# Get the time dimension from the number of input files
t_dim = len(image_paths)
# TODO: Tried to work out the order with Axes class, got something weird though.
dimensions = [Short(x_dim), Short(y_dim), Short(c_dim), Short(z_dim)]
pixels_per_plane = x_dim * y_dim
# Assemble the metadata for the output file
out_meta = MetadataTools.createOMEXMLMetadata()
out_meta.setImageID(MetadataTools.createLSID('Image', series), series)
out_meta.setPixelsID(MetadataTools.createLSID('Pixels', series), series)
out_meta.setPixelsBinDataBigEndian(Boolean.TRUE, 0, 0)
out_meta.setPixelsDimensionOrder(DimensionOrder.fromString(order), series)
out_meta.setPixelsType(PixelType.fromString(format), series)
out_meta.setPixelsSizeX(PositiveInteger(x_dim), series)
out_meta.setPixelsSizeY(PositiveInteger(y_dim), series)
out_meta.setPixelsSizeZ(PositiveInteger(z_dim), series)
out_meta.setPixelsSizeC(PositiveInteger(c_dim), series)
out_meta.setPixelsSizeT(PositiveInteger(t_dim), series)
for c in range(c_dim):
out_meta.setChannelID(MetadataTools.createLSID('Channel', series, c),
series, c)
out_meta.setChannelSamplesPerPixel(PositiveInteger(1), series, c)
# Initialize the BF writer
result_path = os.path.join(result_dir.getPath(), result_name)
writer = ImageWriter()
writer.setMetadataRetrieve(out_meta)
writer.setId(result_path)
print '\tcreated to %s' % (result_path)
# Write the stacks into the output file
N = len(image_paths)
for i, image_path in enumerate(image_paths):
status.showStatus(i, N, "catenating %i of %i time-points" % (i, N))
print '\t processing %s' % (image_path)
ds = io.open(image_path)
xi = ds.dimensionIndex(Axes.X)
xv = ds.dimension(xi)
yi = ds.dimensionIndex(Axes.Y)
yv = ds.dimension(yi)
zi = ds.dimensionIndex(Axes.Z)
zv = ds.dimension(zi)
ti = ds.dimensionIndex(Axes.TIME)
tv = ds.dimension(ti)
ci = ds.dimensionIndex(Axes.CHANNEL)
cv = ds.dimension(ci)
dx = float(x_dim - xv) / 2.0
dy = float(y_dim - yv) / 2.0
dz = float(z_dim - zv) / 2.0
print '\t translation vector (dx, dy, dz) = (%f, %f, %f)' % (
dx, dy, dz)
if (dx != 0) or (dy != 0) or (dz != 0):
stk = Views.translate(ds, long(dx), long(dy), long(0), long(dz))
stk = Views.extendZero(stk)
else:
stk = Views.extendZero(ds.getImgPlus().getImg())
print '\t writing planes ',
n = 0
plane = 1
byte_array = []
interval_view = Views.interval(stk, \
[Long(0), Long(0), Long(0), Long(0)], \
[Long(x_dim - 1), Long(y_dim - 1), Long(c_dim - 1), Long(z_dim - 1)])
cursor = interval_view.cursor()
while cursor.hasNext():
n += 1
cursor.fwd()
value = cursor.get().getInteger()
bytes = DataTools.shortToBytes(value, big_endian)
byte_array.extend(bytes)
if n == pixels_per_plane:
writer.saveBytes(plane - 1, byte_array)
print '.',
if ((plane) % 10) == 0:
print '\n\t ',
byte_array = []
plane += 1
n = 0
print ' '
writer.close()
t = datetime.now() - t_start
print '\twrote %i planes to %s in %i sec.' % (plane - 1, result_path,
t.total_seconds())
print '... done.'
from net.imglib2.img.display.imagej import ImageJFunctions as IL
from net.imglib2.img.array import ArrayImgs
from net.imglib2.type.numeric.real import FloatType
from net.imglib2.view import Views
from net.imglib2.util import Intervals
from ij import IJ
imp = IJ.getImage() # an 8-bit image
img = IL.wrap(imp)
# Create the integral image of an 8-bit input, stored as 64-bit
target = ArrayImgs.unsignedLongs(Intervals.dimensionsAsLongArray(img))
# Copy input onto the target image
compute(img).into(target)
# Extend target with zeros, so that we can read at coordinate -1
imgE = Views.extendZero(target)
# Integrate every dimension, cummulatively by writing into
# a target image that is also the input
for d in xrange(img.numDimensions()):
coord = [0] * img.numDimensions() # array of zeros
coord[d] = -1
# Cummulative sum along the current dimension
# Note that instead of the ImgMath offset op,
# we could have used Views.translate(Views.extendZero(target), [1, 0]))
# (Notice though the sign change in the translation)
integral = add(target, offset(imgE, coord))
compute(integral).into(target)
# The target is the integral image
integralImg = target
width = img.dimension(0) # same as imp.getWidth()
height = img.dimension(1) # same as imp.getHeight()
# from half an image beyond 0,0 (to the left and up) to half an image beyond width,height
imgExtended = Views.interval(extendedView, [-width / 2, -height / 2],
[width + width / 2 - 1, height + height / 2 - 1
]) # RandomAccessibleInterval
IL.show(imgExtended, "enlarged canvas with extended mirror symmetry")
# The viewing interval doesn't have to overlap with the interval where the original image is defined
# For example:
imgSomewhere = Views.interval(extendedView, [41000, 60000], [42000, 61000])
IL.show(imgSomewhere, "Arbitrary interval somewhere")
# Other forms of extended views:
extendedEmptyView = Views.extendZero(img)
extendedValueView = Views.extendValue(img, 50)
# Find out the pixel type and its min and max values
t = img.randomAccess().get()
min_value = t.getMinValue() # minimum value for the pixel type
max_value = t.getMaxValue() # maximum
extendedRandomView = Views.extendRandom(img, min_value, max_value)
imgExtRandom = Views.interval(extendedRandomView, [-width / 2, -height / 2],
[width + width / 2, height + height / 2])
IL.show(imgExtRandom, "extended with random noise")
# 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 maxCoords(img):
return [
int(img.dimension(d) * calibration[d] - 1)
for d in xrange(img.numDimensions())
]
# Identity transform for CM00, scaled to isotropy
affine0 = AffineTransform3D()
affine0.identity()
affine0.concatenate(scale3D)
# Expand camera CM00 to isotropy
imgE = Views.extendZero(img0)
imgI = Views.interpolate(imgE, NLinearInterpolatorFactory())
imgT = RealViews.transform(imgI, affine0)
imgB0 = Views.interval(imgT, [0, 0, 0], maxCoords(img0))
# Transform camera CM01 to CM00: 180 degrees on Y axis, plus a translation in X
affine1 = AffineTransform3D()
affine1.set(-1.0, 0.0, 0.0, img1.dimension(0), 0.0, 1.0, 0.0, 0.0, 0.0, 0.0,
1.0, 0.0)
affine1.concatenate(scale3D)
imgE = Views.extendZero(img1)
imgI = Views.interpolate(imgE, NLinearInterpolatorFactory())
imgT = RealViews.transform(imgI, affine1)
imgB1 = Views.interval(imgT, [0, 0, 0], maxCoords(img1))
# Transform camera CM02 to CM00: 90 degrees on Y axis, plus a translation in Z
ReadOnlyCachedCellImgOptions.options().volatileAccesses(
True).cellDimensions(cell_dimensions))
# View the image as an ImageJ ImagePlus with an underlying VirtualStack
IL.wrap(cachedCellImg, "sections").show()
# Now show a UI that enables moving a window around a data set
from net.imglib2.view import Views
from net.imglib2 import FinalInterval
from jarray import array
from java.awt.event import KeyAdapter, KeyEvent
from net.imglib2.img.display.imagej import ImageJVirtualStack
mins = array([1307, 448, 0], 'l')
maxs = array([1307 + 976 - 1, 448 + 732 - 1, len(filepaths) - 1], 'l')
imgE = Views.extendZero(cachedCellImg)
crop = Views.interval(imgE, FinalInterval(mins, maxs))
imp = IL.wrap(crop, "sections crop") # ImagePlus
imp.show()
# Once shown, a reference to the ij.gui.ImageWindow exists
win = imp.getWindow()
# Remove and store key listeners from the ImageCanvas
kls = win.getCanvas().getKeyListeners()
for kl in kls:
win.getCanvas().removeKeyListener(kl)
stack = imp.getStack(
) # an net.imglib2.img.display.imagej.ImageJVirtualStackUnsignedByte
fsource = ImageJVirtualStack.getDeclaredField("source")
interval2 = FinalInterval([
int(img1.dimension(0) * scale),
int(img1.dimension(1) * scale),
img1.dimension(2)
])
# Interval of a single stack slice of the target image
sliceInterval = FinalInterval([interval2.dimension(0), interval2.dimension(1)])
slices2 = []
for index in xrange(img1.dimension(2)):
# One single 2D RGB slice
imgSlice1 = Views.hyperSlice(img1, 2, index)
# Views of the 3 color channels, as extended and interpolatable
channels = [
Views.interpolate(
Views.extendZero(Converters.argbChannel(imgSlice1, i)),
NLinearInterpolatorFactory()) for i in [1, 2, 3]
]
# ARGBType 2D view of the transformed color channels
imgSlice2 = Converters.mergeARGB(
Views.stack(
Views.interval(RealViews.transform(channel, transform),
sliceInterval)
for channel in channels), ColorChannelOrder.RGB)
slices2.append(imgSlice2)
# Transformed view
viewImg2 = Views.stack(slices2)
# Materialized image
img2 = ArrayImgs.argbs(Intervals.dimensionsAsLongArray(interval2))
ImgUtil.copy(viewImg2, img2)
from ij import IJ from net.imglib2.view import Views from net.imglib2.interpolation.randomaccess import NLinearInterpolatorFactory from net.imglib2.util import Intervals from math import radians, floor, ceil from jarray import zeros from pprint import pprint # Load an image (of any dimensions) imp = IJ.getImage() # Access its pixel data as an ImgLib2 RandomAccessibleInterval img = IL.wrapReal(imp) # View as an infinite image, with value zero beyond the image edges imgE = Views.extendZero(img) # View the pixel data as a RealRandomAccessible # (that is, accessible with sub-pixel precision) # by using an interpolator imgR = Views.interpolate(imgE, NLinearInterpolatorFactory()) # Define a rotation by +30 degrees relative to the image center in the XY axes angle = radians(30) toCenter = AffineTransform3D() cx = img.dimension(0) / 2.0 # X axis cy = img.dimension(1) / 2.0 # Y axis toCenter.setTranslation(-cx, -cy, 0.0) # no translation in the Z axis rotation = AffineTransform3D() # Step 1: place origin of rotation at the center of the image rotation.preConcatenate(toCenter)
from ij import IJ
from net.imglib2.img.display.imagej import ImageJFunctions as IJF
from net.imglib2.view import Views
from jarray import zeros
from net.imglib2 import FinalInterval
imp = IJ.getImage()
image = IJF.wrap(imp)
min = zeros(image.numDimensions(), 'l')
max = zeros(image.numDimensions(), 'l')
min[image.numDimensions() - 1] = 0
max[image.numDimensions() - 1] = image.dimension(image.numDimensions() - 1) - 1
min[image.numDimensions() - 2] = 0
max[image.numDimensions() - 2] = image.dimension(image.numDimensions() - 2) - 1
for d in range(0, image.numDimensions() - 2):
min[d] = -10
max[d] = image.dimension(d) + 10
interval = FinalInterval(min, max)
print(interval)
infinite = Views.extendZero(image)
IJF.show(Views.interval(infinite, interval))