def test(iraf):
# Test dimensions: should be the same as the one input image
print "Dimensions:", Intervals.dimensionsAsLongArray(iraf)
# Test Cursor
c = iraf.cursor()
pos = zeros(2, 'l')
while c.hasNext():
c.fwd()
c.localize(pos)
print "Cursor:", pos, "::", c.get()
# Test RandomAccess
ra = iraf.randomAccess()
c = iraf.cursor()
while c.hasNext():
c.fwd()
ra.setPosition(c)
c.localize(pos)
print "RandomAccess:", pos, "::", ra.get()
# Test source img: should be untouched
c = img.cursor()
while c.hasNext():
print "source:", c.next()
# Test interval view: the middle 2x2 square
v = Views.interval(iraf, [1, 1], [2, 2])
IL.wrap(v, "+2 view").show()
def openImage():
print rel_path
if rel_path.endswith(".klb"):
try:
klb = KLB.newInstance()
img = klb.readFull(os.path.join(base_path, rel_path))
IL.wrap(img, rel_path).show()
except:
print sys.exc_info()
else:
print "via IJ.open"
IJ.open(os.path.join(base_path, rel_path))
def openImage():
print rel_path
if rel_path.endswith(".klb"):
if (KLB == None):
print "Cannot open KLB due to missing module"
try:
klb = KLB.newInstance()
img = klb.readFull(os.path.join(base_path, rel_path))
IL.wrap(img, rel_path).show()
except:
print sys.exc_info()
else:
print "via IJ.open"
IJ.open(os.path.join(base_path, rel_path))
def showAsComposite(images, title="Composite", show=True):
imps = []
# Collect all images as ImagePlus, checking that they have the same XY dimensions.
# (Z doesn't matter)
dimensions = None
for img in images:
if isinstance(img, ImagePlus):
imps.append(img)
else:
imps.append(IL.wrap(img, ""))
if not dimensions:
dimensions = [imps[-1].getWidth(), imps[-1].getHeight()]
else:
if imps[-1].width != dimensions[0] or imps[-1].getHeight(
) != dimensions[1]:
print "asComposite: dimensions mistach."
return
imp = ImagePlus(title, StacksAsChannels([imp.getStack() for imp in imps]))
imp.setDimensions(len(imps), max(imp.getStack().getSize() for imp in imps),
1)
comp = CompositeImage(imp, CompositeImage.COMPOSITE)
if show:
comp.show()
print imp.getNChannels(), imp.getNSlices(), imp.getNFrames(
), "but imps: ", len(imps)
return comp
def __init__(self, imp, cell_padding, padding_color_value, grid):
self.stack = imp.getStack()
self.grid = grid
self.cell_padding = cell_padding
self.t = IL.wrap(imp).randomAccess().get().createVariable()
self.t.setReal(padding_color_value)
self.cache = {}
def create(self, index):
cell_dimensions = [
self.grid.cellDimension(0),
self.grid.cellDimension(1)
]
n_cols = grid.imgDimension(0) / cell_dimensions[0]
x0 = (index % n_cols) * cell_dimensions[0]
y0 = (index / n_cols) * cell_dimensions[1]
index += 1 # 1-based slice indices in ij.ImageStack
if index < 1 or index > self.stack.size():
# Return blank image: a ByteAccess that always returns 255
return Cell(
cell_dimensions, [x0, y0],
type('ConstantValue', (ByteAccess, ), {
'getValue': lambda self, index: 255
})())
else:
# ImageJ stack slice indices are 1-based
img = IL.wrap(ImagePlus("", self.stack.getProcessor(index)))
# Create extended image with the padding color value
imgE = Views.extendValue(img, self.t.copy())
# A view that includes the padding between slices
minC = [-self.cell_padding for d in xrange(img.numDimensions())]
maxC = [
img.dimension(d) - 1 + self.cell_padding
for d in xrange(img.numDimensions())
]
imgP = Views.interval(imgE, minC, maxC)
return Cell(cell_dimensions, [x0, y0],
ProxyByteAccess(imgP, self.grid))
def combine(op, title, *ops): edges_img = img.factory().imgFactory(FloatType()).create(img) compute(op(*ops)).into(edges_img) imp = IL.wrap(edges_img, title) imp.getProcessor().resetMinAndMax() imp.show() return imp
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 main():
img = IJF.wrap(imp)
img_out = smooth_temporal_gradient(ops, img, sigma_xy, sigma_t,
frame_start, frame_end,
normalize_output)
img_out.setCalibration(imp.getCalibration().copy())
comp = CompositeImage(img_out, CompositeImage.COMPOSITE)
comp.show()
def oneStep(index=0):
# Combining transforms into one, via a translation to account of the ROI crop
img = klb.readFull(filepaths[index]) # klb_loader.get(filepaths[index])
t1 = cmIsotropicTransforms[index]
t2 = affine3D(
[1, 0, 0, -roi[0][0], 0, 1, 0, -roi[0][1], 0, 0, 1, -roi[0][2]])
t3 = affine3D(fineTransformsPostROICrop[index]).inverse()
aff = AffineTransform3D()
aff.set(t1)
aff.preConcatenate(t2)
aff.preConcatenate(t3)
# Final interval is now rooted at 0,0,0 given that the transform includes the translation
imgP = prepareImgForDeconvolution(
img, aff,
FinalInterval([0, 0, 0],
[maxC - minC for minC, maxC in izip(roi[0], roi[1])]))
# 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, "one step index %i" % index).show()
def showStack(img, title="", proper=True, n_channels=1):
# IL.wrap fails: shows slices as channels, and channels as frames
if not proper:
imp = IL.wrap(img, title)
imp.show()
return imp
# Proper sorting of slices, channels and frames
imp = wrap(img, title=title, n_channels=n_channels)
comp = CompositeImage(
imp,
CompositeImage.GRAYSCALE if 1 == n_channels else CompositeImage.COLOR)
comp.show()
return comp
def writeZip(img, path, title=""):
if isinstance(img, RandomAccessibleInterval):
imp = IL.wrap(img, title)
elif isinstance(img, ImagePlus):
imp = img
if title:
imp.setTitle(title)
else:
syncPrint("Cannot writeZip to %s:\n Unsupported image type %s" % (path, str(type(img))))
return None
#
FileSaver(imp).saveAsZip(path)
return imp
def getMIP(imp): if isinstance(imp,ImagePlus): im = ImageJFunctions.wrap(imp) else: im = imp projected = ops.create().img([ im.dimension(d) for d in [0,1] ]) # Create the op and run it proj_op = ops.op(getattr(Ops.Stats, "Max"), im) ops.transform().project(projected, im, proj_op, 2) return projected
def maskFromOverlay(imp):
''' TODO Documentation '''
overlay = imp.getOverlay();
img = ImageJFunctions.wrap(imp);
emptyImg = ops.create().img(img);
if overlay is None:
return emptyImg;
emptyImp = ImageJFunctions.wrap(emptyImg, "mask");
for roi in overlay.toArray():
imp.setRoi(roi);
IJ.run(imp, "Create Mask", "");
manualMaskImp = IJ.getImage();
ic = ImageCalculator();
ic.run("OR", emptyImp, manualMaskImp);
manualMask = ImageJFunctions.wrap(manualMaskImp);
manualMaskImp.close();
#imp.setRoi(None);
return manualMask;
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 main():
files = []
for filt in img_extensions.split(";"):
if len(filt.strip()) > 0:
files += glob.glob(os.path.join(str(input_dir), filt.strip()))
else:
files += glob.glob(os.path.join(str(input_dir), "*.*"))
break
if len(files) == 0:
IJ.showMessage("No files found in '{}'\nfor extensions '{}'".format(
str(input_dir), img_extensions))
else:
for fn in files:
try:
imp = BF.openImagePlus(fn)[0]
except:
IJ.showMessage(
"Could not open file '{}' (skipping).\nUse extension filter to filter non-image files..."
.format(str(fn)))
continue
img = IJF.wrap(imp)
cali = imp.getCalibration().copy()
if pixel_width > 0:
cali.pixelWidth = pixel_width
cali.pixelHeight = pixel_width
cali.setUnit("micron")
if frame_interval > 0:
cali.frameInterval = frame_interval
cali.setTimeUnit("sec.")
imp_out = smooth_temporal_gradient(ops, img, sigma_xy, sigma_t,
frame_start, frame_end,
normalize_output)
imp_out.setCalibration(cali)
channels = ChannelSplitter.split(imp_out)
fn_basename = os.path.splitext(fn)[0]
IJ.save(channels[0], "{}_shrinkage.tiff".format(fn_basename))
IJ.save(channels[1], "{}_growth.tiff".format(fn_basename))
print("{} processed".format(fn_basename))
IJ.showMessage(
"Growth/shrinkage extraction of {} inputs finsihed.".format(
len(files)))
def wrap(img, title="", n_channels=1):
""" Like ImageJFunctions.wrap but, when n_channels=1 (the default),
then a new dimension of size 1 is inserted at position 2 to prevent the Z axis
from showing as the channels axis.
To enable ImageJFunctions.wrap default behavior, set n_channels to a value other than 1. """
if 1 == n_channels:
# Append a dimension of size 1 at the end
# and permute it iteratively so that it becomes the channels dimension (d=2)
img = Views.addDimension(img, 1, 1)
d = img.numDimensions(
) - 1 # starts with the last: the new one of size 1
while d > 2:
img = Views.permute(img, d, d - 1)
d -= 1
#
return IL.wrap(img, title)
def SpotDetectionGray(gray, data, display, ops, invert):
# get the dimensions
dimensions2D = array([gray.dimension(0), gray.dimension(1)], 'l')
factory = gray.getImg().factory()
# wrap as ImagePlus
imp = ImageJFunctions.wrap(gray, "wrapped")
# create and call background subtractor
bgs = BackgroundSubtracter()
bgs.rollingBallBackground(imp.getProcessor(), 50.0, False, False, True,
True, True)
# wrap the result of background subtraction as Img and display it
iplus = ImagePlus("bgs", imp.getProcessor())
# if (invert==True):
# iplus.getProcessor().invert()
imgBgs = ImageJFunctions.wrapByte(iplus)
display.createDisplay("back_sub", data.create(ImgPlus(imgBgs)))
# convert the background subtracted image to 32 bit
temp = ops.run("createimg", factory, FloatType(), dimensions2D)
imgBgs32 = ImgPlus(temp)
ops.convert(imgBgs32, imgBgs, ConvertPixCopy())
#display.createDisplay("back_sub 32", data.create(ImgPlus(imgBgs32)))
# create the Laplacian of Gaussian filter
kernel = DetectionUtils.createLoGKernel(3.0, 2, array([1.0, 1.0], 'd'))
# apply the log filter and display the result
log = ImgPlus(ops.run("createimg", factory, FloatType(), dimensions2D))
ops.convolve(log, imgBgs32, kernel)
#display.createDisplay("log", data.create(ImgPlus(log)))
# apply the threshold operation
#thresholded=ops.run("threshold", ops.create( dimensions2D, BitType()), log, Triangle())
thresholded = ops.run("triangle", log)
return ImgPlus(thresholded)
def SpotDetectionGray(gray, data, display, ops, invert):
# get the dimensions
dimensions2D=array( [gray.dimension(0), gray.dimension(1)], 'l')
factory=gray.getImg().factory()
# wrap as ImagePlus
imp=ImageJFunctions.wrap(gray, "wrapped")
# create and call background subtractor
bgs=BackgroundSubtracter()
bgs.rollingBallBackground(imp.getProcessor(), 50.0, False, False, True, True, True)
# wrap the result of background subtraction as Img and display it
iplus=ImagePlus("bgs", imp.getProcessor())
# if (invert==True):
# iplus.getProcessor().invert()
imgBgs=ImageJFunctions.wrapByte(iplus)
display.createDisplay("back_sub", data.create(ImgPlus(imgBgs)))
# convert the background subtracted image to 32 bit
temp=ops.run( "createimg", factory, FloatType(), dimensions2D )
imgBgs32=ImgPlus( temp )
ops.convert(imgBgs32, imgBgs, ConvertPixCopy() )
#display.createDisplay("back_sub 32", data.create(ImgPlus(imgBgs32)))
# create the Laplacian of Gaussian filter
kernel = DetectionUtils.createLoGKernel( 3.0, 2, array([1.0, 1.0], 'd' ) )
# apply the log filter and display the result
log=ImgPlus( ops.run("createimg", factory, FloatType(), dimensions2D) )
ops.convolve(log, imgBgs32, kernel)
#display.createDisplay("log", data.create(ImgPlus(log)))
# apply the threshold operation
#thresholded=ops.run("threshold", ops.create( dimensions2D, BitType()), log, Triangle())
thresholded = ops.run("triangle", log)
return ImgPlus(thresholded)
from mpicbg.models import Point, PointMatch, InterpolatedAffineModel3D, AffineModel3D, RigidModel3D, NotEnoughDataPointsException
from collections import defaultdict
from operator import sub
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)
from net.imglib2.view import Views
from net.imglib2.img.array import ArrayImgs
from net.imglib2.util import Intervals, ImgUtil
from net.imglib2.algorithm.math.ImgMath import compute, maximum
from java.lang import Math
imp = IJ.getImage()
stack = imp.getStack()
# Grab the underlying ImgLib2 object, or wrap into one
if isinstance(stack, ImageJVirtualStack):
srcF = ImageJVirtualStack.getDeclaredField("source")
srcF.setAccessible(True)
img4D = srcF.get(stack)
else:
img4D = IL.wrap(imp)
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,
def poreDetectionUV(inputImp, inputDataset, inputRoi, ops, data, display, detectionParameters):
title = inputImp.getTitle()
title=title.replace('UV', 'SD')
print title
#trueColorImp= WindowManager.getImage(title)
#print type( trueColorImp)
# calculate are of roi
stats=inputImp.getStatistics()
inputRoiArea=stats.area
print inputRoi
# get the bounding box of the active roi
inputRec = inputRoi.getBounds()
x1=long(inputRec.getX())
y1=long(inputRec.getY())
x2=x1+long(inputRec.getWidth())-1
y2=y1+long(inputRec.getHeight())-1
print x1
print y1
print x2
print y2
# crop the roi
interval=FinalInterval( array([x1, y1 ,0], 'l'), array([x2, y2, 2], 'l') )
cropped=ops.crop(interval, None, inputDataset.getImgPlus() )
datacropped=data.create(cropped)
display.createDisplay("cropped", datacropped)
croppedPlus=IJ.getImage()
duplicator=Duplicator()
substackMaker=SubstackMaker()
# duplicate the roi
duplicate=duplicator.run(croppedPlus)
#duplicate.show()
# convert duplicate of roi to HSB and get brightness
IJ.run(duplicate, "HSB Stack", "");
brightnessPlus=substackMaker.makeSubstack(duplicate, "3-3")
brightness=ImgPlus(ImageJFunctions.wrapByte(brightnessPlus))
brightnessPlus.setTitle("Brightness")
#brightnessPlus.show()
# make another duplicate, split channels and get red
duplicate=duplicator.run(croppedPlus)
channels=ChannelSplitter().split(duplicate)
redPlus=channels[0]
red=ImgPlus(ImageJFunctions.wrapByte(redPlus))
redPlus.show()
# convert to lab
IJ.run(croppedPlus, "Color Transformer", "colour=Lab")
IJ.selectWindow('Lab')
labPlus=IJ.getImage()
# get the A channel
APlus=substackMaker.makeSubstack(labPlus, "2-2")
APlus.setTitle('A')
APlus.show()
APlus.getProcessor().resetMinAndMax()
APlus.updateAndDraw()
AThresholded=threshold(APlus, -10, 50)
# get the B channel
BPlus=substackMaker.makeSubstack(labPlus, "3-3")
BPlus.setTitle('B')
BPlus.show()
BPlus.getProcessor().resetMinAndMax()
BPlus.updateAndDraw()
BThresholded=threshold(BPlus, -10, 50)
# AND the Athreshold and Bthreshold to get a map of the red pixels
ic = ImageCalculator();
redMask = ic.run("AND create", AThresholded, BThresholded);
IJ.run(redMask, "Divide...", "value=255");
#redMask.show()
labPlus.close()
# threshold the spots from the red channel
thresholdedred=SpotDetectionGray(red, data, display, ops, False)
display.createDisplay("thresholdedred", data.create(thresholdedred))
impthresholdedred = ImageJFunctions.wrap(thresholdedred, "wrapped")
# threshold the spots from the brightness channel
thresholded=SpotDetectionGray(brightness, data, display, ops, False)
display.createDisplay("thresholded", data.create(thresholded))
impthresholded=ImageJFunctions.wrap(thresholded, "wrapped")
# or the thresholding results from red and brightness channel
impthresholded = ic.run("OR create", impthresholded, impthresholdedred);
# convert to mask
Prefs.blackBackground = True
IJ.run(impthresholded, "Convert to Mask", "")
# clear the region outside the roi
clone=inputRoi.clone()
clone.setLocation(0,0)
Utility.clearOutsideRoi(impthresholded, clone)
# create a hidden roi manager
roim = RoiManager(True)
# count the particlesimp.getProcessor().setColor(Color.green)
countParticles(impthresholded, roim, detectionParameters.minSize, detectionParameters.maxSize, detectionParameters.minCircularity, detectionParameters.maxCircularity)
# define a function to determine the percentage of pixels that are foreground in a binary image
# inputs:
# imp: binary image, 0=background, 1=foreground
# roi: an roi
def isRed(imp, roi):
stats = imp.getStatistics()
if (stats.mean>detectionParameters.redPercentage): return True
else: return False
def notRed(imp, roi):
stats = imp.getStatistics()
if (stats.mean>detectionParameters.redPercentage): return False
else: return True
allList=[]
for roi in roim.getRoisAsArray():
allList.append(roi.clone())
# count particles that are red
redList=CountParticles.filterParticlesWithFunction(redMask, allList, isRed)
# count particles that are red
blueList=CountParticles.filterParticlesWithFunction(redMask, allList, notRed)
print "Total particles: "+str(len(allList))
print "Filtered particles: "+str(len(redList))
# for each roi add the offset such that the roi is positioned in the correct location for the
# original image
[roi.setLocation(roi.getXBase()+x1, roi.getYBase()+y1) for roi in allList]
# create an overlay and add the rois
overlay1=Overlay()
inputRoi.setStrokeColor(Color.green)
overlay1.add(inputRoi)
[CountParticles.addParticleToOverlay(roi, overlay1, Color.red) for roi in redList]
[CountParticles.addParticleToOverlay(roi, overlay1, Color.cyan) for roi in blueList]
def drawAllRoisOnImage(imp, mainRoi, redList, blueList):
imp.getProcessor().setColor(Color.green)
IJ.run(imp, "Line Width...", "line=3");
imp.getProcessor().draw(inputRoi)
imp.updateAndDraw()
IJ.run(imp, "Line Width...", "line=1");
[CountParticles.drawParticleOnImage(imp, roi, Color.magenta) for roi in redList]
[CountParticles.drawParticleOnImage(imp, roi, Color.green) for roi in blueList]
imp.updateAndDraw()
drawAllRoisOnImage(inputImp, inputRoi, redList, blueList)
#drawAllRoisOnImage(trueColorImp, inputRoi, redList, blueList)
# draw overlay
#inputImp.setOverlay(overlay1)
#inputImp.updateAndDraw()
statsdict=CountParticles.calculateParticleStats(APlus, BPlus, redMask, roim.getRoisAsArray())
print inputRoiArea
areas=statsdict['Areas']
poreArea=0
for area in areas:
poreArea=poreArea+area
ATotal=0
ALevels=statsdict['ALevel']
for A in ALevels:
ATotal=ATotal+A
AAverage=ATotal/len(ALevels)
BTotal=0
BLevels=statsdict['BLevel']
for B in BLevels:
BTotal=BTotal+B
BAverage=BTotal/len(BLevels)
redTotal=0
redPercentages=statsdict['redPercentage']
for red in redPercentages:
redTotal=redTotal+red
redAverage=redTotal/len(redPercentages)
pixwidth=inputImp.getCalibration().pixelWidth
inputRoiArea=inputRoiArea/(pixwidth*pixwidth)
print str(len(allList))+" "+str(len(redList))+" "+str(len(blueList))+" "+str(poreArea/inputRoiArea)+" "+str(redAverage)
display.createDisplay("red", data.create(red))
display.createDisplay("green", data.create(green))
red32=ImgPlus( ops.create( dimensions2D, FloatType()) )
ops.convert(red32, red, ConvertPixCopy() )
green32=ImgPlus( ops.create( dimensions2D, FloatType()) )
ops.convert(green32, green, ConvertPixCopy() )
redgreen= ops.add(red32,green32)
display.createDisplay("redgreen", data.create(redgreen))
# make a copy of the red + green image
copy=redgreen.copy()
# wrap as ImagePlus
imp=ImageJFunctions.wrap(copy, "wrapped")
# create and call background subtractor
bgs=BackgroundSubtracter()
bgs.rollingBallBackground(imp.getProcessor(), 50.0, False, False, True, True, True)
# wrap as Img and display
iplus=ImagePlus("bgs", imp.getProcessor())
print type(imp)
imgBgs=ImageJFunctions.wrapFloat(iplus)
display.createDisplay("back_sub", data.create(ImgPlus(imgBgs)))
kernel = DetectionUtils.createLoGKernel( 3.0, 2, array([1.0, 1.0], 'd' ) )
print type(kernel)
print type(imgBgs)
# Read out single channels
red = Converters.argbChannel(img, 1)
green = Converters.argbChannel(img, 2)
blue = Converters.argbChannel(img, 3)
# Create an empty image of type FloatType (floating-point values)
# Here, the img is used to read out the interval: the dimensions for the new image
brightness = ArrayImgFactory(FloatType()).create(img)
# Compute the brightness: pick the maximum intensity pixel of every channel
# and then normalize it by dividing by the number of channels
compute(div(maximum([red, green, blue]), 255.0)).into(brightness)
# Show the brightness image
impB = IL.wrap(brightness, imp.getTitle() + " brightness")
impB.show()
# Compute now the image color saturation
saturation = ArrayImgFactory(FloatType()).create(img)
compute(
let(
"red",
red, # store as directly readable variables (no dictionary lookups)
"green",
green, # so that only 3 cursors are needed instead of 6
"blue",
blue,
"max",
maximum([var("red"), var("green"),
var("blue")]),
from ij import IJ
from net.imglib2.algorithm.math.ImgMath import compute, maximum, minimum, log, exp, div, mul
from net.imglib2.algorithm.math import Print
from net.imglib2.converter import Converters, ColorChannelOrder
from net.imglib2.img.array import ArrayImgs
from net.imglib2.img.display.imagej import ImageJFunctions as IL
from net.imglib2.view import Views
# Fetch an RGB image stack
imp_rgb = IJ.getImage(
) # IJ.openImage("http://imagej.nih.gov/ij/images/flybrain.zip")
img = IL.wrap(imp_rgb) # an ARGBType Img
# Color channel views
red, green, blue = (Converters.argbChannel(img, c) for c in [1, 2, 3])
# ImgLib1 scripting gamma function
# return Min(255, Max(0, Multiply(Exp(Multiply(gamma, Log(Divide(channel, 255)))), 255)))
gamma = 0.5
def op(channel):
return minimum(
255, maximum(0, mul(exp(mul(gamma, log(div(channel, 255)))), 255)))
img_gamma = Converters.mergeARGB(
Views.stack(
op(red).viewDouble(),
op(green).viewDouble(),
#@ OpService ops #@ ImgPlus inputData #@ Double sigma #@OUTPUT ImgPlus logFiltered #@OUTPUT ImgPlus thresholded # Run this tutorial using the C0Z12 image generated in the 'Crop Confocal Series' tutorial. # To generate the C0Z12 image, do the following: # Go to 'file>Open Samples>Confocal Series' and make sure confocal-series.tif is the active image and # run the Crop Confocal Series tutorial. from net.imglib2.img.display.imagej import ImageJFunctions from ij import IJ # create a log kernel logKernel = ops.create().kernelLog(inputData.numDimensions(), sigma) logFiltered = ops.filter().convolve(inputData, logKernel) # otsu threshold and display thresholded = ops.threshold().otsu(logFiltered) # convert to imagej1 imageplus so we can run analyze particles impThresholded = ImageJFunctions.wrap(thresholded, "wrapped") # convert to mask and analyze particles IJ.run(impThresholded, "Convert to Mask", "") IJ.run(impThresholded, "Analyze Particles...", "display add")
def poreDetectionUV(inputImp, inputDataset, inputRoi, ops, data, display, detectionParameters):
# set calibration
detectionParameters.setCalibration(inputImp);
# calculate area of roi
stats=inputImp.getStatistics()
inputRoiArea=stats.area
# get the bounding box of the active roi
inputRec = inputRoi.getBounds()
x1=long(inputRec.getX())
y1=long(inputRec.getY())
x2=x1+long(inputRec.getWidth())-1
y2=y1+long(inputRec.getHeight())-1
# crop the roi
interval=FinalInterval( array([x1, y1 ,0], 'l'), array([x2, y2, 2], 'l') )
#cropped=ops.image().crop(interval, None, inputDataset.getImgPlus() )
cropped=ops.image().crop(inputDataset.getImgPlus() , interval)
datacropped=data.create(cropped)
display.createDisplay("cropped", datacropped)
croppedPlus=IJ.getImage()
# instantiate the duplicator and the substackmaker classes
duplicator=Duplicator()
substackMaker=SubstackMaker()
# duplicate the roi
duplicate=duplicator.run(croppedPlus)
# convert duplicate of roi to HSB and get brightness
IJ.run(duplicate, "HSB Stack", "");
brightnessPlus=substackMaker.makeSubstack(duplicate, "3-3")
brightness=ImgPlus(ImageJFunctions.wrapByte(brightnessPlus))
brightnessPlus.setTitle("Brightness")
#brightnessPlus.show()
# make another duplicate, split channels and get red
duplicate=duplicator.run(croppedPlus)
channels=ChannelSplitter().split(duplicate)
redPlus=channels[0]
red=ImgPlus(ImageJFunctions.wrapByte(redPlus))
# convert to lab
IJ.run(croppedPlus, "Color Transformer", "colour=Lab")
IJ.selectWindow('Lab')
labPlus=IJ.getImage()
croppedPlus.changes=False
croppedPlus.close()
# get the A channel
APlus=substackMaker.makeSubstack(labPlus, "2-2")
APlus.setTitle('A')
#APlus.show()
APlus.getProcessor().resetMinAndMax()
#APlus.updateAndDraw()
AThresholded=threshold(APlus, -10, 50)
# get the B channel
BPlus=substackMaker.makeSubstack(labPlus, "3-3")
BPlus.setTitle('B')
#BPlus.show()
BPlus.getProcessor().resetMinAndMax()
#BPlus.updateAndDraw()
BThresholded=threshold(BPlus, -10, 50)
# AND the Athreshold and Bthreshold to get a map of the red pixels
ic = ImageCalculator();
redMask = ic.run("AND create", AThresholded, BThresholded);
IJ.run(redMask, "Divide...", "value=255");
labPlus.close()
fast=True
# threshold the spots from the red channel
if (fast==False):
thresholdedred=SpotDetectionGray(red, data, display, ops, "triangle")
impthresholdedred = ImageJFunctions.wrap(thresholdedred, "wrapped")
else:
impthresholdedred=SpotDetection2(redPlus)
# threshold the spots from the brightness channel
if (fast==False):
thresholded=SpotDetectionGray(brightness, data, display, ops, "triangle")
impthresholded=ImageJFunctions.wrap(thresholded, "wrapped")
else:
impthresholded=SpotDetection2(brightnessPlus)
# or the thresholding results from red and brightness channel
impthresholded = ic.run("OR create", impthresholded, impthresholdedred);
roim=RoiManager(True)
# convert to mask
Prefs.blackBackground = True
IJ.run(impthresholded, "Convert to Mask", "")
def isRed(imp, roi):
stats = imp.getStatistics()
if (stats.mean>detectionParameters.porphyrinRedPercentage): return True
else: return False
def notRed(imp, roi):
stats = imp.getStatistics()
if (stats.mean>detectionParameters.porphyrinRedPercentage): return False
else: return True
roiClone=inputRoi.clone()
roiClone.setLocation(0,0)
Utility.clearOutsideRoi(impthresholded, roiClone)
impthresholded.show()
countParticles(impthresholded, roim, detectionParameters.porphyrinMinSize, detectionParameters.porphyrinMaxSize, \
detectionParameters.porphyrinMinCircularity, detectionParameters.porphyrinMaxCircularity)
uvPoreList=[]
for roi in roim.getRoisAsArray():
uvPoreList.append(roi.clone())
#allList=uvPoreList+closedPoresList+openPoresList
# count particles that are porphyrins (red)
porphyrinList=CountParticles.filterParticlesWithFunction(redMask, uvPoreList, isRed)
# count particles that are visible on uv but not porphyrins
sebumList=CountParticles.filterParticlesWithFunction(redMask, uvPoreList, notRed)
# for each roi add the offset such that the roi is positioned in the correct location for the
# original image
[roi.setLocation(roi.getXBase()+x1, roi.getYBase()+y1) for roi in uvPoreList]
# draw the ROIs on to the image
inputImp.getProcessor().setColor(Color.green)
IJ.run(inputImp, "Line Width...", "line=3");
inputImp.getProcessor().draw(inputRoi)
IJ.run(inputImp, "Line Width...", "line=1");
[CountParticles.drawParticleOnImage(inputImp, roi, Color.magenta) for roi in porphyrinList]
[CountParticles.drawParticleOnImage(inputImp, roi, Color.green) for roi in sebumList]
inputImp.updateAndDraw()
# calculate stats for the UV visible particles
detectionParameters.setCalibration(APlus)
statsDictUV=CountParticles.calculateParticleStatsUV(APlus, BPlus, redMask, roim.getRoisAsArray())
totalUVPoreArea=0
for area in statsDictUV['Areas']:
totalUVPoreArea=totalUVPoreArea+area
averageUVPoreArea=totalUVPoreArea/len(statsDictUV['Areas'])
poreDiameter=0
for diameter in statsDictUV['Diameters']:
poreDiameter=poreDiameter+diameter
poreDiameter=poreDiameter/len(statsDictUV['Diameters'])
redTotal=0
for red in statsDictUV['redPercentage']:
redTotal=redTotal+red
redAverage=redTotal/len(statsDictUV['redPercentage'])
statslist=[len(porphyrinList), 100*redAverage];
statsheader=[Messages.Porphyrins, Messages.PercentageRedPixels]
print("Roi Area: "+str(inputRoiArea))
print("Total Pore Area: "+str(totalUVPoreArea))
print("Average Pore Area: "+str(averageUVPoreArea))
print str(len(uvPoreList))+" "+str(len(porphyrinList))+" "+str(len(sebumList))+" "+str(100*totalUVPoreArea/inputRoiArea)+" "+str(100*redAverage)
print "cp min circularity"+str(detectionParameters.closedPoresMinCircularity)+":"+str(detectionParameters.closedPoresMinSize)
# close the thresholded image
impthresholded.changes=False
impthresholded.close()
return uvPoreList, statslist, statsheader
def run(self):
for filename in self.filenames:
try:
img = self.klb.readFull(os.path.join(srcDir, filename))
computeInto(maximum(self.aimg, img), self.aimg)
except:
syncPrint("Skipping failed image: %s\n%s" %
(filename, sys.exc_info()))
# Step 2: project the 4D series into a single 3D image using the maximum function
# (Will read it if it already exists)
max_projection_path = os.path.join(tgtDir, "max_projection.zip")
if os.path.exists(max_projection_path):
max_projection = IL.wrap(readIJ(max_projection_path))
print "Loaded max_projection.zip file from disk at", max_projection_path
else:
# Project the time dimension so that 4D -> 3D
# Take the median
sums.sort(key=itemgetter(1))
median = sums[len(sums) / 2][1]
max_sum = sums[-1][1] # last
print median, max_sum
# Turns out the maximum is infinity.
# Therefore, discard all infinity values, and also any above 1.5 * median
threshold = median * 1.5
filtered = [
def run(imp, preprocessor_path, postprocessor_path, threshold_method, user_comment):
output_parameters = {"image title" : "",
"preprocessor path" : float,
"post processor path" : float,
"thresholding op" : float,
"use ridge detection" : bool,
"high contrast" : int,
"low contrast" : int,
"line width" : int,
"minimum line length" : int,
"mitochondrial footprint" : float,
"branch length mean" : float,
"branch length median" : float,
"branch length stdevp" : float,
"summed branch lengths mean" : float,
"summed branch lengths median" : float,
"summed branch lengths stdevp" : float,
"network branches mean" : float,
"network branches median" : float,
"network branches stdevp" : float}
output_order = ["image title",
"preprocessor path",
"post processor path",
"thresholding op",
"use ridge detection",
"high contrast",
"low contrast",
"line width",
"minimum line length",
"mitochondrial footprint",
"branch length mean",
"branch length median",
"branch length stdevp",
"summed branch lengths mean",
"summed branch lengths median",
"summed branch lengths stdevp",
"network branches mean",
"network branches median",
"network branches stdevp"]
# Perform any preprocessing steps...
status.showStatus("Preprocessing image...")
if preprocessor_path != None:
if preprocessor_path.exists():
preprocessor_thread = scripts.run(preprocessor_path, True)
preprocessor_thread.get()
imp = WindowManager.getCurrentImage()
else:
pass
# Store all of the analysis parameters in the table
if preprocessor_path == None:
preprocessor_str = ""
else:
preprocessor_str = preprocessor_path.getCanonicalPath()
if postprocessor_path == None:
postprocessor_str = ""
else:
postprocessor_str = preprocessor_path.getCanonicalPath()
output_parameters["preprocessor path"] = preprocessor_str
output_parameters["post processor path"] = postprocessor_str
output_parameters["thresholding op"] = threshold_method
output_parameters["use ridge detection"] = str(use_ridge_detection)
output_parameters["high contrast"] = rd_max
output_parameters["low contrast"] = rd_min
output_parameters["line width"] = rd_width
output_parameters["minimum line length"] = rd_length
# Create and ImgPlus copy of the ImagePlus for thresholding with ops...
status.showStatus("Determining threshold level...")
imp_title = imp.getTitle()
slices = imp.getNSlices()
frames = imp.getNFrames()
output_parameters["image title"] = imp_title
imp_calibration = imp.getCalibration()
imp_channel = Duplicator().run(imp, imp.getChannel(), imp.getChannel(), 1, slices, 1, frames)
img = ImageJFunctions.wrap(imp_channel)
# Determine the threshold value if not manual...
binary_img = ops.run("threshold.%s"%threshold_method, img)
binary = ImageJFunctions.wrap(binary_img, 'binary')
binary.setCalibration(imp_calibration)
binary.setDimensions(1, slices, 1)
# Get the total_area
if binary.getNSlices() == 1:
area = binary.getStatistics(Measurements.AREA).area
area_fraction = binary.getStatistics(Measurements.AREA_FRACTION).areaFraction
output_parameters["mitochondrial footprint"] = area * area_fraction / 100.0
else:
mito_footprint = 0.0
for slice in range(binary.getNSlices()):
binary.setSliceWithoutUpdate(slice)
area = binary.getStatistics(Measurements.AREA).area
area_fraction = binary.getStatistics(Measurements.AREA_FRACTION).areaFraction
mito_footprint += area * area_fraction / 100.0
output_parameters["mitochondrial footprint"] = mito_footprint * imp_calibration.pixelDepth
# Generate skeleton from masked binary ...
# Generate ridges first if using Ridge Detection
if use_ridge_detection and (imp.getNSlices() == 1):
skeleton = ridge_detect(imp, rd_max, rd_min, rd_width, rd_length)
else:
skeleton = Duplicator().run(binary)
IJ.run(skeleton, "Skeletonize (2D/3D)", "")
# Analyze the skeleton...
status.showStatus("Setting up skeleton analysis...")
skel = AnalyzeSkeleton_()
skel.setup("", skeleton)
status.showStatus("Analyzing skeleton...")
skel_result = skel.run()
status.showStatus("Computing graph based parameters...")
branch_lengths = []
summed_lengths = []
graphs = skel_result.getGraph()
for graph in graphs:
summed_length = 0.0
edges = graph.getEdges()
for edge in edges:
length = edge.getLength()
branch_lengths.append(length)
summed_length += length
summed_lengths.append(summed_length)
output_parameters["branch length mean"] = eztables.statistical.average(branch_lengths)
output_parameters["branch length median"] = eztables.statistical.median(branch_lengths)
output_parameters["branch length stdevp"] = eztables.statistical.stdevp(branch_lengths)
output_parameters["summed branch lengths mean"] = eztables.statistical.average(summed_lengths)
output_parameters["summed branch lengths median"] = eztables.statistical.median(summed_lengths)
output_parameters["summed branch lengths stdevp"] = eztables.statistical.stdevp(summed_lengths)
branches = list(skel_result.getBranches())
output_parameters["network branches mean"] = eztables.statistical.average(branches)
output_parameters["network branches median"] = eztables.statistical.median(branches)
output_parameters["network branches stdevp"] = eztables.statistical.stdevp(branches)
# Create/append results to a ResultsTable...
status.showStatus("Display results...")
if "Mito Morphology" in list(WindowManager.getNonImageTitles()):
rt = WindowManager.getWindow("Mito Morphology").getTextPanel().getOrCreateResultsTable()
else:
rt = ResultsTable()
rt.incrementCounter()
for key in output_order:
rt.addValue(key, str(output_parameters[key]))
# Add user comments intelligently
if user_comment != None and user_comment != "":
if "=" in user_comment:
comments = user_comment.split(",")
for comment in comments:
rt.addValue(comment.split("=")[0], comment.split("=")[1])
else:
rt.addValue("Comment", user_comment)
rt.show("Mito Morphology")
# Create overlays on the original ImagePlus and display them if 2D...
if imp.getNSlices() == 1:
status.showStatus("Generate overlays...")
IJ.run(skeleton, "Green", "")
IJ.run(binary, "Magenta", "")
skeleton_ROI = ImageRoi(0,0,skeleton.getProcessor())
skeleton_ROI.setZeroTransparent(True)
skeleton_ROI.setOpacity(1.0)
binary_ROI = ImageRoi(0,0,binary.getProcessor())
binary_ROI.setZeroTransparent(True)
binary_ROI.setOpacity(0.25)
overlay = Overlay()
overlay.add(binary_ROI)
overlay.add(skeleton_ROI)
imp.setOverlay(overlay)
imp.updateAndDraw()
# Generate a 3D model if a stack
if imp.getNSlices() > 1:
univ = Image3DUniverse()
univ.show()
pixelWidth = imp_calibration.pixelWidth
pixelHeight = imp_calibration.pixelHeight
pixelDepth = imp_calibration.pixelDepth
# Add end points in yellow
end_points = skel_result.getListOfEndPoints()
end_point_list = []
for p in end_points:
end_point_list.append(Point3f(p.x * pixelWidth, p.y * pixelHeight, p.z * pixelDepth))
univ.addIcospheres(end_point_list, Color3f(255.0, 255.0, 0.0), 2, 1*pixelDepth, "endpoints")
# Add junctions in magenta
junctions = skel_result.getListOfJunctionVoxels()
junction_list = []
for p in junctions:
junction_list.append(Point3f(p.x * pixelWidth, p.y * pixelHeight, p.z * pixelDepth))
univ.addIcospheres(junction_list, Color3f(255.0, 0.0, 255.0), 2, 1*pixelDepth, "junctions")
# Add the lines in green
graphs = skel_result.getGraph()
for graph in range(len(graphs)):
edges = graphs[graph].getEdges()
for edge in range(len(edges)):
branch_points = []
for p in edges[edge].getSlabs():
branch_points.append(Point3f(p.x * pixelWidth, p.y * pixelHeight, p.z * pixelDepth))
univ.addLineMesh(branch_points, Color3f(0.0, 255.0, 0.0), "branch-%s-%s"%(graph, edge), True)
# Add the surface
univ.addMesh(binary)
univ.getContent("binary").setTransparency(0.5)
# Perform any postprocessing steps...
status.showStatus("Running postprocessing...")
if postprocessor_path != None:
if postprocessor_path.exists():
postprocessor_thread = scripts.run(postprocessor_path, True)
postprocessor_thread.get()
else:
pass
status.showStatus("Done analysis!")
from ij import ImagePlus
from ij.plugin.filter import BackgroundSubtracter
from jarray import array
from fiji.plugin.trackmate.detection import DetectionUtils
from net.imagej.ops.convert import ConvertPixCopy
###############################################################
# Step 1: Rolling ball background subtraction (still uses IJ1)
###############################################################
# wrap as ImagePlus
imp=ImageJFunctions.wrap(inputData, "wrapped")
# create and call background subtractor
bgs=BackgroundSubtracter()
bgs.rollingBallBackground(imp.getProcessor(), 50.0, False, False, True, True, True)
# wrap the result of background subtraction as Img
iplus=ImagePlus("bgs", imp.getProcessor())
imgBgs=ImageJFunctions.wrapShort(iplus)
###############################################################
# Step 2: Laplacian of Gaussian Filtering
###############################################################
# convert to 32 bit
results.incrementCounter()
results.addValue("area", area.getRealDouble())
results.addValue("min", min.getRealDouble())
results.addValue("max", max.getRealDouble())
results.addValue("mean", mean.getRealDouble())
results.addValue("median", median.getRealDouble())
results.addValue("stdev", stdev.getRealDouble())
results.addValue("sum", sum.getRealDouble())
results.addValue("comment", comment)
# Display the table
results.show("Results")
# Outline and highlight the regions
outline = ops.run("morphology.outline", binary, False)
image_imp = ImageJFunctions.wrap(image, "Overlay Render")
binary_imp = ImageJFunctions.wrap(binary, "Binary")
outline_imp = ImageJFunctions.wrap(outline, "Outline")
IJ.run(binary_imp, "Green", "")
binary_ROI = ImageRoi(0, 0, binary_imp.getProcessor())
binary_ROI.setZeroTransparent(True)
binary_ROI.setOpacity(0.25)
IJ.run(outline_imp, "Green", "")
outline_ROI = ImageRoi(0, 0, outline_imp.getProcessor())
outline_ROI.setZeroTransparent(True)
outline_ROI.setOpacity(1.00)
overlay = Overlay()
overlay.add(binary_ROI)
categorizer = CategorizerWithState.generateFixedRange( ranges )
categorizer = RangedCategorizer( nImages )
matrices = DenseCorrelationMatricesWithRadius(
wrappedImage,
radii[0],
c,
DoubleType()
)
result = MultiScaleEstimation.estimateZCoordinates( matrices, startingCoordinates, c, radii, steps, visitor, categorizer, opt )
IJ.log("done")
resultFileName = '%s/result.tif' % home.rstrip('/')
imp = ImageJFunctions.wrap( result, 'result' )
IJ.saveAsTiff(imp.duplicate(), resultFileName)
relativeResult = result.copy()
c = relativeResult.cursor()
while c.hasNext():
c.fwd()
cur = c.get()
val = cur.get()
cur.set( val - c.getDoublePosition( 2 ) )
relativeResultFileName = '%s/relativeResult.tif' % home.rstrip('/')
imp = ImageJFunctions.wrap( relativeResult, 'relative result' )
IJ.saveAsTiff(imp.duplicate(), relativeResultFileName)
ratio = [ wrappedImage.dimension( 0 )*1.0/result.dimension( 0 ), wrappedImage.dimension( 1 )*1.0/result.dimension( 1 ) ]
# @DisplayService display
# @OpService ops
# @net.imagej.Dataset inputData
from net.imglib2.meta import ImgPlus
from net.imglib2.img.display.imagej import ImageJFunctions
from jarray import array
from ij import IJ
# create a log kernel
logKernel=ops.logKernel(inputData.numDimensions(), 1.0);
# convolve with log kernel
logFiltered=ops.convolve(inputData, logKernel);
# display log filter result
display.createDisplay("log", ImgPlus(logFiltered));
# otsu threshold and display
thresholded = ops.run("threshold.otsu",logFiltered)
display.createDisplay("thresholded", ImgPlus(thresholded));
# convert to imagej1 imageplus so we can run analyze particles
impThresholded=ImageJFunctions.wrap(thresholded, "wrapped")
# convert to mask and analyze particles
IJ.run(impThresholded, "Convert to Mask", "")
IJ.run(impThresholded, "Analyze Particles...", "display add");
IJ.run("Close");
stack_slice = ArrayImgFactory(
img.randomAccess().get().createVariable()).create(
[canvas_width, canvas_height])
target = Views.interval(
stack_slice, [xOffset, yOffset],
[xOffset + img.dimension(0) - 1, yOffset + img.dimension(1) - 1])
c1 = target.cursor()
c2 = img.cursor()
while c1.hasNext():
c1.next().set(c2.next())
return stack_slice
# Re-cut ROIs, this time in RGB rather than just red
img1 = Views.interval(img, [r1.x, r1.y],
[r1.x + r1.width - 1, r1.y + r1.height - 1])
img2 = Views.interval(img, [r2.x, r2.y],
[r2.x + r2.width - 1, r2.y + r2.height - 1])
# Insert each into a stack slice
xOffset1 = 0 if dx >= 0 else abs(dx)
yOffset1 = 0 if dy >= 0 else abs(dy)
xOffset2 = 0 if dx <= 0 else dx
yOffset2 = 0 if dy <= 0 else dy
slice1 = intoSlice(img1, xOffset1, yOffset1)
slice2 = intoSlice(img2, xOffset2, yOffset2)
stack = Views.stack([slice1, slice2])
IL.wrap(stack, "registered with phase correlation").show()
# This is not indexed by intellij import net.imagej.legacy.IJ1Helper import org.scijava.log.LogService from net.imglib2.img.display.imagej import ImageJFunctions # log = IJ1Helper.getLegacyContext().getService(LogService.class) # Finds methods but no signatures from ij import IJ IJ.open() repurl = "http://imagej.net/images" IJ.open(repurl + "/FluorescentCells.jpg") imp = IJ.getImage() print imp.getClass() img = ImageJFunctions.wrap(imp) print img.getClass()
if title.startswith("Energy"):
# Keep "Energy"
energyImp = impOpened;
### Remove holes from image ###
# Selection mask from overlay
manualMask = maskFromOverlay(imp);
# Invert
invertedManualMask = invertImg(manualMask);
if IJ.debugMode:
displays.createDisplay("manual-mask", ImgPlus(invertedManualMask));
# Threshold energyImp
wrappedImg = ImageJFunctions.wrap(energyImp);
if useEnergy:
energyMask = ops.create().img(wrappedImg, BitType());
ops.threshold().apply(energyMask, wrappedImg, FloatType(0.20));
# Invert, b/c we want to have lower energy regions
#invertedOutput = invertImg(output);
if IJ.debugMode:
displays.createDisplay("energy-mask", ImgPlus(energyMask));
# Convert mask to binary image
wrappedManualMask = ImageJFunctions.wrap(maskImp);
coherencyMask = ops.create().img(wrappedImg, BitType());
ops.convert().bit(coherencyMask, wrappedManualMask);
print "read", len(bytes), "bytes" # takes ~2 seconds
# Parse as 16-bit array
sb = ByteBuffer.wrap(bytes).order(ByteOrder.BIG_ENDIAN).asShortBuffer()
shorts = zeros(width * height * numChannels, 'h')
sb.get(shorts)
# Deinterleave channels
# With Weaver: fast
channels = w.deinterleave(shorts, numChannels, channel_index)
# With python array sampling: very slow, and not just from iterating whole array once per channel
# seq = xrange(numChannels) if -1 == channel_index else [channel_index]
#channels = [shorts[i::numChannels] for i in seq]
# With clojure: extremely slow, may be using reflection unexpectedly
#channels = deinterleave.invoke(shorts, numChannels)
print len(channels)
# Shockingly, these values are signed shorts, not unsigned!
return [ArrayImgs.shorts(s, [width, height]) for s in channels]
finally:
ra.close()
path = "/net/ark/raw/fibsem/pygmy-squid/2021-12_popeye/Popeye2/Y2021/M12/D23/FIBdeSEMAna_21-12-23_235849_0-0-0.dat"
channels = readFIBSEMdat(path)
print channels
IL.wrap(channels[0], "channel 1").show() # looks good
IL.wrap(channels[1], "channel 2").show() # looks grainy, lots of shot noise
imgSource.getProcessor().multiply( 1.0 / normalizeBy )
nThreads = 1
serializeCorrelations = True
deserializeCorrelations = not serializeCorrelations
options = Options.generateDefaultOptions()
options.shiftProportion = 0.6
options.nIterations = 30
options.withRegularization = True
options.minimumSectionThickness = 0.0001
options.multiplierGenerationRegularizerWeight = 0.1
options.multiplierEstimationIterations = 10
options.withReorder = False
options.coordinateUpdateRegularizerWeight = 0.0
thickness_estimation_repo_dir = '/groups/saalfeld/home/hanslovskyp/workspace/em-thickness-estimation'
wholeStrip = ImageJFunctions.wrap( imgSource )
timestamp = str(datetime.datetime.now() )
threads = []
upper = start
while upper < stop:
correlationRange = int(c)
lower = max( 0, upper - overlap )
upper = lower + interval
if upper + step >= stop:
upper = min( stop, upper + step )
home = root.rstrip('/') + '/range=%d_%s/lower=%d_upper=%d'
home = home % ( correlationRange, timestamp, lower, upper )
make_sure_path_exists( home.rstrip('/') + '/' )
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) # Step 2: rotate around the Z axis rotation.rotate(2, angle) # 2 is the Z axis, or 3rd dimension # Step 3: undo translation to the center rotation.preConcatenate(toCenter.inverse()) # undo translation to the center # Define a rotated view of the image rotated = RV.transform(imgR, rotation) # View the image rotated, without enlarging the canvas # so we define the interval (here, the field of view of an otherwise infinite image) # as the original image dimensions by using "img", which in itself is an Interval. imgRot2d = IL.wrap(Views.interval(rotated, img), imp.getTitle() + " - rot2d") imgRot2d.show() # View the image rotated, enlarging the interval to fit it. # (This is akin to enlarging the canvas.) # We define each corner of the nth-dimensional volume as a combination, # namely the 'product' (think nested loop) of the pairs of possible values # that each dimension can take in every corner coordinate, zipping each # with the value zero (hence the repeat(0) to provide as many as necessary), # and then unpacking the list of pairs by using the * in front of 'zip' # so that 'product' receives the pairs as arguments rather than a list of pairs. # Then we apply the transform to each corner, reading out the transformed coordinates # by using the 'transformed' float array. # We compute the bounds by, for every corner, checking if the floor of each dimension
rm = RoiManager.getInstance()
if not rm:
rm = RoiManager()
rm.runCommand("reset")
#ask the user to define a selection and get the bounds of the selection
IJ.setTool(Toolbar.RECTANGLE)
WaitForUserDialog("Select the area,then click OK.").show()
boundRect = imp.getRoi()
imp.setRoi(boundRect)
rm.addRoi(boundRect)
imp = IJ.getImage()
cal = imp.getCalibration() # in microns
img = IJF.wrap(imp)
print(img.dimensions)
# Create a variable of the correct type (UnsignedByteType) for the value-extended view
zero = img.randomAccess().get().createVariable()
# Run the difference of Gaussian
cell = 30.0 # microns in diameter
min_peak = 10.0 # min intensity for a peak to be considered
dog = DogDetection(
Views.extendValue(img, zero),
img,
[cal.pixelWidth, cal.pixelHeight],
cell / 2,
cell,
DogDetection.ExtremaType.MAXIMA, #MAXIMA
