def main(): # Open a .ome.tif image from the Flexoscope. impath = IJ.getFilePath("Choose .ome.tiff file") channels = Opener.openUsingBioFormats(impath) # Show image # imp.show() # straight to channels object sames memory. # Split channels. channels = ChannelSplitter().split(channels) # Process channel 1. # subtractzproject(imp, projectionMethod="Median") channels[1] = ImagePlus() channels.append(ImagePlus()) channels[1] = subtractzproject(channels[0]) IJ.run(channels[0], "Enhance Contrast...", "saturated=0.3 normalize process_all use") IJ.run(channels[0], "8-bit", "") IJ.run(channels[1], "Square", "stack") IJ.run(channels[1], "Enhance Contrast...", "saturated=0.3 normalize process_all use") IJ.run(channels[1], "8-bit", "") # Merge channels. merge = RGBStackMerge().mergeChannels(channels, True) # boolean keep merge.show()
def run(): # ensure no other windows are open and clear resultstable IJ.run("Close All") IJ.run("Clear Results", "") #Ask user for file to be converted srcDir = IJ.getFilePath("Select file to analyse") if not srcDir: return #open file IJ.open(srcDir) dstDir = os.path.dirname(srcDir) print("dstDir = " + dstDir) #open ROI manager, save ROI names as labels in measurements rm = RoiManager.getInstance() if not rm: rm = RoiManager() rm.runCommand("UseNames", "true") # set parameters to be measured IJ.run("Set Measurements...", "area mean integrated limit display redirect=None decimal=3") FOVlist = WindowManager.getIDList() chnls = IJ.getString( "Please enter which channels you would like to analyse. Example: 123 analyses channels 1, 2 and 3", '123') for FOV in FOVlist: imp = WindowManager.getImage(FOV) IJ.run(imp, "Arrange Channels...", "new=" + chnls) imp.close() imp2 = WindowManager.getCurrentImage() imageTitle = WindowManager.getImage(FOV).getTitle() newDir = imageTitle + ' ROIs' dirPath = os.path.join(dstDir, newDir) if not os.path.exists(dirPath): try: os.makedirs(dirPath) except OSError as e: if e.errno != errno.EEXIST: raise # clear ROI list before analysis rm.runCommand(imp2, "Deselect") rm.runCommand(imp2, "Delete") TMdata, nFrames = runTrackMate(imp2) if TMdata: iterateCoords(TMdata, nFrames, dirPath, imp2) imp2.changes = 0 imp2.close() #relabel() resultsDir = os.path.splitext(srcDir)[0] + ".csv" #while os.path.exists(resultsDir): #resultsDir = resultsDir+"_1"+".csv" IJ.saveAs("Results", resultsDir)
def opencsv(self, name): # Return if the csv object was not set. # if self.trackscsv == None: return None TODO: some errorchecking for false csv input. # Open the csv file and return it as ResultsTable object. try: csv = IJ.getFilePath("Choose the {} file".format(name)) if csv.endswith(".csv"): rt = ResultsTable.open(csv) else: IJ.log("{} was not a .csv file".format(csv)) raise ValueError columns = rt.getHeadings() table = [{column: rt.getValue(column, row) for column in columns} for row in range(rt.size())] if rt.columnExists("Label"): for i in range(len(table)): table[i]["Label"] = rt.getStringValue("Label", i) IJ.log("Read {} rows in {}.".format(len(table), name)) return table except Exception as ex: IJ.log("Something in opencsv() went wrong: {}".format( type(ex).__name__, ex.args))
def main(): # --------------------------------------------- # Loads json file, reads tiff stack filenames # runs them through the selected STORM analyser # then attempts to save the collected spot info. # --------------------------------------------- settingsFile = "" settingsFile = IJ.getFilePath(settingsFile) if settingsFile == None: return try: jsonFileObj = open(settingsFile, 'r') jsonRead = json.load(jsonFileObj) except: IJ.error("No JSON could be loaded from " + settingsFile + ". Are you certain this file is the correct format?") return directory = jsonRead['SaveDirectory'] tiledStormOutputFile = directory + os.sep + "Tiled_STORM_spots.csv" # Run analysis: for item in jsonRead['Points']: imageFile = directory + os.sep + item['Filename'] if macro == "ThunderSTORM": fileList = runThunderSTORM(imageFile) elif macro == "SomeOTHERnotimplementedSTORM": fileList = runThunderSTORM(imageFile) else: IJ.error( "The STORM method selected in the Tile_STORM macro is invalid. :(" ) # Apply offsets: applyOffsets(fileList, jsonRead, tiledStormOutputFile) return 0
def main(): # Open a .ome.tif image from the Flexoscope. impath = IJ.getFilePath("Choose .ome.tiff file") channels = Opener.openUsingBioFormats(impath) cal = channels.getCalibration() # Show image # imp.show() # straight to channels object sames memory. # Split channels. channels = ChannelSplitter().split(channels) # Process channel 1. # subtractzproject(imp, projectionMethod="Median") channels[0] = subtractzproject(channels[0]) IJ.run(channels[0], "8-bit", "") # Process channel 2. # glidingprojection(imp, startframe=1, stopframe=None, glidingFlag=True, no_frames_per_integral=3, projectionmethod="Median") channels[1] = glidingprojection(channels[1]) IJ.run(channels[1], "8-bit", "") # [Optional] Process channel 3, 4, etc. # subtractzproject(channels[3], projectionMethod="Median") # glidingprojection(channels[3], startframe=1, stopframe=None, glidingFlag=True, no_frames_per_integral=3, projectionmethod="Median") # IJ.run(channels[3], "8-bit", "") # Merge channels. merge = RGBStackMerge().mergeChannels(channels, True) # boolean keep merge.setCalibration(cal) merge.show()
def __init__(self, fp = None): # Initialize the filepath to the grid file if fp is None: self.fp = IJ.getFilePath("Grid file") else: self.fp = fp # Get the directory, the name of the grid, and the name of the image self.initializeFilenames() self.loadSourceImage() self.initializeGridCoords()
def main(): imp = IJ.getFilePath("Select DCIMG file") if not imp: return root, ext = os.path.splitext(imp) if ext.lower() != '.dcimg': cFrame = PlugInFrame('ERR DLG') MessageDialog(cFrame, 'ERROR', 'Expected extension .dcimg') return #Lets start fID = open(imp, 'rb') hdr_bytes = read_header_bytes(fID) hdr = parse_header_bytes(fID, hdr_bytes) metadataStr = beginMetadata() for key, value in hdr.iteritems(): metadataStr += addMetadataEntry(key, str(value)) metadataStr += endMetadata() metadataDlg = HTMLDialog("DCIMG metadata", metadataStr, 0) size = metadataDlg.getSize() if size.width < 300: size.width = 300 if size.height < 500: size.height = 500 metadataDlg.setSize(size) finfo = FileInfo() finfo.fileName = imp #finfo.width = hdr['xsize_req'] finfo.width = hdr['xsize'] finfo.height = hdr['ysize'] finfo.nImages = hdr['nframes'] finfo.offset = 232 finfo.fileType = hdr['bitdepth'] / 8 - 1 #Ugh finfo.intelByteOrder = 1 #finfo.gapBetweenImages = int(hdr['bytes_per_img']*(1-float(hdr['xsize_req'])/float(hdr['xsize']))) finfo.gapBetweenImages = 0 finfo.fileFormat = 1 finfo.samplesPerPixel = 1 finfo.displayRanges = None finfo.lutSize = 0 finfo.whiteIsZero = 0 vs = VirtualStack() finfo.virtualStack = vs FileInfoVirtualStack(finfo)
def select_input(self, event): # get the info about the number of images in the file self.input_path = IJ.getFilePath("Choose a File") # if default naming is not changed use file name if self.textfield2.text == self.default_naming: self.file_core_name = path.basename(self.input_path).split('.czi')[0] else: self.file_core_name = self.textfield2.text # put that name in the text field self.panel.getComponents()[1].setText(self.file_core_name) reader = ImageReader() reader.setId(self.input_path) metadata_list = reader.getCoreMetadataList() # slide scanner makes a piramid of X for every ROI you draw # resolution is not updated in the metadata so it needs to be calculated manually number_of_images, self.num_of_piramids_list = get_data_structure(metadata_list) print("Number of images is " + str(number_of_images)) # get the indexes of the maximum resolution images self.max_res_indexes = get_maxres_indexes(self.num_of_piramids_list) print("Number of pyramids are " + str(self.num_of_piramids_list)) # set names of subimages in the list, waiting to compare to current outputs self.possible_slices = [self.file_core_name + "_slice-" + str(n) for n in range(number_of_images)] self.binFactor_list, self.binStep_list = get_binning_factor(self.max_res_indexes, self.num_of_piramids_list, metadata_list) print("Binning factors are " + str(self.binFactor_list)) print("Binning steps are " + str(self.binStep_list)) # create output directory if it doesn't exist # get the animal id animal_id = self.file_core_name.split('_')[0] self.output_path = path.join(path.dirname(path.dirname(self.input_path)), "Processed_data", animal_id, "ROIs") if path.isdir(self.output_path): print("Output path was already created") else: makedirs(self.output_path) print("Output path created") # update_lists depending on whether something has been processed already self.update_list()
def opencsv(): """Simply imports .csv file in ImageJ. Ask the user for the location of a .csv file. Returns: A ResultsTable object from the input file. """ csv = IJ.getFilePath("Choose a .csv file") # Open the csv file and return it as ResultsTable object. try: if csv.endswith(".csv"): res = ResultsTable.open(csv) return res else: raise TypeError() except TypeError: IJ.log("The chosen file was not a .csv file.") except Exception as ex: IJ.log("Something in opencsv() went wrong: {}".format(type(ex).__name__, ex.args))
(basename)_R(fixed)_GR(.*)_B(block number)_L(location number)\.lsm with GR (group repetition) number being left to be variable, and then these files are merged in the orfer of the GR value. request from Katharina Sonnen ''' import os import re from ij import IJ, ImagePlus from ij.io import Opener from ij.plugin import Concatenator from jarray import array srcpath = IJ.getFilePath('Choose the first file') filename = os.path.basename(srcpath) srcDir = os.path.dirname(srcpath) #chosefile = '20130711_R1_GR001_B1_L2.lsm' pattern = re.compile('(.*)_R(.*)_GR(.*)_B(.*)_L(.*)\.lsm') res = re.search(pattern, filename) basename = res.group(1) repetition = res.group(2) grouprepetition = res.group(3) block = res.group(4) location = res.group(5) GRlist = [] for root, directories, filenames in os.walk(srcDir):
# VIB - Vlaams Instituut voor Biotechnologie # October 2018 from ij import IJ from ij.plugin.frame import RoiManager import sys rm = RoiManager.getInstance() if rm == None: rm = RoiManager() rois = rm.getRoisAsArray() if rois == None or len(rois) == 0: sys.exit('The ROI manager has no ROIs') filename = IJ.getFilePath( 'Specify the output file for the ROIs in JSON format (e.g. myrois.json)') if filename == None: sys.exit('ROI saving canceled by the user.') # Save the ROIs as JSON arrays IJ.log("Saving {} ROIs to {}".format(len(rois), filename)) with open(filename, 'w') as f: f.write('[\n') for i, roi in enumerate(rois): polygon = roi.getPolygon() f.write('[\n') for j in range(polygon.npoints): f.write('[{}, {}]'.format(polygon.xpoints[j], polygon.ypoints[j])) if j < polygon.npoints - 1: f.write(',') f.write('\n')
from ij.gui import HTMLDialog import struct import os def addMetadataEntry(name, val): return "<tr><td style='padding:0 25px 0 0px;'><b>" + name + "</b></td><td>" + val + "</td></tr>" def beginMetadata(): return "<table border=0 cellspacing=0>" def endMetadata(): return "</table>" imp = IJ.getFilePath("Select HIS file") if not imp: exit(-1) root, ext = os.path.splitext(imp) if ext.lower() != '.his': cFrame = PlugInFrame('ERR DLG') MessageDialog(cFrame, 'ERROR', 'Expected extension .his') exit(-1) fID = open(imp, 'rb') fID.seek(2) offset = struct.unpack('<h', fID.read(2))[0] fID.seek(14) frames = struct.unpack('<I', fID.read(4))[0] fID.seek(2) commentBytes = struct.unpack('<h', fID.read(2))[0]
def getPath(text): path = IJ.getFilePath(text) IJ.log('File selected: ' + path) return path
from os import path, makedirs import sys sys.path.append(path.abspath(path.dirname(__file__))) from functions.czi_structure import get_data_structure, get_binning_factor, open_czi_series, \ get_maxres_indexes from functions.image_manipulation import extractChannel piramid_to_open = 1 channel_to_save = 3 final_resolution = 5 # Main if __name__ in ['__builtin__', '__main__']: # get the file input_path = IJ.getFilePath("Choose a .czi file") reader = ImageReader() reader.setId(input_path) metadata_list = reader.getCoreMetadataList() # slide scanner makes a piramid of X for every ROI you draw # resolution is not updated in the metadata so it needs to be calculated manually number_of_images, num_of_piramids_list = get_data_structure(metadata_list) IJ.log("Number of images is " + str(number_of_images)) # set names of subimages in the list, waiting to compare to current outputs file_core_name = path.basename(input_path).split('.czi')[0] # get the indexes of the maximum resolution images max_res_indexes = get_maxres_indexes(num_of_piramids_list) IJ.log("Number of pyramids are " + str(num_of_piramids_list)) # set names of subimages in the list, waiting to compare to current outputs possible_slices = [ file_core_name + "_slice-" + str(n) for n in range(number_of_images)