diff --git a/BIOP_Operetta_Import.groovy b/BIOP_Operetta_Import.groovy index f12a1a1..a0412da 100644 --- a/BIOP_Operetta_Import.groovy +++ b/BIOP_Operetta_Import.groovy @@ -1,790 +1,786 @@ //@File(label="Select your directory with your exported images", style="directory") theDir //@Integer(label="Resize Factor", value=1) resize //@Boolean(label="Tile fields in wells", value=true) is_tile //@Boolean(label="Only Process Selected Wells", value=false, persist=false) is_select_wells //@String(label="X Y W H of box to extract", value="") str_xywh // ---------------- DESCRIPTION ----------------- // /* * PERKIN ELMER OPERETTA STITCHER * v4.1, December 2018 * This tool allows for the reshaping (requires resaving) * of tiffs exported with the Operetta Symphony software * so as to be be viewed and processed with Fiji (or other softwares) * as time lapse (stitched or not) * * This tool can export individual fields or tile all fields in each well * to produce a large image stack. * The output is either * - One hyperstack per field per well (CZT) * - One large (tiled) hyperstack per well (CZT) * * For faster export and preview, we offer the possibility to downsample the images before exporting them, * significantly reducing processing time. * * In order to maximize export speed (Especially due to PerkinElmer using zip-compressed TIFFS, * we benefit from the Gpars for parallel processing library, so there are a * few dependencies not bundled with ImageJ/Fiji * See https://c4science.ch/w/bioimaging_and_optics_platform_biop/image-processing/imagej_tools/perkinelmer-stitching/ * For dependencies and instructions * * Authors: Olivier Burri, Romain Guiet * BioImaging and Optics Platform (BIOP) * Ecole Polytechnique Fédérale de Lausanne * * Change Log: * September 2017 : First version that can tile all fields in wells, parallelized * * October 2017 : Added possibility of downsampling * Added the possibility of defining a ROI * Added a GUI to select which wells to export * * December 2017 : Added possibility to save individual fields, which rewrote most of the tool * Changed some naming conventions, discussing with Romain * * January 2018 : Fixed issue where simple stacks could not be saved due to HyperStackConverter error * Added error correction for filename when PE export uses erroneous convention * XML File : r01c01f01p01-ch1sk1fk1fl1.tiff * Actual file : r01c01f001p01-ch1sk1fk1fl1.tiff * Fixed wrong memory calculation. Bug was introduced in December version * * Copyright 2018 Olivier Burri, Romain Guiet * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ // ------------------ IMPORTS ------------------ // import System.* import groovy.util.XmlSlurper import ij.* import ij.gui.* import ij.plugin.* import ij.process.* import ij.measure.Calibration // Play with parallel stuff import groovyx.gpars.GParsPool import groovyx.gpars.GParsExecutorsPool // Number converter import java.text.DecimalFormat // GUI goodness import groovy.swing.SwingBuilder import javax.swing.* import java.awt.* // This is to fix a bug in the way Perkin Elmer export their files... import groovy.io.FileType // ------------------ SCRIPT ------------------ // // Create an instance of the PerkinElmer Opener def pe = new PerkinElmerOpener() // Test mode only processes the first two wells //pe.setTestMode(true) // Selects whether we should assemble all fields or not pe.setDoTile(is_tile) // Set the ROI as needed pe.setROIFromString(str_xywh) - // Parse the file def parser = new Timer("Parser") parser.tic() pe.parseXML(theDir) parser.toc() // If we want to use the GUI, call it here if(is_select_wells) { // Because GUIs in Java are not attached to the main thread // We cannot just call it, wait for user and then process. // the Run button in the GUI is the one that must run the process... pe.selectWellsGUI(resize) } else { // Process all images in parallel def processor = new Timer("Processing") processor.tic() pe.process(resize) // Where the magic happens processor.toc() } // ----------------- CLASSES ----------------- // /* * The big boy that does everything * Which involves 2 steps. * 1. Parsing the xml file * 2. Exporting the selected wells */ class PerkinElmerOpener { - + def is_test = false def is_tile = true def roi = null ExperimentMetadata meta HashSet selected_wells - + // to help format numbers for console output DecimalFormat df = new DecimalFormat("##.##") void setTestMode(boolean is_test) { this.is_test = is_test } void setDoTile(boolean is_tile) { this.is_tile = is_tile } void setROIFromString(String roi_str) { if (roi_str.size() > 7) { def coordinates = roi_str.tokenize(' ').collect{ it.toInteger() } setRoi(new Roi(coordinates[0], coordinates[1], coordinates[2], coordinates[3])) } } void setRoi(Roi roi) { this.roi = roi; } - + // Method to parse the exported XML file and get all the information regarding the experiment void parseXML(File dir) { // ExperimentMetadata contains all the boring stuff to make sense of the PE file and help the extraction of the data meta = new ExperimentMetadata() - + // Set the location of the data to export meta.setParentDirectory(dir) // Parsing XML file def xml = new XmlSlurper().parse(meta.getXMLFile()) // Get the experiment name from Plate ID meta.setExperimentName(xml.Plates.Plate.PlateID.toString()) - + // Get the image size and pixel size meta.setImageSize( xml.Images.Image[0].ImageSizeX.toInteger(), xml.Images.Image[0].ImageSizeY.toInteger() ) - + meta.setPixelSize( xml.Images.Image[0].ImageResolutionX.toDouble() ) - + // From the xml file, create list of informations for each Image def ims = new ArrayList() // Parse all the image data xml.Images.Image.each{ def im = new Image() im.rowcol.add(it.Row.toInteger()) im.rowcol.add(it.Col.toInteger()) im.field = it.FieldID.toInteger() im.channel = it.ChannelID.toInteger() im.slice = it.PlaneID.toInteger() im.timepoint= it.TimepointID.toInteger() im.posx = it.PositionX.toFloat() im.posy = it.PositionY.toFloat() im.posz = it.PositionZ.toFloat() im.toffset = it.MeasurementTimeOffset.toFloat() im.image = it.URL.text() ims.add(im) } - + // Append image data to the metadata meta.setImageData(ims) // BUG: Need the actual files in the folder to fix the naming conventions meta.setFolderFiles() - } - + void process(int resize) { // Need to process the data in the following way // A certain number of fields in parallel, each with a certain number of parallel openings and closings // If processing a tiled dataset, copy the full field to the tile stack // If no tiling, save each field and store their coordinates in a positions.txt file - + // Check how many open images we can work on def max_ram = IJ.maxMemory() / 1e9 * 0.90 - - + + def field_size = meta.getFieldSize(resize) def field_stack_ram_size = meta.getFieldStackSize(resize) def well_size = meta.getWellSize(resize) def well_stack_ram_size = meta.getWellStackSize(resize) - + def fields_per_well = meta.getFieldsPerWell() - + def the_calibration = meta.computeCalibration(resize) - + def czt_dims = meta.getStackCZTDimensions() - - + + def n_planes = meta.getPlanesPerField() // Compute how many fields and wells we can have in parallel int n_planes_parallel int n_wells_parallel if( is_tile ) { // In the case of a tile, for each well we want to process in parallel we need the memory for all the fields and for the full stacks def n_parallel_tiles = Math.round( max_ram / ( field_stack_ram_size * fields_per_well + well_stack_ram_size ) ) n_planes_parallel = fields_per_well n_wells_parallel = n_parallel_tiles > 2 ? n_parallel_tiles : 1 } else { // For fields only, we just need to compute hopw many fields in parallel we can work on def n_fields_raw = Math.round( max_ram / (field_stack_ram_size) ) n_planes_parallel = n_fields_raw > 10 ? 10 : n_fields_raw def n_wells_parallel_raw = Math.round(max_ram / (n_planes_parallel * field_stack_ram_size) ) n_wells_parallel = n_wells_parallel_raw > 2 ? n_wells_parallel_raw : 1 } - + // Output some data to the user via the log IJ.log("One Field of CZT image stack is "+ df.format(field_stack_ram_size) + " GB.") if (is_tile) { IJ.log("One Tiled CZT image stack is "+ df.format(well_stack_ram_size) + " GB.") } IJ.log("There are "+fields_per_well+" fields in each well") IJ.log("And you have "+ (df.format(max_ram) ) + " GB of RAM") IJ.log("--->We will try to work on "+n_wells_parallel+" wells in parallel and "+n_planes_parallel+" extra threads to process your data") - - return + this.selected_wells = meta.getSelectedWells() - + if(this.is_test) { - this.selected_wells = this.selected_wells.take(2) + this.selected_wells = this.selected_wells.take(2) } - + // ExecutorsPool is less optimized than GParsPool but this way we can nest calls :) //GParsExecutorsPool.withPool(nImages) { GParsExecutorsPool.withPool(n_wells_parallel) { selected_wells.eachWithIndexParallel{ well, i -> IJ.log("\nProcessing Well "+well) - + def field_positions = [] def field_stack_names = [] - + def well_stack def well_stack_name = meta.getWellName(well) final def well_image if (is_tile ) { if(roi != null) { def bounds = roi.getBounds() well_stack = ImageStack.create((int)bounds.width, (int)bounds.height, n_planes, 16 ) } else { well_stack = ImageStack.create((int) well_size['x'], (int) well_size['y'], n_planes, 16 ) } // Prepare final ImagePlus here so we can access the getStackIndex function well_image = new ImagePlus(well_stack_name, well_stack) well_image.setDimensions(czt_dims.c, czt_dims.z, czt_dims.t) } - + (1..fields_per_well).each{ field -> def field_stack def field_stack_name = meta.getFieldName(well, field) if(roi != null && !is_tile) { def bounds = roi.getBounds() field_stack = ImageStack.create((int)bounds.width, (int)bounds.height, n_planes, 16 ) } else { field_stack = ImageStack.create((int) field_size['x'], (int) field_size['y'], n_planes, 16 ) } - // Prepare final ImagePlus here so we can access the getStackIndex function - final def field_image = new ImagePlus(field_stack_name, field_stack) - field_image.setDimensions(czt_dims.c, czt_dims.z, czt_dims.t) - // Image name - if(resize != 1) { - field_stack_name+="-Resized "+resize - } - // Name of each field image for saving as tilepositions if needed - field_stack_names[field-1] = field_stack_name - - //Save the position for this field with the name, so as to write the tile configuration file + // Prepare final ImagePlus here so we can access the getStackIndex function + final def field_image = new ImagePlus(field_stack_name, field_stack) + field_image.setDimensions(czt_dims.c, czt_dims.z, czt_dims.t) + // Image name + if(resize != 1) { + field_stack_name+="-Resized "+resize + } + // Name of each field image for saving as tilepositions if needed + field_stack_names[field-1] = field_stack_name + + //Save the position for this field with the name, so as to write the tile configuration file field_positions[field-1] = meta.getPixelCoordinates(field, resize) - - GParsExecutorsPool.withPool(n_planes_parallel) { - meta.getAllCZT().eachParallel { czt -> - - // Get the image matching this CZT + + GParsExecutorsPool.withPool(n_planes_parallel) { + meta.getAllCZT().eachParallel { czt -> + + // Get the image matching this CZT def current_image = meta.findImage(well, czt, field) // The operetta system does not save images in case of failed autofocus for example if(current_image != null) { - + // Open the image print("\nOpening Image "+meta.getParentDirectory() +"/"+ current_image.image.toString()) def current_imp = tryOpening(meta.getParentDirectory() +"/"+ current_image.image.toString()) - + // Had issues with some being null once in a while...? concurrency issue of IJ.openImage()? if(current_imp != null) { // resize the image as requested and add it to the large slice def current_ip = current_imp.getProcessor().resize((int) (field_size['x'])) - + // if a ROI was defined, crop it before adding it if (roi != null && !is_tile) { current_ip.setRoi(roi) current_ip = current_ip.crop() } // Now add this image to the hyperstack - def stack_position = field_image.getStackIndex(czt.getC(), czt.getZ(), czt.getT()+1) - - // We have the position, we can now place the data - field_stack.setProcessor(current_ip, stack_position) + def stack_position = field_image.getStackIndex(czt.getC(), czt.getZ(), czt.getT()+1) + + // We have the position, we can now place the data + field_stack.setProcessor(current_ip, stack_position) current_imp.close() } else { IJ.log("!! Got null image at c:"+czt.getC()+" z:"+czt.getZ()+" t:"+czt.getT()+" for field:" +field+" !!") } - } else { - IJ.log("!! No Image at c:"+czt.getC()+" z:"+czt.getZ()+" t:"+czt.getT()+" for field:" +field+" !!") - } - - }} - - // At this point we have a complete field in field_stack - // Now we either copy it to the larger stack or save it - if (is_tile) { - (1..field_stack.getSize()).each{ slice -> - well_stack.getProcessor(slice).copyBits(field_stack.getProcessor(slice), (int) field_positions[field-1].x, (int) field_positions[field-1].y, Blitter.COPY) - } - print("\n--> Field "+field+" copied to tiled well #"+well+" <--") - } else { - - // Prepare correct dimensions of image, but only if there is at least one non-singleton dimension - if((czt_dims.c+czt_dims.z+czt_dims.t) > 3) - field_image = HyperStackConverter.toHyperStack(field_image, czt_dims.c, czt_dims.z, czt_dims.t, "xyczt", "Composite") - // add calibration - field_image.setCalibration(the_calibration) - - IJ.saveAs(field_image, "Tiff", meta.getSaveDirectory()+"//"+field_stack_name+".tif"); - print("\n----> Field "+field_stack_name+" saved. <----") - field_image.close() - } + } else { + IJ.log("!! No Image at c:"+czt.getC()+" z:"+czt.getZ()+" t:"+czt.getT()+" for field:" +field+" !!") + } + + }} + + // At this point we have a complete field in field_stack + // Now we either copy it to the larger stack or save it + if (is_tile) { + (1..field_stack.getSize()).each{ slice -> + well_stack.getProcessor(slice).copyBits(field_stack.getProcessor(slice), (int) field_positions[field-1].x, (int) field_positions[field-1].y, Blitter.COPY) + } + print("\n--> Field "+field+" copied to tiled well #"+well+" <--") + } else { + // Prepare correct dimensions of image, but only if there is at least one non-singleton dimension + if((czt_dims.c+czt_dims.z+czt_dims.t) > 3) + field_image = HyperStackConverter.toHyperStack(field_image, czt_dims.c, czt_dims.z, czt_dims.t, "xyczt", "Composite") + // add calibration + field_image.setCalibration(the_calibration) + + IJ.saveAs(field_image, "Tiff", meta.getSaveDirectory()+"//"+field_stack_name+".tif"); + print("\n----> Field "+field_stack_name+" saved. <----") + field_image.close() + } + } // Done processing the fields - + // At this point, if this is a tile, we can save the well, or we save the position list if (is_tile) { - + // Prepare correct dimensions of image, but only if there is at least one non-singleton dimension if((czt_dims.c+czt_dims.z+czt_dims.t) > 3) well_image = HyperStackConverter.toHyperStack(well_image, czt_dims.c, czt_dims.z, czt_dims.t, "xyczt", "Composite") - + // add calibration well_image.setCalibration(the_calibration) IJ.saveAs(well_image, "Tiff", meta.getSaveDirectory()+"//"+well_stack_name+".tif"); print("\n---> Well File "+well_stack_name+" saved. <---") well_image.close() } else { def positions_file = new File(meta.getSaveDirectory()+"//"+well_stack_name+"-positions.txt") writePositionsFile(positions_file, field_stack_names, field_positions, meta.is_z) print("\n----> Position File "+positions_file.getName()+" saved. <----") } } } } ImagePlus tryOpening(String path) { /* * As noticed with the dataset of Cody Naricsso, there is an issue with the padding of files if there are more thatn 100 timepoints, fields or Z * XML reports file URL to be r01c01f01p01-ch1sk1fk1fl1.tiff * URL actually ends up being r01c01f001p01-ch1sk1fk1fl1.tiff * * Idea. Match the r c f p strings with regular expressions, convert to int and find other image that matches that int combination */ - + def all_files = meta.getFolderFiles() ImagePlus image = IJ.openImage(path) if(image != null) return image - - + + // Now find which file it 'could' be - + def f = new File(path) // Get ID of file trying to be opened def gr = (f.name =~ /r(\d*)c(\d*)f(\d*)p(\d*).*/) def file_id = [r:gr[0][1] as int, c:gr[0][2] as int , f:gr[0][3] as int, p:gr[0][4] as int] // Create an ID for all files def all_ids = all_files.collect{ def group = (it.name =~ /r(\d*)c(\d*)f(\d*)p(\d*).*/) if (!group.hasGroup() ) return [r:0 as int, c:0 as int, f:0 as int, p:0 as int] return [r:group[0][1] as int, c:group[0][2] as int , f:group[0][3] as int, p:group[0][4] as int] } - + // Find file that matches ths right ID def idx = all_ids.findIndexValues{ it.r == file_id.r && it.c == file_id.c && it.f == file_id.f && it.p == file_id.p } - + // Open it if(idx.size() > 0 ) { IJ.log("Could not find file "+f.name+". Opening "+all_files[idx].name+" instead..."); return IJ.openImage(all_files[idx[0] as int].getAbsolutePath()) } return null } - + void writePositionsFile(posfile, fileNames, positions, is_z) { def dim = 2 def z= "" if(is_z){ dim = 3 z = ", 0.0" } posfile << "#Define the number of dimensions we are working on:\n" posfile << "dim = "+dim+"\n" posfile << "# Define the image coordinates\n" - + fileNames.eachWithIndex{ file, i -> posfile << file+".tif; ; ("+positions.get(i)['x']+", "+positions.get(i)['y'] + z+")\n" } } - + /* * GUI for selecting wells in case this is requested */ Boolean selectWellsGUI(int resize) { def peGUI = new SwingBuilder() def positionList = { peGUI.panel() { scrollPane(verticalScrollBarPolicy:JScrollPane.VERTICAL_SCROLLBAR_ALWAYS ) { - list(id: "wells", - listData: meta.getSelectedWells(), - selectionMode: ListSelectionModel.MULTIPLE_INTERVAL_SELECTION - ) - } - - } + list(id: "wells", + listData: meta.getSelectedWells(), + selectionMode: ListSelectionModel.MULTIPLE_INTERVAL_SELECTION + ) + } + + } + } + + def myframe = peGUI.frame( title : 'Choose Wells', + location : [100, 400], + size : [200, 300], + defaultCloseOperation : WindowConstants.DISPOSE_ON_CLOSE, + ){ + panel() { + boxLayout(axis : BoxLayout.Y_AXIS) + label( text : 'Select multiple with Shift or Ctrlt', + horizontalAlignment : JLabel.CENTER + ) + positionList() + + button( text : 'Run', + horizontalAlignment : JLabel.CENTER, + actionPerformed : { act -> + selected_wells = new HashSet(peGUI.wells.getSelectedIndices().collect{ val -> meta.getSelectedWells()[val] }) + meta.setSelectedWells(selected_wells) + def selproc = new Timer("Processing selected") + selproc.tic() + this.process(resize) + selproc.toc() + dispose() + } ) + } + } + myframe.setVisible(true) } - - def myframe = peGUI.frame(title : 'Choose Wells', - location : [100, 400], - size : [200, 300], - defaultCloseOperation : WindowConstants.DISPOSE_ON_CLOSE, - ) { - panel() { - boxLayout(axis : BoxLayout.Y_AXIS) - label(text : 'Select multiple with Shift or Ctrlt', - horizontalAlignment : JLabel.CENTER - ) - positionList() - - button(text : 'Run', - - horizontalAlignment : JLabel.CENTER, - actionPerformed : { act -> - selected_wells = new HashSet(peGUI.wells.getSelectedIndices().collect{ val -> meta.getSelectedWells()[val] }) - meta.setSelectedWells(selected_wells) - def selproc = new Timer("Processing selected") - selproc.tic() - this.process(resize) - selproc.toc() - dispose() - } ) - } - } - myframe.setVisible(true) } -} /* * Time class to 'tic-toc' a few steps and check time spent. */ class Timer{ Long startTime Long endTime def name - + public Timer(String name){ this.name = name } - + public void tic(){ this.startTime = System.nanoTime() } - + public void toc(){ this.endTime = System.nanoTime() IJ.log("'"+name+"' took : "+((endTime-startTime)/1e9)+" s") } } /* * Image class containing important imformation about each image file */ class Image { ArrayList rowcol = new ArrayList(2) int field int channel int slice int timepoint float posx float posy float posz - + int posx_px int posy_px float toffset String image } /* * Small class to store the CZT Indexes */ class CZT { int c int z int t - + CZT(int c, int z, int t) { this.c = c this.z = z this.t = t } - + int getC() { return c } int getZ() { return z } int getT() { return t } } - + /* * Experiment metadata that contains global information about the images and their extraction * Also contains helper functions to calculate all required information about the experiment */ class ExperimentMetadata { String xml_name = "Index.idx.xml" File parent_directory File save_directory ArrayList image_data def folder_files = [] String experiment_name def image_size def pixel_size def c_xtents def t_xtents def z_xtents def f_xtents def x_xtents def y_xtents def is_z def field_xy_size def well_xy_size def all_CZT HashSet wells - + /* * Handles building the save directory */ void setParentDirectory(File dir) { this.parent_directory = dir //make save directory this.save_directory = new File(dir, "output") save_directory.mkdir() } // Experimen Name is used to name the final exported files void setExperimentName(String exp_name) { this.experiment_name = exp_name } - + // This method is the metadata workhorse, calculates most of what we need void setImageData(ArrayList image_data) { - + this.image_data = image_data //Once this is set we can calculate a bunch of useful things this.c_xtents = [ start: image_data.min{ it.channel }.channel, end: image_data.max{ it.channel }.channel ] this.t_xtents = [ start: image_data.min{ it.timepoint }.timepoint, end: image_data.max{ it.timepoint }.timepoint ] this.z_xtents = [ start: image_data.min{ it.slice }.slice, end: image_data.max{ it.slice }.slice ] this.f_xtents = [ start: image_data.min{ it.field }.field, end: image_data.max{ it.field }.field ] - + // Get extent of position in xy this.x_xtents = [ start: image_data.min { it.posx }.posx, end: image_data.max { it.posx }.posx ] this.y_xtents = [ start: image_data.min { it.posy }.posy, end: image_data.max { it.posy }.posy ] - + // Check if the dataset is 3D (for writing the positions file) this.is_z = (z_xtents.end - z_xtents.start > 0) ? true : false // Get the size of a field this.field_xy_size = [ x: image_size.x , y: image_size.y ] // Size of a tiled plane is the difference of the start end xy coordinates, in pixels, to which we add the xy size of one image this.well_xy_size = [x: Math.round((x_xtents.end - x_xtents.start) / pixel_size) + image_size.x, y: Math.round((y_xtents.end - y_xtents.start) / pixel_size ) + image_size.y] // Get all Channels Slices and Timepoints this.all_CZT = new ArrayList() (c_xtents.start..c_xtents.end).each{ c -> (z_xtents.start..z_xtents.end).each{ z -> (t_xtents.start..t_xtents.end).each{ t -> all_CZT.add(new CZT(c,z,t)) } } } - + this.wells = new HashSet(image_data.rowcol) // Compute the pixel positions of each image as well image_data.each{ it.posx_px = (it.posx - x_xtents.start) / pixel_size it.posy_px = (y_xtents.end - it.posy ) / pixel_size } } - + void setFolderFiles() { this.parent_directory.eachFileRecurse (FileType.FILES) { file -> - if(file.name.endsWith('.tiff')) - this.folder_files << file + if(file.name.endsWith('.tiff')) + this.folder_files << file } } void setImageSize(int size_x, int size_y) { this.image_size = [x: size_x, y: size_y] } void setPixelSize(double pixel_size) { this.pixel_size = pixel_size } - + void setSelectedWells(HashSet selection) { this.wells = selection } - + ArrayList getFolderFiles() { return this.folder_files } Map getFieldSize(int resize) { def xy_size = this.field_xy_size xy_size.x /= resize xy_size.y /= resize return xy_size } Map getWellSize(int resize) { def xy_size = this.well_xy_size xy_size.x /= resize xy_size.y /= resize return xy_size } - + // Required for tiling by this script // or for writing the positions file for downstream stitching (Grid Collection Stitching) Map getPixelCoordinates(int field, int resize) { def img = this.image_data.find { it.field == field } def px_coords = [x:img.posx_px / resize, y:img.posy_px / resize] return px_coords } - + // Recover data regarding final field sizes, to compute RAM usage // 16, for the bit depth of the camera // '/8' = bytes // '/1e9' = Gbytes // This will help determine the number of threads double getFieldStackSize(int resize) { return 16 * all_CZT.size() * field_xy_size.x * field_xy_size.y / 8 / 1e9 } double getWellStackSize(int resize) { return 16 * all_CZT.size() * well_xy_size.x * well_xy_size.y / 8 / 1e9 } int getFieldsPerWell() { return f_xtents.end - f_xtents.start + 1 } - + int getPlanesPerField() { return all_CZT.size() } ArrayList getAllCZT() { return this.all_CZT } File getXMLFile() { return new File(parent_directory, xml_name) } String getParentDirectory() { return parent_directory.getAbsolutePath() } - + String getSaveDirectory() { return save_directory.getAbsolutePath() } - + HashSet getSelectedWells() { return this.wells } String getWellName(well) { return experiment_name+" - R"+IJ.pad(well[0],2)+"-C"+IJ.pad(well[1],2) } - + String getFieldName(well, field) { return getWellName(well)+"-F"+IJ.pad(field,2) } Map getStackCZTDimensions() { return [c: c_xtents.end, z: z_xtents.end, t: (t_xtents.end+1) ] } // T indexes start at 0 Image findImage(well, czt, field) { return this.image_data.find { it.rowcol == well && it.channel == czt.getC() && it.timepoint == czt.getT() && it.field == field && it.slice == czt.getZ()} } /* * xy size is straightformward but time and Z are not stored as intervals but absolute values * So we need to compute their values from two subsequent frames or slices */ Calibration computeCalibration(int resize) { def z_xtents = (image_data.min{ it.slice }.slice)..(image_data.max{ it.slice }.slice) def t_xtents = (image_data.min{ it.timepoint }.timepoint)..(image_data.max{ it.timepoint }.timepoint) - + // Need to compute voxelDepth def voxel_depth = 0.0 if(z_xtents.size() > 1) { def z1_image = image_data.find { it.rowcol == image_data[0].rowcol && it.channel == image_data[0].channel && it.timepoint == image_data[0].timepoint && it.slice == z_xtents[0] } def z2_image = image_data.find { it.rowcol == image_data[0].rowcol && it.channel == image_data[0].channel && it.timepoint == image_data[0].timepoint && it.slice == z_xtents[1] } voxel_depth = z2_image.posz - z1_image.posz } - + // Need to compute frameInterval def time_delta = 1.0 if(t_xtents.size() > 1) { def t1_image = image_data.find { it.rowcol == image_data[0].rowcol && it.channel == image_data[0].channel && it.timepoint == t_xtents[0] && it.slice == image_data[0].slice } def t2_image = image_data.find { it.rowcol == image_data[0].rowcol && it.channel == image_data[0].channel && it.timepoint == t_xtents[1] && it.slice == image_data[0].slice } time_delta = t2_image.toffset - t1_image.toffset } - + def cal = new Calibration() // 1e6 because values in the xml file are in meters and we want microns cal.pixelWidth = pixel_size * 1e6 * resize cal.pixelHeight = pixel_size * 1e6 * resize cal.pixelDepth = voxel_depth * 1e6 cal.setUnit("um") cal.frameInterval = (double) time_delta cal.setTimeUnit("s") - + return cal } } \ No newline at end of file