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 readUnsignedShorts(path, dimensions, header=0, return_array=False, byte_order=ByteOrder.LITTLE_ENDIAN): """ Read a file as an ArrayImg of UnsignedShortType """ size = reduce(operator.mul, dimensions) ra = RandomAccessFile(path, 'r') try: if header < 0: # Interpret from the end: useful for files with variable header lengths # such as some types of uncompressed TIFF formats header = ra.length() + header ra.skipBytes(header) bytes = zeros(size * 2, 'b') ra.read(bytes) shorts = zeros(size, 'h') # h is for short ByteBuffer.wrap(bytes).order(byte_order).asShortBuffer().get(shorts) return shorts if return_array else ArrayImgs.unsignedShorts(shorts, dimensions) finally: ra.close()
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 projectLastDimension(img, showEarly=False): """ Project the last dimension, e.g. a 4D image becomes a 3D image, using the provided reducing function (e.g. min, max, sum). """ last_dimension = img.numDimensions() - 1 # The collapsed image imgC = ArrayImgs.unsignedShorts( [img.dimension(d) for d in xrange(last_dimension)]) if showEarly: showStack( imgC, title="projected") # show it early, will be updated progressively if img.dimension(last_dimension) > 10: # one by one print "One by one" for i in xrange(img.dimension(last_dimension)): print i compute(maximum(imgC, Views.hyperSlice(img, last_dimension, i))).into(imgC) else: # Each sample of img3DV is a virtual vector over all time frames at that 3D coordinate: imgV = Views.collapseReal(img) # Reduce each vector to a single scalar, using a Converter # The Converter class reduce_max = makeCompositeToRealConverter( reducer_class=Math, reducer_method="max", reducer_method_signature="(DD)D") img3DC = convert(imgV, reduce_max.newInstance(), img.randomAccess().get().getClass()) ImgUtil.copy(ImgView.wrap(imgV, img.factory()), imgC) return imgC
def getPixels(self, n): # 'n' is 1-based # Target 2D array img to copy data into aimg = ArrayImgs.unsignedShorts(self.dimensions[0:2]) # The number of slices of the 3D volume of a single timepoint nZ = self.img4d.dimension(2) # The slice_index if there was a single channel slice_index = int((n - 1) / 2) # 0-based, of the whole 4D series local_slice_index = slice_index % nZ # 0-based, of the timepoint 3D volume timepoint_index = int(slice_index / nZ) # Z blocks if 1 == n % 2: # Odd slice index: image channel fixedT = Views.hyperSlice(self.img4d, 3, timepoint_index) fixedZ = Views.hyperSlice(fixedT, 2, local_slice_index) w.copy(fixedZ.cursor(), aimg.cursor()) else: # Even slice index: spheres channel sd = SpheresData(self.kdtrees[timepoint_index], radius, inside, outside) volume = Views.interval(Views.raster(sd), self.dimensions3d) plane = Views.hyperSlice(volume, 2, local_slice_index) w.copy(plane.cursor(), aimg.cursor()) # return aimg.update(None).getCurrentStorageArray()
from random import random from net.imglib2.algorithm.math import ImgMath from net.imglib2.util import ImgUtil from net.imglib2.img import ImgView import sys sys.path.append("/home/albert/lab/scripts/python/imagej/IsoView-GCaMP/") from lib.util import timeit roi = ( [1, 228, 0], # top-left coordinates [1 + 406 - 1, 228 + 465 - 1, 0 + 325 - 1]) # bottom-right coordinates (inclusive, hence the -1) dimensions = [maxC - minC + 1 for minC, maxC in zip(roi[0], roi[1])] imgU = ArrayImgs.unsignedShorts(dimensions) imgF = ArrayImgs.floats(dimensions) #c = imgF.cursor() #while c.hasNext(): # c.next().set(random() * 65535) ImgMath.compute(ImgMath.number(17)).into(imgF) ImgMath.compute(ImgMath.img(imgF)).into(imgU) aff = AffineTransform3D() """ aff.set(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0) """ aff.set(*[ 0.9999949529841275, -0.0031770224721305684, 2.3118912942710207e-05, -1.6032353998500826, 0.003177032139125933, 0.999994860398559,
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 IL.wrap(img1, "cube").show() IL.wrap(img2, "cube rotated").show() # Now register them # IMPORTANT PARAMETERS raw_calibration = [1.0, 1.0, 1.0] # micrometers per pixel
# 2022 I2K example # Albert Cardona 2022 # Create an ImgLib2 ArrayImg # 1. With ArrayImgs: trivial from net.imglib2.img.array import ArrayImgs img = ArrayImgs.unsignedShorts([512, 512]) # Or reusing the pixel array from e.g., an open ImageJ image: from net.imglib2.img.array import ArrayImgs from ij import IJ from ij.process import ShortProcessor imp = IJ.getImage() # most recently activated ImageJ image window ip = imp.getProcessor() if isinstance(ip, ShortProcessor): width, height = imp.getWidth(), imp.getHeight() pixelsU16 = ip.getPixels() img = ArrayImgs.unsignedShorts(pixelsU16, [width, height]) # Or creating a new pixel array from scratch from net.imglib2.img.array import ArrayImgs from jarray import zeros pixelsU16 = zeros(512 * 512, 'h') # 'h' means short[] img = ArrayImgs.unsignedShorts(pixelsU16, [512, 512]) # 2. With ArrayImgFactory: unnecessary, use ArrayImgs from net.imglib2.img.array import ArrayImgFactory from net.imglib2.type.numeric.integer import UnsignedShortType
def maxProjectLastDimension(img, strategy="1by1", chunk_size=0): last_dimension = img.numDimensions() -1 if "1by1" == strategy: exe = newFixedThreadPool() try: n_threads = exe.getCorePoolSize() imgTs = [ArrayImgs.unsignedShorts(list(Intervals.dimensionsAsLongArray(img))[:-1]) for i in xrange(n_threads)] def mergeMax(img1, img2, imgT): return compute(maximum(img1, img2)).into(imgT) def hyperSlice(index): return Views.hyperSlice(img, last_dimension, index) # The first n_threads mergeMax: futures = [exe.submit(Task(mergeMax, hyperSlice(i*2), hyperSlice(i*2 +1), imgTs[i])) for i in xrange(n_threads)] # As soon as one finishes, merge it with the next available hyperSlice next = n_threads while len(futures) > 0: # i.e. not empty imgT = futures.pop(0).get() if next < img.dimension(last_dimension): futures.append(exe.submit(Task(mergeMax, imgT, hyperSlice(next), imgT))) next += 1 else: # Run out of hyperSlices to merge if 0 == len(futures): return imgT # done # Merge imgT to each other until none remain futures.append(exe.submit(Task(mergeMax, imgT, futures.pop(0).get(), imgT))) finally: exe.shutdownNow() else: # By chunks imglibtype = img.randomAccess().get().getClass() # The Converter class reduce_max = makeCompositeToRealConverter(reducer_class=Math, reducer_method="max", reducer_method_signature="(DD)D") if chunk_size > 0: # map reduce approach exe = newFixedThreadPool() try: def projectMax(img, minC, maxC, reduce_max): imgA = ArrayImgs.unsignedSorts(Intervals.dimensionsAsLongArray(imgC)) ImgUtil.copy(ImgView.wrap(convert(Views.collapseReal(Views.interval(img, minC, maxC)), reduce_max.newInstance(), imglibtype), img.factory()), imgA) return imgA # The min and max coordinates of all dimensions except the last one minCS = [0 for d in xrange(last_dimension)] maxCS = [img.dimension(d) -1 for d in xrange(last_dimension)] # Process every chunk in parallel futures = [exe.submit(Task(projectMax, img, minCS + [offset], maxCS + [min(offset + chunk_size, img.dimension(last_dimension)) -1])) for offset in xrange(0, img.dimension(last_dimension), chunk_size)] return reduce(lambda f1, f2: compute(maximum(f1.get(), f2.get())).into(f1.get(), futures)) finally: exe.shutdownNow() else: # One chunk: all at once # Each sample of img3DV is a virtual vector over all time frames at that 3D coordinate # Reduce each vector to a single scalar, using a Converter img3DC = convert(Views.collapseReal(img), reduce_max.newInstance(), imglibtype) imgA = ArrayImgs.unsignedShorts([img.dimension(d) for d in xrange(last_dimension)]) ImgUtil.copy(ImgView.wrap(imgV, img.factory()), imgA) return imgA
from net.imglib2.type.numeric.real import FloatType from net.imglib2.view import Views imp = IJ.getImage() dimensions = [imp.getWidth(), imp.getHeight()] ip = imp.getProcessor() pixels = ip.getPixels() # In practice, you never want to do this below, # and instead you'd use the built-in wrapper: ImageJFunctions.wrap(imp) # This is merely for illustration of how to use ArrayImgs with an existing pixel array if isinstance(ip, ByteProcessor): img1 = ArrayImgs.unsignedBytes(pixels, dimensions) elif isinstance(ip, ShortProcessor): img1 = ArrayImgs.unsignedShorts(pixels, dimensions) elif isinstance(ip, FloatProcessor): img1 = ArrayImgs.floats(pixels, dimensions) else: print "Can't handle image of type:", type(ip).getName() # An empty image of float[] img2 = ArrayImgs.floats(dimensions) # View it as RandomAccessibleInterval<FloatType> by converting on the fly # using a generic RealType to FloatType converter floatView = Converters.convertRAI(img1, RealFloatConverter(), FloatType()) # The above 'floatView' can be used as an image: one that gets always converted on demand. # If you only have to iterate over the pixels just once, there's no need to create a new image.
def loadUnsignedShort(filepath): imp = loadImp(filepath) return ArrayImgs.unsignedShorts( imp.getProcessor().getPixels(), [imp.getWidth(), imp.getHeight()])
def asArrayImg(img1): dimensions1 = [img1.dimension(d) for d in xrange(img1.numDimensions())] img2 = ArrayImgs.unsignedShorts(dimensions1) ImgMath.compute(ImgSource(img1)).into(img2) return img2
def loadUnsignedShort(filepath): imp = loadImp(filepath) # an instance of an ij.ImagePlus return ArrayImgs.unsignedShorts( imp.getProcessor().getPixels(), [imp.getWidth(), imp.getHeight()])