def SaveCoverFromFs(tiles, newwidth, newheight, cols, rows): tilewidth = int(newwidth/cols) tileheight = int(newheight/rows) newwidth = int(newwidth/tilewidth) * tilewidth newheight = int(newheight/tileheight) * tileheight hiresoutip = ColorProcessor(newwidth, newheight) hiresout = ImagePlus("hi res output", hiresoutip) hiresout.show() x = 0 y = -1 plane = [] # scale the images for i in sorted(tiles.iterkeys()): if y < rows-1: y += 1 else: y = 0 x += 1 imp = IJ.openImage(str(tiles[i])) scale = Scale(imp.getProcessor()) ipscaled = ScaleImageToSize(scale, tilewidth, tileheight) hiresoutip.copyBits(ipscaled, x*tilewidth, y*tileheight, 0) hiresout.draw()
def scale(ip, s): """ Scale the image with the parameter scale = s """ imp = ImagePlus('scale',ip) IJ.run(imp, "Scale...", "x="+str(s)+" y="+str(s)+" interpolation=Bilinear average"); ip = imp.getProcessor() w = ip.width h = ip.height cd = CanvasResizer() ip = cd.expandImage(ip, int(round(s*w)), int(round(s*h)), -int(round((1-s)/2*w)), -int(round((1-s)/2*h)) ) return ip
def draw_bounding_boxes(objects,title,templateImage): drawnIp = ByteProcessor(templateImage.getWidth(),templateImage.getHeight()) drawnImage = ImagePlus(title,drawnIp) drawnImage.show() IJ.selectWindow(title) for j in range(len(objects)): IJ.makeRectangle(objects[j][42],objects[j][43],objects[j][45]-objects[j][42],objects[j][46]-objects[j][43]) IJ.run("Draw","stack") drawnImage.hide() return(drawnImage)
def generateOverlay(project, patch, shape): oWidth = patch.getOWidth() oHeight = patch.getOHeight() overlayp = ByteProcessor(oWidth, oHeight) # TODO: Use ShortProcessor instead of ByteProcessor imp = ImagePlus("Patch %s" % patch, overlayp) stepX = oWidth/shape[0] stepY = oHeight/shape[1] color = 1 for x in xrange(shape[0]): offsetX = x * stepX for y in xrange(shape[1]): offsetY = y * stepY imp.setRoi(offsetX, offsetY, stepX, stepY) imp.getProcessor().setValue(color) imp.getProcessor().fill() color += 1 imp.setRoi(None) overlayPatch = Patch(project, "%s_overlay" % patch, 0.0, 0.0, imp) overlayPatch.setAffineTransform(patch.getAffineTransform()) overlayPatch.setCoordinateTransform(patch.getCoordinateTransform()) return overlayPatch
def __init__(self, listpaths): self.__listpaths = listpaths self.__listimp = [] for v in listpaths : print v imp = ImagePlus(v) print imp.getTitle() self.__listimp.append(imp) swing.JFrame.__init__(self, title="Images") self.setDefaultCloseOperation(swing.JFrame.DISPOSE_ON_CLOSE) self.run()
def scaleLongSide(ip, longSide): """ Scale the image with respect to the longSide parameter (new size along the long side of the image should equal the longSide parameter) """ w = ip.width h = ip.height l = max(w,h) s = float(longSide)/l imp = ImagePlus('scaleLongSide',ip) IJ.run(imp, "Scale...", "x="+str(s)+" y="+str(s)+" interpolation=Bilinear average"); ip = imp.getProcessor() cd = CanvasResizer() ip = cd.expandImage(ip, int(round(s*w)), int(round(s*h)), -int(round((1-s)/2*w)), -int(round((1-s)/2*h)) ) return ip, s
def siftSingle(ref, target): """ perform SIFT registration for one image """ impRef = ImagePlus('Sift_source', ref) impTarget = ImagePlus('Sift_target', target) expected_transformation = 'Similarity' initial_gaussian_blur = 2 feature_descriptor_size = 8 imp = ImagePlus('siftRefTest', ref) t = SIFT_ExtractPointRoi() t.exec( impRef, impTarget ) roiRef = impRef.getRoi() roiTarget = impTarget.getRoi() return roiRef, roiTarget
def __init__(self): self.imp = None self.preview = None self.createMainWindow() self.cells = None self.files = [] self.results = ResultsTable() ImagePlus.addImageListener(self) self.selectInputDir() self.selectOutputDir() self.pairs = [] self.methods = [] self.processNextFile()
def extract_frame_process_roi(imp, frame, channel, process, roi): # extract frame and channel imp_frame = ImagePlus("", extract_frame(imp, frame, channel)).duplicate() # check for roi and crop if roi != None: #print roi.getBounds() imp_frame.setRoi(roi) IJ.run(imp_frame, "Crop", "") # process if process: IJ.run(imp_frame, "Mean 3D...", "x=1 y=1 z=0"); IJ.run(imp_frame, "Find Edges", "stack"); # return return imp_frame
def test(): newImg = ImagePlus("GrayScaled",imp) newip = newImg.getProcessor() hist = newip.getHistogram() lowTH = Auto_Threshold.IsoData(hist) newip.setThreshold(lowTH, max(hist),ImageProcessor.BLACK_AND_WHITE_LUT) rt = ResultsTable() pa = ParticleAnalyzer(ParticleAnalyzer.SHOW_RESULTS | ParticleAnalyzer.SHOW_OVERLAY_OUTLINES, Measurements.AREA |Measurements.MEAN |\ Measurements.MEDIAN | Measurements.STD_DEV | Measurements.MIN_MAX | Measurements.RECT, rt,50, 200000, 0.5, 1 ) pa.setResultsTable(rt) pa.analyze(newImg) rt.show("Results")
def extract_stack_under_arealist(): # Check that a Display is open display = Display.getFront() if display is None: IJ.log("Open a TrakEM2 Display first!") return # Check that an AreaList is selected and active: ali = display.getActive() if ali is None or not isinstance(ali, AreaList): IJ.log("Please select an AreaList first!") return # Get the range of layers to which ali paints: ls = display.getLayerSet() ifirst = ls.indexOf(ali.getFirstLayer()) ilast = ls.indexOf(ali.getLastLayer()) layers = display.getLayerSet().getLayers().subList(ifirst, ilast +1) # Create a stack with the dimensions of ali bounds = ali.getBoundingBox() stack = ImageStack(bounds.width, bounds.height) # Using 16-bit. To change to 8-bit, use GRAY8 and ByteProcessor in the two lines below: type = ImagePlus.GRAY16 ref_ip = ShortProcessor(bounds.width, bounds.height) for layer in layers: area = ali.getArea(layer) z = layer.getZ() ip = ref_ip.createProcessor(bounds.width, bounds.height) if area is None: stack.addSlice(str(z), bp) continue # Create a ROI from the area of ali at layer: aff = ali.getAffineTransformCopy() aff.translate(-bounds.x, -bounds.y) roi = ShapeRoi(area.createTransformedArea(aff)) # Create a cropped snapshot of the images at layer under ali: flat = Patch.makeFlatImage(type, layer, bounds, 1.0, layer.getDisplayables(Patch), Color.black) b = roi.getBounds() flat.setRoi(roi) ip.insert(flat.crop(), b.x, b.y) # Clear the outside of ROI (ShapeRoi is a non-rectangular ROI type) bimp = ImagePlus("", ip) bimp.setRoi(roi) ip.setValue(0) ip.setBackgroundValue(0) IJ.run(bimp, "Clear Outside", "") # Accumulate slices stack.addSlice(str(z), ip) imp = ImagePlus("AreaList stack", stack) imp.setCalibration(ls.getCalibrationCopy()) imp.show()
def run_script(): # We can use import inside of code blocks to limit the scope. import math from ij import IJ, ImagePlus from ij.process import FloatProcessor blank = IJ.createImage("Blank", "32-bit black", img_size, img_size, 1) # This create a list of lists. Each inner list represents a line. # pixel_matrix[0] is the first line where y=0. pixel_matrix = split_list(blank.getProcessor().getPixels(), wanted_parts=img_size) # This swaps x and y coordinates. # http://stackoverflow.com/questions/8421337/rotating-a-two-dimensional-array-in-python # As zip() creates tuples, we have to convert each one by using list(). pixel_matrix = [list(x) for x in zip(*pixel_matrix)] for y in range(img_size): for x in range(img_size): # This function oszillates between 0 and 1. # The distance of 2 maxima in a row/column is given by spacing. val = (0.5 * (math.cos(2*math.pi/spacing*x) + math.sin(2*math.pi/spacing*y)))**2 # When assigning, we multiply the value by the amplitude. pixel_matrix[x][y] = amplitude * val # The constructor of FloatProcessor works fine with a 2D Python list. crystal = ImagePlus("Crystal", FloatProcessor(pixel_matrix)) # Crop without selection is used to duplicate an image. crystal_with_noise = crystal.crop() crystal_with_noise.setTitle("Crystal with noise") IJ.run(crystal_with_noise, "Add Specified Noise...", "standard=%d" % int(amplitude/math.sqrt(2))) # As this is a demo, we don't want to be ask to save an image on closing it. # In Python True and False start with capital letters. crystal_with_noise.changes = False crystal.show() crystal_with_noise.show() filtered = fft_filter(crystal_with_noise) # We create a lambda function to be used as a parameter of img_calc(). subtract = lambda values: values[0] - values[1] """ This is a short form for: def subtract(values): return values[0] - values[1] """ # The first time we call img_calc with 2 images. difference = img_calc(subtract, crystal, filtered, title="Difference of 2") difference.show() # The first time we call img_calc with 3 images. minimum = img_calc(min, crystal, filtered, crystal_with_noise, title="Minimum of 3") minimum.show() for imp in (crystal, crystal_with_noise, filtered, difference, minimum): IJ.run(imp, "Measure", "")
def __falign(self) : #self.__impRes=IJ.getImage() stack = self.__impRes.getStack() # get the stack within the ImagePlus n_slices = stack.getSize() # get the number of slices ic = ImageCalculator() w = self.__impRes.getWidth() h = self.__impRes.getHeight() self.__sens[:] = [] self.__listrois[:] = [] for index in range(1, n_slices+1): self.__impRes.setSlice(index) ip1 = stack.getProcessor(index) imp1 = ImagePlus("imp1-"+str(index), ip1) #imp1sqr = ic.run("Multiply create 32-bit", imp1, imp1) #IJ.setThreshold(imp1sqr, 1, 4294967296) #IJ.run(imp1sqr, "Create Selection", "") #IJ.run(imp1sqr, "Select All", "") #roi = imp1sqr.getRoi() #rect=roi.getBounds() #roi = Roi(rect) #self.__listrois.append(roi) #ipsqr = imp1sqr.getProcessor() #is1 = ipsqr.getStatistics() #self.__impRes.killRoi() IJ.run(imp1, "Select All", "") roi = imp1.getRoi() self.__listrois.append(roi) ipsqr = imp1.getProcessor() is1 = ipsqr.getStatistics() self.__impRes.killRoi() if is1.xCenterOfMass > w/2.00 : self.__impRes.setRoi(roi) ip1 = self.__impRes.getProcessor() ip1.flipHorizontal() self.__impRes.killRoi() self.__sens.append(-1) else : self.__sens.append(1) self.__impRes.updateAndDraw()
def extract_frame_process_roi(imp, frame, channel, process, roi, roiz): if( imp.getStack().getClass().getName() == "ct.vss.VirtualStackOfStacks"): imp_frame = extract_cropped_frame_from_VirtualStackOfStacks(imp, frame-1, channel, roi, roiz) else: # extract frame and channel imp_frame = ImagePlus("", extract_frame(imp, frame, channel, roiz)).duplicate() # check for roi and crop if roi != None: #print roi.getBounds() imp_frame.setRoi(roi) IJ.run(imp_frame, "Crop", "") # process if process: IJ.run(imp_frame, "Mean 3D...", "x=1 y=1 z=0"); IJ.run(imp_frame, "Find Edges", "stack"); # return return imp_frame
def SaveCoverFromZip(tileIndex, newwidth, newheight, cols, rows, originalspath): baseDir = re.sub(r'\/originals.zip', "", originalspath) #print baseDir zf = zipfile.ZipFile(originalspath, mode='r') tilewidth = int(newwidth/cols) tileheight = int(newheight/rows) newwidth = int(newwidth/tilewidth) * tilewidth newheight = int(newheight/tileheight) * tileheight hiresoutip = ColorProcessor(newwidth, newheight) hiresout = ImagePlus("hi res output", hiresoutip) hiresout.show() x = 0 y = -1 plane = [] # scale the images for i in sorted(tileIndex.iterkeys()): if y < rows-1: y += 1 else: y = 0 x += 1 #bi = bir.openImage(tileIndex[i]); #ip = ColorProcessor(bi) image = zf.read(str(tileIndex[i]) + ".jpeg") #IJ.log("Placing image :" + str(tileIndex[i]) + ".jpeg") my_file = open(baseDir + 'temporary.jpeg','w') my_file.write(image) my_file.close() imp = IJ.openImage(baseDir + "/temporary.jpeg") ip = imp.getProcessor() scale = Scale(ip) ipscaled = ScaleImageToSize(scale, tilewidth, tileheight) hiresoutip.copyBits(ipscaled, x*tilewidth, y*tileheight, 0) hiresout.draw()
def run(): d = str(input_dir) files = get_swc_files(d, filenameFilter); if not files or len(files) == 0: uiservice.showDialog("No files matched the specified criteria", "Error") IT = ImportTracings() IT.applyScalingFactor(scale_factor, scale_factor, scale_factor) # IT.applyCalibration(1, 1, 1, "um") proj_rendering = "Projected" in display_choice for (counter, f) in enumerate(files): basename = os.path.basename(f) status.showStatus('Loading file %s: %s...' % (counter + 1, basename)) try: IT.autoLoadSWC(f, proj_rendering) if proj_rendering: imp = ImagePlus("file: " + basename, IT.getSkeletonizedProjection()) imp.show() except Exception, msg: # Jython 3: except Exception as msg: log.error("An error occurred when loading %s. Details:\n%s" % (f, msg)) break
def __end(self, event): if len(self.__iplist)==0 : IJ.showMessage("", "Stack is empty") return self.__iplist.sort(key = lambda ip : ip.width) self.__ipw=[ ip.getWidth() for ip in self.__iplist ] self.__iph=[ ip.getHeight() for ip in self.__iplist ] maxw=max(self.__ipw) maxh=max(self.__iph) if self.__enlarge : resizelist = [ ip.resize(maxw, maxh, True) for ip in self.__iplist ] else : resizelist = [] for ip in self.__iplist : tempip = ShortProcessor(maxw, maxh) xloc = int(math.floor((maxw/2.00) - (ip.width/2.00))) yloc = int(math.floor((maxh/2.00) - (ip.height/2.00))) tempip.copyBits(ip, xloc, yloc, Blitter.COPY) resizelist.append(tempip) ims = ImageStack(maxw, maxh) #for ip in resizelist : ims.addSlice("", ip) for i in range(len(resizelist)) : ims.addSlice(self.__labels[i], resizelist[i]) self.__impRes = ImagePlus(self.__name, ims) self.__impRes.show() self.__sens = [1 for i in range(len(self.__iplist)) ] if self.__appmedian : IJ.run(self.__impRes, "Median...", "radius=1 stack") if self.__align : self.__falign() if self.__avg : self.__favg() if self.__mosa : self.__fmosa() if self.__maxfinder : self.__fmaxfinder() if self.__fire : IJ.run(self.__impRes, "Fire", "") if self.__measures : self.__fmeasures() self.__sens[:] = [] self.__listrois[:] = [] self.__iplist[:] = [] self.__cellsrois[:] = [] self.__ipw[:] = [] self.__iph[:] = [] self.__init = False
def Extract_Red_Channel(color): imp = IJ.getImage() stack = imp.getImageStack() print "number of slices:", imp.getNSlices() # A list of red slices reds = [] # Iterate each slice in the stack for i in xrange(1, imp.getNSlices()+1): # Get the ColorProcessor slice at index i cp = stack.getProcessor(i) # Get its green channel as a FloatProcessor fp = cp.toFloat(0, None) # ... and store it in a list reds.append(fp) # Create a new stack with only the green channel stack2 = ImageStack(imp.width, imp.height) for fp in reds: stack2.addSlice(None, fp) # Create a new image with the stack of green channel slices imp2 = ImagePlus("Red channel", stack2) # Set a green look-up table: IJ.run(imp2, "Red", "") imp2.show()
def load(self, event): #choose a folder to load images self.imdir = DirectoryChooser("Select a dir, dude").getDirectory() self.pictureList = [path.join(self.imdir, f) for f in listdir(self.imdir) if path.splitext(f)[1]==".tiff" and 'AVG' not in f and 'Avg' not in f] #list of pictures (not averages) with .tiff extension print self.pictureList #list of pictures self.imLeft = ImagePlus(self.pictureList[self.imageCount]) #read the image self.imageCount =self.imageCount+1 #increase counter self.imRight = ImagePlus(self.pictureList[self.imageCount]) #read the image self.imageCount =self.imageCount+1 self.imLeft.show() #show image on the left self.imLeft.getWindow().setLocation(self.coordx,self.coordy) #reposition image self.imRight.show() #show image on the right self.rightImLocx = self.coordx+self.imLeft.getWindow().getWidth() #set a variable with the x position for right image self.imRight.getWindow().setLocation(self.rightImLocx,self.coordy) #reposition image #WindowOrganizer("Tile") #SyncWindows(self.imLeft.getTitle() + " " + self.imRight.getTitle()) #IJ.run("Sync Windows") print len(self.pictureList)
def ChooseLeft(self, event): #remove right image and load another if self.listendFlag==0: #if is not the end of the list print "You chose left, which is of course right" self.imRight.close() if self.imageCount>=len(self.pictureList): #if is the end of the list print "YOU HAVE A WINNER!!!" self.listendFlag = 1 #flag if self.imageCount==len(self.pictureList): self.chosenOne = 'L' #a variable to know the position of the chosen one self.imageCount = self.imageCount+1 #this is to avoid changing the chosen one else: self.imRight = ImagePlus(self.pictureList[self.imageCount]) #read next image self.imageCount =self.imageCount+1 #increase counter self.imRight.show() #show image on the right self.imRight.getWindow().setLocation(self.rightImLocx,self.coordy) #reposition image
def ChooseRight(self, event): #same as above but for the right image if self.listendFlag==0: print "You chose right, :)" self.imLeft.close() if self.imageCount>=len(self.pictureList): print "YOU HAVE A WINNER!!!" self.listendFlag = 1 if self.imageCount==len(self.pictureList): self.chosenOne = 'R' self.imageCount = self.imageCount+1 else: self.imLeft = ImagePlus(self.pictureList[self.imageCount]) self.imageCount =self.imageCount+1 self.imLeft.show() #show image on the left self.imLeft.getWindow().setLocation(self.coordx,self.coordy) #reposition image
def openImp(self, path): imp = ImagePlus(path) # open associated tif file imp.show() imp.getWindow().setLocationAndSize(280, 120, imp.getWidth()*4, imp.getHeight()*4) # int x, int y, int width, int height return imp
#!/bin/sh ''''exec "$(dirname "$0")"/ImageJ.sh --jython "$0" "$@" # (call again with fiji)''' from org.jpedal import PdfDecoder from ij import ImageJ, ImagePlus import sys if len(sys.argv) != 2: print 'Usage:', sys.argv[0], 'source.pdf' sys.exit(1) ij = None decoder = PdfDecoder(False) decoder.setExtractionMode(PdfDecoder.RAWIMAGES | PdfDecoder.FINALIMAGES) decoder.openPdfFile(sys.argv[1]) for page in range(0, decoder.getPageCount()): decoder.decodePage(page + 1) images = decoder.getPdfImageData() image_count = images.getImageCount() for i in range(0, image_count): name = images.getImageName(i) image = decoder.getObjectStore().loadStoredImage('R' + name) if ij == None: ij = ImageJ() ij.exitWhenQuitting(True) ImagePlus(name, image).show() decoder.flushObjectValues(True) decoder.closePdfFile()
def test(red, green, blue, easy=True): saturation = let( "red", red, "green", green, "blue", blue, "max", maximum("red", "green", "blue"), "min", minimum("red", "green", "blue"), IF(EQ(0, "max"), THEN(0), ELSE(div(sub("max", "min"), "max")))) brightness = div(maximum(red, green, blue), 255.0) hue = IF( EQ(0, saturation), THEN(0), ELSE( let( "red", red, "green", green, "blue", blue, "max", maximum("red", "green", "blue"), "min", minimum("red", "green", "blue"), "range", sub("max", "min"), "redc", div(sub("max", "red"), "range"), "greenc", div(sub("max", "green"), "range"), "bluec", div(sub("max", "blue"), "range"), "hue", div( IF( EQ("red", "max"), THEN(sub("bluec", "greenc")), ELSE( IF(EQ("green", "max"), THEN(sub(add(2, "redc"), "bluec")), ELSE(sub(add(4, "greenc"), "redc"))))), 6), IF(LT("hue", 0), THEN(add("hue", 1)), ELSE("hue"))))) #print hierarchy(hue) #print "hue view:", hue.view( FloatType() ).iterationOrder() if easy: # About 26 ms """ hsb = Views.stack( hue.view( FloatType() ), saturation.view( FloatType() ), brightness.view( FloatType() ) ) """ # About 13 ms: half! Still much worse than plain ImageJ, # but the source images are iterated 4 times, rather than just once, # and the saturation is computed twice, # and the min, max is computed 3 and 4 times, respectively. hsb = Views.stack(hue.viewDouble(FloatType()), saturation.viewDouble(FloatType()), brightness.viewDouble(FloatType())) """ # Even worse: ~37 ms width, height = rgb.dimension(0), rgb.dimension(1) h = compute(hue).into(ArrayImgs.floats([width, height])) s = compute(saturation).into(ArrayImgs.floats([width, height])) b = compute(brightness).into(ArrayImgs.floats([width, height])) hsb = Views.stack( h, s, b ) """ imp = IL.wrap(hsb, "HSB view") else: # Tested it: takes more time (~40 ms vs 26 ms above) width, height = rgb.dimension(0), rgb.dimension(1) hb = zeros(width * height, 'f') sb = zeros(width * height, 'f') bb = zeros(width * height, 'f') h = ArrayImgs.floats(hb, [width, height]) s = ArrayImgs.floats(sb, [width, height]) b = ArrayImgs.floats(bb, [width, height]) #print "ArrayImg:", b.iterationOrder() ImgUtil.copy(ImgView.wrap(hue.view(FloatType()), None), h) ImgUtil.copy(ImgView.wrap(saturation.view(FloatType()), None), s) ImgUtil.copy(ImgView.wrap(brightness.view(FloatType()), None), b) stack = ImageStack(width, height) stack.addSlice(FloatProcessor(width, height, hb, None)) stack.addSlice(FloatProcessor(width, height, sb, None)) stack.addSlice(FloatProcessor(width, height, bb, None)) imp = ImagePlus("hsb", stack) return imp
nearZImp.close() #add the images to concatenated stacks conThresholdStack = concatStacks(conThresholdStack, thresholdImp) conFRETImp2Stack=concatStacks(conFRETImp2Stack, FRETimp2) conFRETProjImpStack=concatStacks(conFRETProjImpStack, FRETProjImp) conlabelImpStack=concatStacks(conlabelImpStack, labelImp) thresholdImp.close() FRETimp2.close() FRETProjImp.close() labelImp.close() #Show the images and make the images pretty... I should have put in a function` conThresholdImp= ImagePlus( "Threshold image for "+ originalTitle, conThresholdStack) conThresholdImp.setDimensions(1, imp1.getNSlices(), imp1.getNFrames()) IJ.setMinAndMax(conThresholdImp, 0,1) conThresholdImp.setCalibration(cal) conThresholdImp = CompositeImage(conThresholdImp, CompositeImage.COMPOSITE) conThresholdImp.show() conFRETImp2 = ImagePlus( "Emission ratios X1000 of "+ originalTitle, conFRETImp2Stack) conFRETImp2.setDimensions(1, imp1.getNSlices(), imp1.getNFrames()) conFRETImp2.setCalibration(cal) stats=StackStatistics(conFRETImp2) conFRETImp2 = CompositeImage(conFRETImp2, CompositeImage.COMPOSITE) IJ.setMinAndMax(conFRETImp2, 500, 3500) conFRETImp2.show() IJ.run("16_colors")
# Convert method string to the opencv corresponding index Dico_Method = { "Square difference": 0, "Normalised Square Difference": 1, "Cross-Correlation": 2, "Normalised cross-correlation": 3, "0-mean cross-correlation": 4, "Normalised 0-mean cross-correlation": 5 } Method = Dico_Method[method] if show_images: from ij import ImagePlus, ImageStack Stack_Image = ImageStack() Stack_Image_ImP = ImagePlus() if add_roi: from ij.plugin.frame import RoiManager from ij.gui import Roi RM = RoiManager() rm = RM.getInstance() if show_table: from ij.measure import ResultsTable from utils import AddToTable Table = ResultsTable().getResultsTable( ) # allows to append to an existing table ## Check if input are valid if n_hit <= 0:
def getThreshold(self, imp): result = ImagePlus(imp.title, self.segmentor.applyClassifier(imp).getProcessor()) return result
def crop(im,roi): ip = im.getProcessor() ip.setRoi(roi) im = ImagePlus(im.getTitle() + '_Cropped', ip.crop()) return im
def scaleandfilter(infile,outfile,scalex,scaley,scalez,anisofilter,runtube): print ("infile is: "+infile) imp = Opener().openImage(infile) print imp print "scalex = %f; scaley = %f ; scalez = %f" % (scalex,scaley,scalez) # Rescale cal = imp.getCalibration() iml = ImgLib.wrap(imp) scaledimg = Scale3D(iml, scalex, scaley, scalez) imp2=ImgLib.wrap(scaledimg) # find range of pixel values for scaled image from mpicbg.imglib.algorithm.math import ComputeMinMax # (for imglib2 will be: net.imglib2.algorithm.stats) minmax=ComputeMinMax(scaledimg) minmax.process() (min,max)=(minmax.getMin().get(),minmax.getMax().get()) # Make a copy of the stack (converting to 8 bit as we go) stack = ImageStack(imp2.width, imp2.height) print "min = %e, max =%e" % (min,max) for i in xrange(1, imp2.getNSlices()+1): imp2.setSliceWithoutUpdate(i) ip=imp2.getProcessor() # set range ip.setMinAndMax(min,max) stack.addSlice(str(i), ip.convertToByte(True)) # save copy of calibration info cal=imp.getCalibration() # close original image imp.close() # make an image plus with the copy scaled = ImagePlus(imp2.title, stack) # Deal with calibration info which didn't seem to come along for the ride cal.pixelWidth/=scalex cal.pixelHeight/=scaley cal.pixelDepth/=scalez scaled.setCalibration(cal) print "dx = %f; dy=%f; dz=%f" % (cal.pixelWidth,cal.pixelHeight,cal.pixelDepth) intif=infile+".tif" outtif=infile+"-filtered.tif" if anisofilter.upper() != 'FALSE': print("saving input file as "+intif) f=FileSaver(scaled) f.saveAsTiffStack(intif) scaled.close() # anisotropic filtering anisopts="-scanrange:10 -tau:2 -nsteps:2 -lambda:0.1 -ipflag:0 -anicoeff1:1 -anicoeff2:0 -anicoeff3:0" anisopts=anisopts+" -dx:%f -dy:%f -dz:%f" % (cal.pixelWidth,cal.pixelHeight,cal.pixelDepth) if sys.version_info > (2, 4): #for testing # subprocess.check_call(["cp",intif,outtif]) subprocess.check_call([anisofilter]+anisopts.split(' ')+[intif,outtif]) else: os.system(" ".join([anisofilter]+anisopts.split(' ')+[intif,outtif])) # Open anisofilter output back into Fiji print("Opening output tif: "+outtif) scaled = Opener().openImage(outtif) scaled.setCalibration(cal) # Hessian (tubeness) print("Running tubeness") if(runtube): tp=TubenessProcessor(1.0,False) result = tp.generateImage(scaled) IJ.run(result, "8-bit","") else: result=scaled # Save out file fileName, fileExtension = os.path.splitext(outfile) print("Saving as "+fileExtension+": "+outfile) if fileExtension.lower()=='.nrrd': nw=Nrrd_Writer() nw.setNrrdEncoding("gzip") nw.save(result,outfile) else: # Save to PIC IJ.run(result,"Biorad ...", "biorad=["+outfile+"]") scaled.close() result.close()
def exit(self): ImagePlus.removeImageListener(self) self.closeImage() self.closeMainWindow()
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) print type(red32.getImg()) log = ops.convolve(ops.create(dimensions2D, FloatType()), imgBgs, kernel) display.createDisplay("log", data.create(ImgPlus(log))) otsu = ops.run("threshold", ops.create(dimensions2D, BitType()), log, Otsu())
os.mkdir(z_proj_dir+'/green') if red: if not os.path.exists(z_proj_dir+'/red'): os.mkdir(z_proj_dir+'/red') if yellow: if not os.path.exists(z_proj_dir+'/yellow'): os.mkdir(z_proj_dir+'/yellow') if not os.path.exists(merge_z_dir): os.mkdir(merge_z_dir) for stage_pos in im_series: print 'current stage position ID: ' + stage_pos imps_for_comp = [None, None, None, None, None, None, None] if blue: cyan_id = color_sublists['bfp'][stage_pos] print 'blue image file: ' + cyan_id c_imp = ImagePlus(img_dir+'/'+cyan_id) imps_for_comp[4] = c_imp if cyan: cyan_id = color_sublists['cfp'][stage_pos] print 'cyan image file: ' + cyan_id c_imp = ImagePlus(img_dir+'/'+cyan_id) imps_for_comp[4] = c_imp if green: green_id = color_sublists['gfp'][stage_pos] print 'green image file: ' + green_id g_imp = ImagePlus(img_dir+'/'+green_id) imps_for_comp[1] = g_imp if yellow: green_id = color_sublists['yfp'][stage_pos] print 'yellow image file: ' + green_id g_imp = ImagePlus(img_dir+'/'+green_id)
stack2 = imp2.getImageStack() #this is te destination (we will display as composite) newStack = ImageStack(imp1.width, imp1.height) #fuse the 2 stacks inter intwoven stack for i in xrange(1, imp1.getNSlices() + 1): # Get the ColorProcessor slice at index i cp1 = stack1.getProcessor(i) cp2 = stack2.getProcessor(i) # Add both to the new stack newStack.addSlice(None, cp1) newStack.addSlice(None, cp2) # Create a new ImagePlus with the new stack newStack newImp = ImagePlus("my composite", newStack) newImp.setCalibration(imp1.getCalibration().copy()) # Tell the ImagePlus to represent the slices in its stack # in hyperstack form, and open it as a CompositeImage: nChannels = 2 # two color channels nSlices = stack1.getSize() # the number of slices of the original stack nFrames = 1 # only one time point newImp.setDimensions(nChannels, nSlices, nFrames) #comp = ImagePlus.CompositeImage(newImp, CompositeImage.COMPOSITE) comp = ImagePlus.CompositeImage(newImp) comp.show() imp1 = comp else: print "Opening single channel:"
def snapshot(imp, c, z, f, x, y, L): '''Take a L x L snapshot centered at (x,y) at channel c, slice z and frame f Parameters: imp: an ImagePlus object for processing c, z, f: specificed channel, slice (z-dimension) and frame coordinate x, y: targeted center position to take the snapshot L: desired edge lengths of the snapshot in pixels Returns: cropped: an ImagePlus object of the snapshot image ''' # Import inside function to limit scope from ij import ImagePlus # Get the dimensions of the images cN = imp.getNChannels() zN = imp.getNSlices() # fN = imp.getNFrames() # Convert specified position (c,z,f) to index assuming hyperstack order is czt (default) sliceIndex = int(cN * zN * (f-1) + cN * (z-1) + c) imp.setSlice(sliceIndex) ipTemp = imp.getProcessor() impTemp = ImagePlus('temp', ipTemp) # Expand the image by half of L to make sure final duplicate is the same size # when requested (x,y) could be within L pixels of the edge wOld = ipTemp.getWidth() hOld = ipTemp.getHeight() wNew = wOld + int(L) hNew = hOld + int(L) ipNew = ipTemp.createProcessor(wNew, hNew) ipNew.setColor(0) # 0 = black color ipNew.insert(ipTemp, int(L/2), int(L/2)) imgNew = ImagePlus('new', ipNew) # Use the specified center coordinate x, y and the target side length to create ROI imgNew.setRoi(int(x), int(y), int(L), int(L)) # cropped = ImagePlus('cropped', ipNew.crop()) cropped = imgNew.crop() impTemp.close() imgNew.close() return cropped
#DRAW_DOT = False DRAW_DOT = True # use if drawing a dot at the center of tracking #DRAW_BOX = False DRAW_BOX = True # use if drawing a dot at the center of tracking ANNOTATE_Z = False #ANNOTATE_Z = True # use if drawing a string to annotate the z position TEST_RUN = False #TEST_RUN = True # use for testing run (2 tracks) # Reading in the image file for taking snapshots tifFile = input_folder + tif_filename imp = ImagePlus(tifFile) #---------------------------------------------------------- # For running all ZOOM_BY_Z_DEPTH and DRAW_DOT combinations #---------------------------------------------------------- #boolList = [False, True] #for ZOOM_BY_Z_DEPTH in boolList: # for DRAW_DOT in boolList: # # Running the heavy-lifting function to save all snapshot series # output_folder = input_folder + outputPrefix + '-zZoom_' + str(ZOOM_BY_Z_DEPTH) + '-drawDot_' + str(DRAW_DOT) + '-' + time_stamp + '/' # if not os.path.exists(output_folder): # os.makedirs(output_folder) # save_snap_shot_seq(imp, xml_filename, input_folder, output_folder, ZOOM_BY_Z_DEPTH, Z1_CLOSE_TO_COVERSLIP, DRAW_DOT, TEST_RUN, z_number_to_project, L) #----------------------------------------------------------
for ch in range(0, 2): #Loop over channels norm = 1 / (apicalimps[ch].getProcessor().getStats().mean ) * 1000 #normalize to mean intensity of image apicalimps[ch].setRoi( int(centroidX[cell]) - 30, int(centroidY[cell]) - 30, 60, 60) toAdd = apicalimps[ch].crop().getProcessor() toAdd.multiply(norm) stacks[ch].addSlice(toAdd) except: print('There was a problem with sample ' + sample_label) pass #Merge channels and save image stacks measureAll = ImagePlus('measure_all', stacks[0]) detectAll = ImagePlus('detect_all', stacks[1]) measureAvg = zp.run(measureAll, 'avg') detectAvg = zp.run(detectAll, 'avg') compositeAvg = cm.mergeChannels([measureAvg, detectAvg], False) #this we'll save compositeAll = cm.mergeChannels([measureAll, detectAll], False) IJ.saveAs(compositeAll, "Tiff", os.path.join(outputdir, 'Composite_All.tif')) print('Saved ' + os.path.join(outputdir, 'Composite_All.tif')) IJ.saveAs(compositeAvg, "Tiff", os.path.join(outputdir, 'Composite_AVG.tif')) print('Saved ' + os.path.join(outputdir, 'Composite_AVG.tif'))
def main(): Interpreter.batchMode = True if (lambda_flat == 0) ^ (lambda_dark == 0): print ("ERROR: Both of lambda_flat and lambda_dark must be zero," " or both non-zero.") return lambda_estimate = "Automatic" if lambda_flat == 0 else "Manual" #import pdb; pdb.set_trace() print "Loading images..." filenames = enumerate_filenames(pattern) num_channels = len(filenames) num_images = len(filenames[0]) image = Opener().openImage(filenames[0][0]) width = image.width height = image.height image.close() # The internal initialization of the BaSiC code fails when we invoke it via # scripting, unless we explicitly set a the private 'noOfSlices' field. # Since it's private, we need to use Java reflection to access it. Basic_noOfSlices = Basic.getDeclaredField('noOfSlices') Basic_noOfSlices.setAccessible(True) basic = Basic() Basic_noOfSlices.setInt(basic, num_images) # Pre-allocate the output profile images, since we have all the dimensions. ff_image = IJ.createImage("Flat-field", width, height, num_channels, 32); df_image = IJ.createImage("Dark-field", width, height, num_channels, 32); print("\n\n") # BaSiC works on one channel at a time, so we only read the images from one # channel at a time to limit memory usage. for channel in range(num_channels): print "Processing channel %d/%d..." % (channel + 1, num_channels) print "===========================" stack = ImageStack(width, height, num_images) opener = Opener() for i, filename in enumerate(filenames[channel]): print "Loading image %d/%d" % (i + 1, num_images) image = opener.openImage(filename) stack.setProcessor(image.getProcessor(), i + 1) input_image = ImagePlus("input", stack) # BaSiC seems to require the input image is actually the ImageJ # "current" image, otherwise it prints an error and aborts. WindowManager.setTempCurrentImage(input_image) basic.exec( input_image, None, None, "Estimate shading profiles", "Estimate both flat-field and dark-field", lambda_estimate, lambda_flat, lambda_dark, "Ignore", "Compute shading only" ) input_image.close() # Copy the pixels from the BaSiC-generated profile images to the # corresponding channel of our output images. ff_channel = WindowManager.getImage("Flat-field:%s" % input_image.title) ff_image.slice = channel + 1 ff_image.getProcessor().insert(ff_channel.getProcessor(), 0, 0) ff_channel.close() df_channel = WindowManager.getImage("Dark-field:%s" % input_image.title) df_image.slice = channel + 1 df_image.getProcessor().insert(df_channel.getProcessor(), 0, 0) df_channel.close() print("\n\n") template = '%s/%s-%%s.tif' % (output_dir, experiment_name) ff_filename = template % 'ffp' IJ.saveAsTiff(ff_image, ff_filename) ff_image.close() df_filename = template % 'dfp' IJ.saveAsTiff(df_image, df_filename) df_image.close() print "Done!"
imp = IJ.getImage() stkA = ArrayList() for i in range(1, 4): #for i in range(1, imp.getNFrames()): e4d = Extractfrom4D() e4d.setGstarttimepoint(i) IJ.log("current time point" + str(i)) aframe = e4d.coreheadless(imp, 3) ortho = XYZMaxProject(aframe) orthoimp = ortho.getXYZProject() stkA.add(orthoimp) #orthoimp.show() stk = ImageStack(stkA.get(0).getWidth(), stkA.get(0).getHeight()) for item in stkA: stk.addSlice("slcie", item.getProcessor()) out = ImagePlus("out", stk) #out.setCalibration(imp.getCalibration().copy()) IJ.run(out, "Grays", ""); IJ.run(out, "RGB Color", ""); # load data from file filepath = '/Users/miura/Dropbox/Mette/20_23h/20_23hrfull_corrected_1_6_6_netdispZ40.csv' filename = os.path.basename(filepath) newfilename = os.path.join(os.path.splitext(filename)[0], '_plotStack.tif') out.setTitle(os.path.basename(filename)+'_OutStack.tif') PLOT_ONLY_IN_FRAME1 = False data = readCSV(filepath) calib = imp.getCalibration() xscale = calib.pixelWidth
finally: # This 'finally' block executes even in the event of an error # guaranteeing that the executing threads will be shut down no matter what. exe.shutdown() # ISSUE: Does not work with IntervalView from View.rotate, # so img1 and img2 were copied into ArrayImg # (The error would occur when iterating vol4d pixels beyond the first element in the 4th dimension.) vol4d = Views.stack([img1] + steps + [img2]) # Convert 1 -> 255 for easier volume rendering in 3D Viewer #compute(mul(vol4d, 255)).into(vol4d) for t in Views.iterable(vol4d): if 0 != t.getByte(): t.setReal(255) # Construct an ij.VirtualStack from vol4d virtualstack = IL.wrap(vol4d, "interpolations").getStack() imp = ImagePlus("interpolations", virtualstack) imp.setDimensions(1, vol4d.dimension(2), vol4d.dimension(3)) imp.setDisplayRange(0, 255) # Show as a hyperstack with 4 dimensions, 1 channel com = CompositeImage(imp, CompositeImage.GRAYSCALE) com.show() # Show rendered volumes in 4D viewer: 3D + time axis univ = Image3DUniverse() univ.show() univ.addVoltex(com)
def register_hyperstack_subpixel(imp, channel, shifts, target_folder, virtual): """ Takes the imp, determines the x,y,z drift for each pair of time points, using the preferred given channel, and outputs as a hyperstack. The shifted image is computed using TransformJ allowing for sub-pixel shifts using interpolation. This is quite a bit slower than just shifting the image by full pixels as done in above function register_hyperstack(). However it significantly improves the result by removing pixel jitter. """ # Compute bounds of the new volume, # which accounts for all translations: minx, miny, minz, maxx, maxy, maxz = compute_min_max(shifts) # Make shifts relative to new canvas dimensions # so that the min values become 0,0,0 for shift in shifts: shift.x -= minx shift.y -= miny shift.z -= minz # new canvas dimensions: width = int(imp.width + maxx - minx) height = int(maxy - miny + imp.height) slices = int(maxz - minz + imp.getNSlices()) print "New dimensions:", width, height, slices # prepare stack for final results stack = imp.getStack() if virtual is True: names = [] else: registeredstack = ImageStack(width, height, imp.getProcessor().getColorModel()) # prepare empty slice for padding empty = imp.getProcessor().createProcessor(width, height) IJ.showProgress(0) # get raw data as stack stack = imp.getStack() # loop across frames for frame in range(1, imp.getNFrames()+1): IJ.showProgress(frame / float(imp.getNFrames()+1)) fr = "t" + zero_pad(frame, len(str(imp.getNFrames()))) # for saving files in a virtual stack # get and report current shift shift = shifts[frame-1] print "frame",frame,"correcting drift",-shift.x-minx,-shift.y-miny,-shift.z-minz IJ.log(" frame "+str(frame)+" correcting drift "+str(round(-shift.x-minx,2))+","+str(round(-shift.y-miny,2))+","+str(round(-shift.z-minz,2))) # loop across channels for ch in range(1, imp.getNChannels()+1): tmpstack = ImageStack(width, height, imp.getProcessor().getColorModel()) # get all slices of this channel and frame for s in range(1, imp.getNSlices()+1): ip = stack.getProcessor(imp.getStackIndex(ch, s, frame)) ip2 = ip.createProcessor(width, height) # potentially larger ip2.insert(ip, 0, 0) tmpstack.addSlice("", ip2) # Pad the end (in z) of this channel and frame for s in range(imp.getNSlices(), slices): tmpstack.addSlice("", empty) # subpixel translation imp_tmpstack = ImagePlus("", tmpstack) imp_translated = translate_single_stack_using_imglib2(imp_tmpstack, shift.x, shift.y, shift.z) # Add translated frame to final time-series translated_stack = imp_translated.getStack() for s in range(1, translated_stack.getSize()+1): ss = "_z" + zero_pad(s, len(str(slices))) ip = translated_stack.getProcessor(s).duplicate() # duplicate is important as otherwise it will only be a reference that can change its content if virtual is True: name = fr + ss + "_c" + zero_pad(ch, len(str(imp.getNChannels()))) +".tif" names.append(name) currentslice = ImagePlus("", ip) currentslice.setCalibration(imp.getCalibration().copy()) currentslice.setProperty("Info", imp.getProperty("Info")); FileSaver(currentslice).saveAsTiff(target_folder + "/" + name) else: registeredstack.addSlice("", ip) IJ.showProgress(1) if virtual is True: # Create virtual hyper stack with the result registeredstack = VirtualStack(width, height, None, target_folder) for name in names: registeredstack.addSlice(name) registeredstack_imp = ImagePlus("registered time points", registeredstack) registeredstack_imp.setDimensions(imp.getNChannels(), slices, imp.getNFrames()) registeredstack_imp.setCalibration(imp.getCalibration().copy()) registeredstack_imp.setOpenAsHyperStack(True) else: registeredstack_imp = ImagePlus("registered time points", registeredstack) registeredstack_imp.setCalibration(imp.getCalibration().copy()) registeredstack_imp.setProperty("Info", imp.getProperty("Info")) registeredstack_imp.setDimensions(imp.getNChannels(), slices, imp.getNFrames()) registeredstack_imp.setOpenAsHyperStack(True) if 1 == registeredstack_imp.getNChannels(): return registeredstack_imp #IJ.log("\nHyperstack dimensions: time frames:" + str(registeredstack_imp.getNFrames()) + ", slices: " + str(registeredstack_imp.getNSlices()) + ", channels: " + str(registeredstack_imp.getNChannels())) # Else, as composite mode = CompositeImage.COLOR; if isinstance(imp, CompositeImage): mode = imp.getMode() else: return registeredstack_imp return CompositeImage(registeredstack_imp, mode)
a different LUT to each slice in a stack... """ from ij import IJ, ImagePlus, ImageStack # start clean IJ.run("Close All") # returned is an array of ImagePlus, in many cases just one imp. src = img_dir + "/VS_demo.tif" stack = IJ.openImage(src) stack.show() ip_red = stack.getProcessor(1) imp_red = ImagePlus('red', ip_red) imp_red.show() imp_r = imp_red.duplicate() # IJ.saveAs(imp_red, "Tiff", img_dir + "/R.tif") ip_green = stack.getProcessor(2) imp_green = ImagePlus('green', ip_green) imp_green.show() imp_g = imp_green.duplicate() ip_blue = stack.getProcessor(3) imp_blue = ImagePlus('blue', ip_blue) imp_blue.show() imp_b = imp_blue.duplicate() ip_ir = stack.getProcessor(4)
print("STICS completed for ROI " + str(i + 1) + " of " + str(num_window_x * num_window_y)) IJ.log("2D STICS completed") IJ.log("Window size: " + str(width_sub) + " pixels") IJ.log("Maximum time lag analyzed: " + str(max_cycle_length) + " frames") #savepath = IJ.getDirectory("") #imp = IJ.getImage() #ssize = imp.getStackSize() #titleext = imp.getTitle() title = os.path.splitext( filename)[0] + "_STICS_map" #os.path.splitext(titleext)[0] save_imp = ImagePlus(title, result_stack) save_imp.show() dimA = save_imp.getDimensions() for c in range(dimA[2]): for z in range(dimA[3]): for t in range(dimA[4]): save_imp.setPosition(c + 1, z + 1, t + 1) #print c, z, t numberedtitle = \ title + "_c" + IJ.pad(c, 2) + \ "_z" + IJ.pad(z, 4) + \ "_t" + IJ.pad(t, 4) + ".tif" stackindex = save_imp.getStackIndex(c + 1, z + 1, t + 1) aframe = ImagePlus(numberedtitle, save_imp.getStack().getProcessor(stackindex))
def fretCalculations(imp1, nFrame, donorChannel, acceptorChannel, acceptorChannel2, table, gfx1, gfx2, gfx3, gfx4, gfx5, originalTitle): donorImp=extractChannel(imp1, donorChannel, nFrame) acceptorImp=extractChannel(imp1, acceptorChannel, nFrame) acceptorImp2=extractChannel(imp1, acceptorChannel2, nFrame) #push donor and acceptor channels to gpu and threshold them both to remove saturated pixels gfx4=clij2.push(donorImp) gfx5=clij2.push(acceptorImp) gfx6=clij2.create(gfx5) clij2.threshold(gfx4,gfx2, maxIntensity) clij2.binarySubtract(gfx3, gfx2, gfx6) clij2.threshold(gfx5,gfx2, maxIntensity) clij2.binarySubtract(gfx6, gfx2, gfx3) clij2.threshold(gfx3,gfx6, 0.5) clij2.multiplyImages(gfx6, gfx4, gfx2) clij2.multiplyImages(gfx6, gfx5, gfx4) gfx6=clij2.push(acceptorImp2) #donor is gfx2, acceptor FRET is gfx4, segment channel (acceptor normal) is gfx6 results=ResultsTable() clij2.statisticsOfBackgroundAndLabelledPixels(gfx2, gfx1, results) donorChIntensity=results.getColumn(13) results2=ResultsTable() clij2.statisticsOfBackgroundAndLabelledPixels(gfx4, gfx1, results2) acceptorChIntensity=results2.getColumn(13) results3=ResultsTable() clij2.statisticsOfBackgroundAndLabelledPixels(gfx6, gfx1, results3) #calculate the fret ratios, removing any ROI with intensity of zero FRET =[] for i in xrange(len(acceptorChIntensity)): if (acceptorChIntensity[i]>0) and (donorChIntensity[i]>0): #don't write in the zeros to the results FRET.append((1000*acceptorChIntensity[i]/donorChIntensity[i])) table.incrementCounter() table.addValue("Frame (Time)", nFrame) table.addValue("Label", i) table.addValue("Emission ratio", acceptorChIntensity[i]/donorChIntensity[i]) table.addValue("Mean donor emission", results.getValue("MEAN_INTENSITY",i)) table.addValue("Mean acceptor emission (FRET)", results2.getValue("MEAN_INTENSITY",i)) table.addValue("Mean acceptor emission", results3.getValue("MEAN_INTENSITY",i)) table.addValue("Sum donor emission", donorChIntensity[i]) table.addValue("Sum acceptor emission (FRET)", acceptorChIntensity[i]) table.addValue("Sum acceptor emission", results3.getValue("SUM_INTENSITY",i)) table.addValue("Volume", cal.pixelWidth * cal.pixelHeight * cal.pixelDepth * results.getValue("PIXEL_COUNT",i)) table.addValue("Pixel count", results.getValue("PIXEL_COUNT",i)) table.addValue("x", cal.pixelWidth*results.getValue("CENTROID_X",i)) table.addValue("y", cal.pixelHeight*results.getValue("CENTROID_Y",i)) table.addValue("z", cal.pixelDepth*results.getValue("CENTROID_Z",i)) table.addValue("File name", originalTitle) else: #must write in the zeros as this array is used to generate the map of emission ratios FRET.append(0) table.show("Results of " + originalTitle) FRET[0]=0 FRETarray= array( "f", FRET) fp= FloatProcessor(len(FRET), 1, FRETarray, None) FRETImp= ImagePlus("FRETImp", fp) gfx4=clij2.push(FRETImp) clij2.replaceIntensities(gfx1, gfx4, gfx5) maxProj=clij2.create(gfx5.getWidth(), gfx5.getHeight(), 1) clij2.maximumZProjection(gfx5, maxProj) #pull the images FRETimp2=clij2.pull(gfx5) FRETProjImp=clij2.pull(maxProj) labelImp = clij2.pull(gfx1) clij2.clear() donorImp.close() acceptorImp.close() acceptorImp2.close() return table, FRETimp2, FRETProjImp, labelImp
# Capture RGB movie from stack, including ROIs and overlays from ij import IJ, ImageStack, ImagePlus from ij.process import ColorProcessor from java.awt.image import BufferedImage as BI from java.lang import Thread f = ImagePlus.getDeclaredField("listeners") f.setAccessible(True) listeners = f.get(None) imp = IJ.getImage() canvas = imp.getWindow().getCanvas() # Define range of slices to capture slices = xrange(1, imp.getNSlices() + 1) w, h = canvas.getWidth(), canvas.getHeight() capture = ImageStack(w, h) for i in slices: imp.setSlice(i) for l in listeners: l.imageUpdated(imp) Thread.sleep(50) # wait for repaints to happen, triggered by listeners, if any. bi = BI(w, h, BI.TYPE_INT_ARGB) g = bi.createGraphics() canvas.paint(g) g.dispose() capture.addSlice(ColorProcessor(bi))
# (watershed segmentation), some segmentation lines # may be improperly placed if local maxima are suppressed # by the tolerance. mf = MaximumFinder() if output_type == 'Single_Points': output_type_param = mf.SINGLE_POINTS elif output_type == 'Maxima_Within_Tolerance': output_type_param = mf.IN_TOLERANCE elif output_type == 'Segmented_Particles': output_type_param = mf.SEGMENTED elif output_type == 'List': output_type_param = mf.LIST elif output_type == 'Count': output_type_param = mf.COUNT # Get a new byteProcessor with a normal (uninverted) LUT where # the marked points are set to 255 (Background 0). Pixels outside # of the roi of the input image_processor_copy are not set. No # output image is created for output types POINT_SELECTION, LIST # and COUNT. In these cases findMaxima returns null. byte_processor = mf.findMaxima(image_processor_copy, noise_tolerance, ImageProcessor.NO_THRESHOLD, output_type_param, exclude_edge_maxima, False) # Invert the image or ROI. byte_processor.invert() if output_type == 'Segmented_Particles' and not light_background: # Invert the values in this image's LUT (indexed color model). byte_processor.invertLut() image_plus = ImagePlus("output", byte_processor) IJ.saveAs(image_plus, output_datatype, tmp_output_path)
A = SimpleMatrix(s) #ejml matrix B = SimpleMatrix.transpose(A.divide(A.normF())) # normalize source R = SimpleMatrix.transpose(B.svd().getU().negative( )) # Rotation matrix from SVD decomposition of source color c_suv = R.mult(D).getMatrix().data # Rotate RGB #Fiddly stuff to divide data array into SUV components L1 = [ c_suv[i:i + imp2.height * imp2.width] for i in range(0, len(c_suv), imp2.height * imp2.width) ] # \\J\\, two channel diffuse color vector. See Mallick et al. Beyond Lambert: Reconstructing Specular Surfaces Using Color J1 = [val * val for val in L1[1]] J2 = [val * val for val in L1[2]] J = [math.sqrt(x + y) for x, y in zip(J1, J2)] # arrays into images S = ImagePlus("S", FloatProcessor(imp2.height, imp2.width, L1[0])) U = ImagePlus("U", FloatProcessor(imp2.height, imp2.width, L1[1])) V = ImagePlus("V", FloatProcessor(imp2.height, imp2.width, L1[2])) JNorm = ImagePlus("two channel diffuse color vector", FloatProcessor(imp2.height, imp2.width, J)) #S.show() #U.show() #V.show() JNorm.show( ) # two channel diffuse color vector show, uncomment for SUV components
def testImageJ(imp): return ImagePlus("HSB stack", imp.getProcessor().getHSBStack())
if not os.path.exists(resultPrefix): resultPrefix = IJ.getDirectory("home") resultPrefix = resultPrefix + "/Results" # for all the frames in the movie, run "Analyze Skeleton (2D/3D)" (maybe # later in multiple threads) newStack = ImageStack(imp.getWidth(), imp.getHeight()) # getNFrames not getNSlices since input data is a 2D time series stack # NOT a 3D stack. frameCount = imp.getNFrames() # Remember: a python range (1, 10) is the numbers 1 to 9! for i in range(1, frameCount + 1): slice = ImagePlus(str(i), stack.getProcessor(i)) # Execute plugin exactly on this slice i IJ.run(slice, "Analyze Skeleton (2D/3D)", "") image = WindowManager.getCurrentImage() IJ.saveAs("Measurements", resultPrefix + str(i) + ".xls") # concatenate the new tagged image onto the end of the tagged image stack we # want in the end, but not if its then 1st one! newStack.addSlice("", image.getProcessor().getPixels()) if i == 1: newStack.setColorModel(image.getProcessor().getColorModel()) image.close() image = ImagePlus("TaggedMovie", newStack) image.show()
yoffset = imp.getHeight() ip = out.getProcessor() size = 5 off = int(Math.floor(size/2) + 1) for i in range(len(data)): if i < 1: continue # if i > 20: # break frame = float(data.get(i)[2]) # nextframe = float(data.get(i+1)[2]) # if nextframe - frame < 1: # print str(i), 'trackend' # else: #print str(i), 'in track' x1 = int(round(float(data.get(i)[13]) / xscale)) y1 = int(round(float(data.get(i)[14]) / xscale)) z1 = int(round(float(data.get(i)[15]) / xscale)) ip.setColor(Color(255, 100, 100)) ip.drawOval(x1-off, y1-off, size, size) ip.drawOval(x1-off, yoffset + z1 -off, size, size) ip.drawOval(xoffset + z1 -off, y1 - off, size, size) # plot outimp = ImagePlus(os.path.basename(filename)+'_Out.tif', ip) outimp.show()
# Assumes all files have the same size ImStack = None for root, directories, filenames in os.walk(sourceDir): for filename in filenames: # Skip non-TIFF files if not filename.endswith(".tif"): continue path = os.path.join(root, filename) # Upon finding the first image, initialize the VirtualStack if ImStack is None: imp = IJ.openImage(path) ImStack = VirtualStack(imp.width, imp.height, None, sourceDir) # Add a slice, relative to the sourceDIr ImStack.addSlice(path[len(sourceDir):]) OnscreenImage = ImagePlus(sourceDir,ImStack) OnscreenImage.show() print "Generating MIP, waiting..." outimp = maxZprojection(OnscreenImage) outimp.show() print "Max projection generated" #@ String (label="Would you like to save the max proj? y = save, anything else = don't save", description="Save as") SaveQuery #@output String greeting print SaveQuery savename = sourceDir+"_MIP.tif" if SaveQuery.upper=='Y': #@ String (label="Would you like to rename the max proj? (if not, will use directory name+MIP). y = yes, otherwise no", description="Save as rename") RenameQuery #@output String greeting
else: xradius = gd.getNextNumber() yradius = gd.getNextNumber() zradius = gd.getNextNumber() return canProceed # Get active image and store it in the variable 'img' img = WindowManager.getCurrentImage() # Can we proceed? if getSettings(img): # Get the image stack within the ImagePlus of img stack = img.getStack() # Instantiate ij.plugin.Filters3D f3d = Filters3D() # Retrieve filtered stack newStack = f3d.filter(stack, f3d.MEDIAN, xradius, yradius, zradius) # Construct a new ImagePlus from the stack fImg = ImagePlus("Filtered_"+img.getTitle(), newStack); # Other processing could go here (...) #IJ.run(fImg, "Shen-Castan Edge Detector", "coefficient=0.50"); # Display result fImg.show()
def from32To8Bit(imPath): im = IJ.openImage(imPath) im.getProcessor().setMinAndMax(0,255) im = ImagePlus(im.getTitle(),im.getProcessor().convertToByteProcessor()) IJ.save(im,imPath)
def PrepareDatabase(minw, maxw, baseDir, aspectRatio, majorWidth, majorHeight): outputpath = baseDir + "/" + str(majorWidth) + "_" + str(majorHeight) + "_orig.tif" #initialize stacks and labels stackScaled = [] stackOrig = ImageStack(majorWidth, majorHeight) imageNames = [] for i in range(minw, maxw+1): stackScaled.append(ImageStack(i, int(round(i/aspectRatio, 0)))) imageNames.append('') counter = 0 # initialize zip file for originals zf = zipfile.ZipFile(baseDir + "/originals.zip", mode='w', compression=zipfile.ZIP_DEFLATED, allowZip64=1) zf.writestr('from_string.txt', 'hello') zf.close() zf = zipfile.ZipFile(baseDir + "/originals.zip", mode='a', compression=zipfile.ZIP_DEFLATED, allowZip64=1) for root, dirs, files in os.walk(str(baseDir)): for f1 in files: if f1.endswith(".jpg") or f1.endswith(".jpe") or f1.endswith(".jpeg"): id = root + "/" + f1 IJ.redirectErrorMessages() IJ.redirectErrorMessages(1) imp = IJ.openImage(id) if imp is None: print "Couldn\'t open image from file:", id continue # skip non RGBimages if imp.getProcessor().getNChannels() != 3: print "Converting non RGB image:", id if imp.getStackSize() > 1: StackConverter(imp).convertToRGB() else: ImageConverter(imp).convertToRGB() #skip images with different aspect ratio width = imp.getWidth() height = imp.getHeight() ratio = round(float(width)/float(height), 2) # this makes the ratio filering approximate, minor variations in image dimensions will be ignored if ratio != aspectRatio: IJ.log("Skipping image of size: " + str(width) + "," + str(height)) continue # now scale the image within a given range scale = Scale(imp.getProcessor()) IJ.log("Scaling image " + str(counter) + " " + str(id)) for i in range(minw, maxw+1): stackScaled[i-minw].addSlice(None, ScaleImageToSize(scale, i, int(round(i/aspectRatio, 0)))) imageNames[i-minw] += str(id) + ";" # save the originals to a temp directory scaledOrig = ImagePlus(None, ScaleImageToSize(scale, majorWidth, majorHeight)) SaveToZip(zf, scaledOrig, baseDir, counter) counter += 1 zf.close() # save the stacks for i in range(minw, maxw+1): impScaled = ImagePlus(str(minw) + "_" + str(int(round(i/aspectRatio, 0))), stackScaled[i-minw]) impScaled.show() #print imageNames impScaled.setProperty('Info', imageNames[i-minw][:-1]) fs = FileSaver(impScaled) filepath = baseDir + "/" + str(i) + "_" + str(int(round(i/aspectRatio, 0))) + ".tif" IJ.log("Saving output stack" + str(filepath)) fs.saveAsTiffStack(filepath) #IJ.save(impScaled, filepath); IJ.log("Done")
def CreateCover(ip, width, height, dbpath): # split input image into appropriate tiles stackt = SplitImage(ip, width, height) impt = ImagePlus("template", stackt) nSlicestmp = impt.getNSlices() # open the preprocessed database print dbpath impd = IJ.openImage(dbpath) stackd = impd.getImageStack() nSlicesdb = impd.getNSlices() #associate index with image names imageNames = impd.getProperty('Info') imageList = imageNames.split(';') # set up preview output outputip = ColorProcessor(ip.width, ip.height) outputimp = ImagePlus("output", outputip) outputimp.show() cols = ip.width / width rows = ip.height / height print str(cols) + "," + str(rows) x = 0 y = 0 arrays = [None, None] # a list of two elements tileNames = {} tileIndex = {} placed = {} used = {} while len(placed) < nSlicestmp: randomTileIndex = random.randint(1, nSlicestmp) if randomTileIndex in placed: continue # transform to row adn column coordinate if randomTileIndex % rows == 0: y = rows - 1 x = (randomTileIndex / rows) - 1 else: y = (randomTileIndex % rows) - 1 x = int(randomTileIndex / rows) pixelst = stackt.getPixels(randomTileIndex) minimum = Float.MAX_VALUE #iterate through database images j = 1 indexOfBestMatch = 0 arrays[0] = pixelst while j < nSlicesdb: if j in used: j += 1 continue arrays[1] = stackd.getPixels(j) diff = CoverMakerUtils.tileTemplateDifference(arrays) if diff < minimum: minimum = diff indexOfBestMatch = j j += 1 ip = stackd.getProcessor(indexOfBestMatch) outputip.copyBits(ip, x * width, y * height, 0) used[indexOfBestMatch] = 1 tileNames[randomTileIndex] = imageList[indexOfBestMatch - 1] tileIndex[randomTileIndex] = indexOfBestMatch - 1 outputimp.draw() placed[randomTileIndex] = 1 return tileNames, tileIndex, cols, rows
from ij import IJ, ImagePlus from ij.process import FloatProcessor from array import zeros from random import random from ij.gui import Roi, PolygonRoi # Create a new ImagePlus filled with noise width = 1024 height = 1024 pixels = zeros('f', width * height) for i in xrange(len(pixels)): pixels[i] = random() fp = FloatProcessor(width, height, pixels, None) imp = ImagePlus("Random", fp) # Fill a rectangular region of interest # with a value of 2: roi = Roi(400, 200, 400, 300) fp.setRoi(roi) fp.setValue(2.0) fp.fill() # Fill a polygonal region of interest # with a value of -3 xs = [234, 174, 162, 102, 120, 123, 153, 177, 171, 60, 0, 18, 63, 132, 84, 129, 69, 174, 150, 183, 207, 198, 303, 231, 258, 234, 276, 327, 378, 312, 228, 225, 246, 282, 261, 252] ys = [48, 0, 60, 18, 78, 156, 201, 213, 270, 279,
# Duplicate a hyperstack reducing dimensionality in the Z axis, # opening a new stack with XYT (no Z). from ij import IJ, ImagePlus, ImageStack imp = IJ.getImage() stack1 = imp.getStack() # Fixed Z position slice_index = imp.getSlice()# 1-based stack2 = ImageStack(imp.getWidth(), imp.getHeight()) for frame_index in xrange(imp.getNFrames()): i = frame_index * imp.getNSlices() + slice_index stack2.addSlice(str(frame_index), stack1.getPixels(i)) ImagePlus(imp.getTitle() + " - fixed Z=" + str(slice_index), stack2).show()
def main(): try: # Retrieve valid data rt = Utils.getTable(); start = time.time() # Retrive x,y,t positions (all in unc. units) x = getColumn(rt, X_POS_HEADING) y = getColumn(rt, Y_POS_HEADING) t = getColumn(rt, T_POS_HEADING) # Retrieve the total n. of tracks track_ids = getColumn(rt, ID_HEADING) track_ids = [int(i) for i in track_ids] n_tracks = track_ids[-1] log("Tracks to be analyzed: ", n_tracks) except: IJ.error("Invalid Results Table") return # Create "nan"-padded tables to hold results detail_rt = new_Table() # Extract individual tracks and determine the track with the # largest data (i.e., the one with the highest number of rows) track_row = 0 max_track_row = 0 for i in range(0, rt.getCounter()-1): track_label = str(track_ids[i]) if (track_ids[i]==track_ids[i+1]): dx = (x[i+1]-x[i])**2 dy = (y[i+1]-y[1])**2 dt = t[i+1]-t[i] dis = math.sqrt(dx+dy) vel = dis/dt if (track_row>max_track_row): max_track_row = track_row # Log to "detailed" table if (i<=max_track_row): detail_rt.incrementCounter() detail_rt.setValue("Dis_" + track_label, track_row, dis) detail_rt.setValue("Vel_" + track_label, track_row, vel) detail_rt.setValue("Dur_" + track_label, track_row, dt) detail_rt.setValue("Flag_" + track_label, track_row, RESTING_FLAG if vel < restingVelocity else MOVING_FLAG) track_row += 1 else: # Analyzed track just ended: Reset loop variables and create column # to hold bout flags track_row = 0 detail_rt.setValue("BoutFlag_" + track_label, 0, float("nan")) detail_rt.setValue("Mov_Dur_" + track_label, 0, float("nan")) detail_rt.setValue("Rest_Dur_" + track_label, 0, float("nan")) log("Extracting track ", track_label) listOfRasterPaths = [] # List holding raster tracks # Loop through individual tracks and tag each datapoint (i.e., each row) for track in range(0, n_tracks): durHeading = "Dur_" + str(track) fFlagHeading = "Flag_" + str(track) bFlagHeading = "BoutFlag_" + str(track) mDurHeading = "Mov_Dur_" + str(track) rDurHeading = "Rest_Dur_" + str(track) durations = getColumn(detail_rt, durHeading) fFlags = getColumn(detail_rt, fFlagHeading) bFlags = getColumn(detail_rt, bFlagHeading) nDataPoints = findLastNonNumberIdx(durations) + 1 log("Tagging track ", track, ": ", nDataPoints , " positions") for row in range(0, nDataPoints): # Define the boundaries of the moving window. "Stopping flags" # within this window will be monitoried to define a motionless bout # NB: Boundaries are defined from the rows of the input table. This # works only when the time elapsed betwen two rows is a single frame. # So we'll have to monitor the actual time that has elapsed within the # bounderies of the window lower_bound = max(0, row - neighborhood + 1) upper_bound = min(nDataPoints, row+neighborhood) sum_of_flags = 0 sum_of_frames = 0 neighborhood_sum = upper_bound - lower_bound for i in xrange(lower_bound, upper_bound): if isNumber(durations[i]) and isNumber(fFlags[i]): sum_of_flags += (fFlags[i] * durations[i]) sum_of_frames += durations[i] if sum_of_frames >= neighborhood_sum: break # Assign this tracked point to its bout moving_bout_duration = float("nan") resting_bout_duration = float("nan") bout_flag = float("nan") if sum_of_flags >= neighborhood_sum: bout_flag = MOVING_FLAG moving_bout_duration = durations[row] else: bout_flag = RESTING_FLAG resting_bout_duration = durations[row] detail_rt.setValue(bFlagHeading, row, bout_flag) detail_rt.setValue(mDurHeading, row, moving_bout_duration) detail_rt.setValue(rDurHeading, row, resting_bout_duration) if generateRasterTracks: # Generate raster column if path is long enough if nDataPoints > shortestRasterTrack: # Retrieve updated column of bout flags bFlags = getColumn(detail_rt, bFlagHeading) # Generate raster column (motion-flags temporally aligned, all 1 # frame apart) until the path duration reaches the maximum limit keepGrowingRasterPath = True for idx, duration in enumerate(durations): if (keepGrowingRasterPath): flag = bFlags[idx] for insertIdx in range(1, int(duration)): if (len(bFlags)==longestRasterTrack): keepGrowingRasterPath = False break bFlags.insert(idx+insertIdx, flag) # Store only lists without NaN values listOfRasterPaths.append(bFlags[:findLastNonNumberIdx(bFlags)]) # Allow analysis to be interrupted if IJ.escapePressed(): break # Display table. Displaying it now may ensure all tracks are padded with "NaN" if (displayDetailedTable): detail_rt.show("Track_Details["+ str(restingVelocity) +"-"+ str(neighborhood) +"]") # Now that all paths are contained in listOfRasterPaths. Sort them by length of track listOfRasterPaths = sorted(listOfRasterPaths, key = len) # Create Image of analysis. We'll create it from a ResultsTable. It would be much # more efficient to generate a text image directly, but this allows the table to be # processed elsewhere if needed. In IJ1, column headings of a ResultsTable must be # unique, so we will use distinct identifiers if generateRasterTracks: raster_rt = new_Table() log('Tracks to be rendered:', len(listOfRasterPaths)) for rasterPath in xrange(len(listOfRasterPaths)): log("Rendering track ", rasterPath) for row, raster_flag in enumerate(listOfRasterPaths[rasterPath]): if not isNumber(raster_flag): break if (row>raster_rt.getCounter()-1): raster_rt.incrementCounter() # Create upper border: 1 px-wide bColor = borderColor if isNumber(raster_flag) else backgroundColor raster_rt.setValue("Delim1_" + str(rasterPath), row, bColor) # Create raster path: 18 px wide raster_flag_color = colorizeFlag(raster_flag) for i in 'abcdefghijklmnopq': raster_rt.setValue("Raster_" + str(rasterPath) + str(i), row, raster_flag_color) # Create lower border: 1 px-wide raster_rt.setValue("Delim2_" + str(rasterPath), row, bColor) # Append padding space between tracks: 10px wide for j in 'abcdefghij': raster_rt.setValue("Space_" + str(rasterPath) + str(j), row, backgroundColor) # Allow analysis to be interrupted if IJ.escapePressed(): break # Display table of rasterized tracks if displayRasterTable: raster_rt.show("RasterTracks["+ str(restingVelocity) +"-"+ str(neighborhood ) +"]") # Display image of rasterized tracks ip = raster_rt.getTableAsImage().rotateLeft() paintNaNpixels(ip, backgroundColor) ip = ip.convertToByte(False) imp = ImagePlus("RasterTracks["+ str(restingVelocity) +"-"+ str(neighborhood ) +"]", ip) imp.show() ## Add scale-bar for time IJ.run(imp, "Set Scale...", "distance=1 known="+ str(frameCal[0]) +" unit="+ frameCal[1]); IJ.run(imp, "Scale Bar...", "width=10 color=Black location=[Lower Right] overlay"); # Loop through individual tracks and extract some basic statistics. Most of these parameters # are already retrieved by Trackmate. We calculate them here just for convenience track_ids = [] # List holding the track identifier sum_distances = [] # List holding the track's total distance sum_durations = [] # List holding the track's total duration max_speeds = [] # List holding the track's Max speed min_speeds = [] # List holding the track's Min speed sum_n_rests = [] # List holding the number of resting bouts in each track sum_n_moves = [] # List holding the number of moving bouts in each track sum_dur_rests = [] # List holding the total resting time of each tracked object sum_dur_moves = [] # List holding the total moving time of each tracked object log("Logging Summaries...") summary_rt = new_Table() for track in range(0, n_tracks): # Retrieve and store the track identifier track_id = str(track) track_ids.insert(track, "Track_"+track_id) # Retrive tracking data distances = getColumn(detail_rt, "Dis_" + track_id) durations = getColumn(detail_rt, "Dur_" + track_id) velocities = getColumn(detail_rt, "Vel_" + track_id) mov_durations = getColumn(detail_rt, "Mov_Dur_" + track_id) rest_durations = getColumn(detail_rt, "Rest_Dur_" + track_id) # Reset stats for this track track_sum_dis = 0 track_sum_dur = 0 track_max_vel = 0 track_min_vel = sys.maxint track_sum_move = 0 track_sum_rest = 0 track_n_moves = 0 track_n_rests = 0 # Compute basic stats and store them in dedicated lists nDataPoints = findLastNonNumberIdx(distances) + 1 for row in xrange(nDataPoints): track_sum_dis += distances[row] track_sum_dur += durations[row] if (velocities[row]>track_max_vel): track_max_vel = velocities[row] if (velocities[row]<track_min_vel): track_min_vel = velocities[row] if isNumber(mov_durations[row]): track_sum_move += mov_durations[row] if isNumber(rest_durations[row]): track_sum_rest += rest_durations[row] sum_distances.insert(track, track_sum_dis) sum_durations.insert(track, track_sum_dur) max_speeds.insert(track, track_max_vel) min_speeds.insert(track, track_min_vel) sum_dur_moves.insert(track, track_sum_move) sum_dur_rests.insert(track, track_sum_rest) # Assess the number of moving/resting bouts in this track for row in xrange(nDataPoints-1): if isNumber(mov_durations[row]) and not isNumber(mov_durations[row+1]): track_n_moves += 1 if isNumber(rest_durations[row]) and not isNumber(rest_durations[row+1]): track_n_rests += 1 # Predict cases in which bouts lasted entire track duration if track_n_moves==0 and track_sum_dur==track_sum_move: track_n_moves += 1 if track_n_rests==0 and track_sum_dur==track_sum_rest: track_n_rests += 1 sum_n_moves.insert(track, track_n_moves) sum_n_rests.insert(track, track_n_rests) # Log summary data for i in range(0, n_tracks): # Ignore tracks shorter than neighborhood if hideShortTracks and sum_durations[i]<neighborhood: continue row = summary_rt.getCounter() summary_rt.incrementCounter() summary_rt.setLabel(track_ids[i], row) summary_rt.setValue("Total dx", row, sum_distances[i]) summary_rt.setValue("Duration", row, sum_durations[i]) summary_rt.setValue("Max speed", row, max_speeds[i]) summary_rt.setValue("Min speed", row, min_speeds[i]) summary_rt.setValue("Moving dur", row, sum_dur_moves[i]) summary_rt.setValue("Resting dur", row, sum_dur_rests[i]) summary_rt.setValue("Resting %", row, 100 * sum_dur_rests[i] / sum_durations[i]) summary_rt.setValue("Moving bouts", row, sum_n_moves[i]) summary_rt.setValue("Resting bouts", row, sum_n_rests[i]) if sum_n_moves[i]!=0: summary_rt.setValue("Avg moving bout dur", row, sum_dur_moves[i] / sum_n_moves[i]) if sum_n_rests[i]!=0: summary_rt.setValue("Avg resting bout dur", row, sum_dur_rests[i] / sum_n_rests[i]) summary_rt.show("Track_Summaries["+ str(restingVelocity) +"-"+ str(neighborhood) +"]") log("Finished: ", time.time()-start, " seconds")
# Input parameters N = 500 # number of pixels L = 532*0.000000001 # wavelength in nm w = 0.002 # width field of view z = 0.05 # z step in meter imp = IJ.getImage() #synthetic amplitude and phase am = [math.exp(-1.6*val) for val in imp.getProcessor().getPixels()] ph = [-3*val for val in imp.getProcessor().getPixels()] t = [x*cmath.exp(-1j*y) for x, y in zip(am, ph)] real = ImagePlus("real", FloatProcessor(N,N,[val.real for val in t])) imaginary = ImagePlus("IMAGINARY", FloatProcessor(N,N,[val.imag for val in t])) fft_1 = fft.fft(real,imaginary,N,N) #projection to detector plane z = Propagator.Zone(L, N, z, w) real2 = [(x * y).real for x , y in zip(fft_1, [val.conjugate() for val in z])] imag2 = [(x * y).imag for x , y in zip(fft_1, [val.conjugate() for val in z])] R2 = ImagePlus("real", FloatProcessor(N, N, real2, None)) I2 = ImagePlus("imaginary", FloatProcessor(N, N, imag2, None)) ifft_1 = fft.ifft(R2,I2,N,N) #amplitude at detector plane
def create_registered_hyperstack(imp, channel, target_folder, virtual): """ Takes the imp, determines the x,y,z drift for each pair of time points, using the preferred given channel, and outputs as a hyperstack.""" shifts = compute_frame_translations(imp, channel) # Make shifts relative to 0,0,0 of the original imp: shifts = concatenate_shifts(shifts) print "shifts concatenated:" for s in shifts: print s.x, s.y, s.z # Compute bounds of the new volume, # which accounts for all translations: minx, miny, minz, maxx, maxy, maxz = compute_min_max(shifts) # Make shifts relative to new canvas dimensions # so that the min values become 0,0,0 for shift in shifts: shift.x -= minx shift.y -= miny shift.z -= minz print "shifts relative to new dimensions:" for s in shifts: print s.x, s.y, s.z # new canvas dimensions: width = imp.width + maxx - minx height = maxy - miny + imp.height slices = maxz - minz + imp.getNSlices() print "New dimensions:", width, height, slices # Prepare empty slice to pad in Z when necessary empty = imp.getProcessor().createProcessor(width, height) # if it's RGB, fill the empty slice with blackness if isinstance(empty, ColorProcessor): empty.setValue(0) empty.fill() # Write all slices to files: stack = imp.getStack() if virtual is False: registeredstack = ImageStack(width, height, imp.getProcessor().getColorModel()) names = [] for frame in range(1, imp.getNFrames()+1): shift = shifts[frame-1] fr = "t" + zero_pad(frame, len(str(imp.getNFrames()))) # Pad with empty slices before reaching the first slice for s in range(shift.z): ss = "_z" + zero_pad(s + 1, len(str(slices))) # slices start at 1 for ch in range(1, imp.getNChannels()+1): name = fr + ss + "_c" + zero_pad(ch, len(str(imp.getNChannels()))) +".tif" names.append(name) if virtual is True: currentslice = ImagePlus("", empty) currentslice.setCalibration(imp.getCalibration().copy()) currentslice.setProperty("Info", imp.getProperty("Info")) FileSaver(currentslice).saveAsTiff(target_folder + "/" + name) else: empty = imp.getProcessor().createProcessor(width, height) registeredstack.addSlice(str(name), empty) # Add all proper slices stack = imp.getStack() for s in range(1, imp.getNSlices()+1): ss = "_z" + zero_pad(s + shift.z, len(str(slices))) for ch in range(1, imp.getNChannels()+1): ip = stack.getProcessor(imp.getStackIndex(ch, s, frame)) ip2 = ip.createProcessor(width, height) # potentially larger ip2.insert(ip, shift.x, shift.y) name = fr + ss + "_c" + zero_pad(ch, len(str(imp.getNChannels()))) +".tif" names.append(name) if virtual is True: currentslice = ImagePlus("", ip2) currentslice.setCalibration(imp.getCalibration().copy()) currentslice.setProperty("Info", imp.getProperty("Info")); FileSaver(currentslice).saveAsTiff(target_folder + "/" + name) else: registeredstack.addSlice(str(name), ip2) # Pad the end for s in range(shift.z + imp.getNSlices(), slices): ss = "_z" + zero_pad(s + 1, len(str(slices))) for ch in range(1, imp.getNChannels()+1): name = fr + ss + "_c" + zero_pad(ch, len(str(imp.getNChannels()))) +".tif" names.append(name) if virtual is True: currentslice = ImagePlus("", empty) currentslice.setCalibration(imp.getCalibration().copy()) currentslice.setProperty("Info", imp.getProperty("Info")) FileSaver(currentslice).saveAsTiff(target_folder + "/" + name) else: registeredstack.addSlice(str(name), empty) if virtual is True: # Create virtual hyper stack with the result registeredstack = VirtualStack(width, height, None, target_folder) for name in names: registeredstack.addSlice(name) registeredstack_imp = ImagePlus("registered time points", registeredstack) registeredstack_imp.setDimensions(imp.getNChannels(), len(names) / (imp.getNChannels() * imp.getNFrames()), imp.getNFrames()) registeredstack_imp.setCalibration(imp.getCalibration().copy()) registeredstack_imp.setOpenAsHyperStack(True) else: registeredstack_imp = ImagePlus("registered time points", registeredstack) registeredstack_imp.setCalibration(imp.getCalibration().copy()) registeredstack_imp.setProperty("Info", imp.getProperty("Info")) registeredstack_imp.setDimensions(imp.getNChannels(), len(names) / (imp.getNChannels() * imp.getNFrames()), imp.getNFrames()) registeredstack_imp.setOpenAsHyperStack(True) if 1 == registeredstack_imp.getNChannels(): return registeredstack_imp IJ.log("\nHyperstack dimensions: time frames:" + str(registeredstack_imp.getNFrames()) + ", slices: " + str(registeredstack_imp.getNSlices()) + ", channels: " + str(registeredstack_imp.getNChannels())) # Else, as composite mode = CompositeImage.COLOR; if isinstance(imp, CompositeImage): mode = imp.getMode() else: return registeredstack_imp return CompositeImage(registeredstack_imp, mode)
def register_hyperstack(imp, channel, shifts, target_folder, virtual): """ Takes the imp, determines the x,y,z drift for each pair of time points, using the preferred given channel, and outputs as a hyperstack.""" # Compute bounds of the new volume, # which accounts for all translations: minx, miny, minz, maxx, maxy, maxz = compute_min_max(shifts) # Make shifts relative to new canvas dimensions # so that the min values become 0,0,0 for shift in shifts: shift.x -= minx shift.y -= miny shift.z -= minz #print "shifts relative to new dimensions:" #for s in shifts: # print s.x, s.y, s.z # new canvas dimensions:r width = imp.width + maxx - minx height = maxy - miny + imp.height slices = maxz - minz + imp.getNSlices() print "New dimensions:", width, height, slices # Prepare empty slice to pad in Z when necessary empty = imp.getProcessor().createProcessor(width, height) # if it's RGB, fill the empty slice with blackness if isinstance(empty, ColorProcessor): empty.setValue(0) empty.fill() # Write all slices to files: stack = imp.getStack() if virtual is False: registeredstack = ImageStack(width, height, imp.getProcessor().getColorModel()) names = [] for frame in range(1, imp.getNFrames()+1): shift = shifts[frame-1] print "frame",frame,"correcting drift",-shift.x-minx,-shift.y-miny,-shift.z-minz IJ.log(" frame "+str(frame)+" correcting drift "+str(-shift.x-minx)+","+str(-shift.y-miny)+","+str(-shift.z-minz)) fr = "t" + zero_pad(frame, len(str(imp.getNFrames()))) # Pad with empty slices before reaching the first slice for s in range(shift.z): ss = "_z" + zero_pad(s + 1, len(str(slices))) # slices start at 1 for ch in range(1, imp.getNChannels()+1): name = fr + ss + "_c" + zero_pad(ch, len(str(imp.getNChannels()))) +".tif" names.append(name) if virtual is True: currentslice = ImagePlus("", empty) currentslice.setCalibration(imp.getCalibration().copy()) currentslice.setProperty("Info", imp.getProperty("Info")) FileSaver(currentslice).saveAsTiff(target_folder + "/" + name) else: empty = imp.getProcessor().createProcessor(width, height) registeredstack.addSlice(str(name), empty) # Add all proper slices stack = imp.getStack() for s in range(1, imp.getNSlices()+1): ss = "_z" + zero_pad(s + shift.z, len(str(slices))) for ch in range(1, imp.getNChannels()+1): ip = stack.getProcessor(imp.getStackIndex(ch, s, frame)) ip2 = ip.createProcessor(width, height) # potentially larger ip2.insert(ip, shift.x, shift.y) name = fr + ss + "_c" + zero_pad(ch, len(str(imp.getNChannels()))) +".tif" names.append(name) if virtual is True: currentslice = ImagePlus("", ip2) currentslice.setCalibration(imp.getCalibration().copy()) currentslice.setProperty("Info", imp.getProperty("Info")); FileSaver(currentslice).saveAsTiff(target_folder + "/" + name) else: registeredstack.addSlice(str(name), ip2) # Pad the end for s in range(shift.z + imp.getNSlices(), slices): ss = "_z" + zero_pad(s + 1, len(str(slices))) for ch in range(1, imp.getNChannels()+1): name = fr + ss + "_c" + zero_pad(ch, len(str(imp.getNChannels()))) +".tif" names.append(name) if virtual is True: currentslice = ImagePlus("", empty) currentslice.setCalibration(imp.getCalibration().copy()) currentslice.setProperty("Info", imp.getProperty("Info")) FileSaver(currentslice).saveAsTiff(target_folder + "/" + name) else: registeredstack.addSlice(str(name), empty) if virtual is True: # Create virtual hyper stack with the result registeredstack = VirtualStack(width, height, None, target_folder) for name in names: registeredstack.addSlice(name) registeredstack_imp = ImagePlus("registered time points", registeredstack) registeredstack_imp.setDimensions(imp.getNChannels(), len(names) / (imp.getNChannels() * imp.getNFrames()), imp.getNFrames()) registeredstack_imp.setCalibration(imp.getCalibration().copy()) registeredstack_imp.setOpenAsHyperStack(True) else: registeredstack_imp = ImagePlus("registered time points", registeredstack) registeredstack_imp.setCalibration(imp.getCalibration().copy()) registeredstack_imp.setProperty("Info", imp.getProperty("Info")) registeredstack_imp.setDimensions(imp.getNChannels(), len(names) / (imp.getNChannels() * imp.getNFrames()), imp.getNFrames()) registeredstack_imp.setOpenAsHyperStack(True) if 1 == registeredstack_imp.getNChannels(): return registeredstack_imp #IJ.log("\nHyperstack dimensions: time frames:" + str(registeredstack_imp.getNFrames()) + ", slices: " + str(registeredstack_imp.getNSlices()) + ", channels: " + str(registeredstack_imp.getNChannels())) # Else, as composite mode = CompositeImage.COLOR; if isinstance(imp, CompositeImage): mode = imp.getMode() else: return registeredstack_imp return CompositeImage(registeredstack_imp, mode)