Exemple #1
0
def concatenateImagePlus(files, outfile):
    """Concatenate images contained in files and save in outfile"""

    options = ImporterOptions()
    options.setId(files[0])
    options.setVirtual(1)
    options.setOpenAllSeries(1)
    options.setQuiet(1)
    images = BF.openImagePlus(options)
    imageG = images[0]
    nrPositions = len(images)
    options.setOpenAllSeries(0)

    nslices = imageG.getNSlices()
    nframes = len(files)
    nchannels = imageG.getNChannels()
    luts = imageG.getLuts()

    for i in range(0, nrPositions):
        concatImgPlus = IJ.createHyperStack(
            "ConcatFile", imageG.getWidth(), imageG.getHeight(),
            imageG.getNChannels(), imageG.getNSlices(),
            len(files), imageG.getBitDepth())


        concatStack = ImageStack(imageG.getWidth(), imageG.getHeight())
        IJ.showStatus("Concatenating files")
        for file_ in files:
            try:
                print '...', basename(file_)
                options.setSeriesOn(i, 1)
                options.setId(file_)
                image = BF.openImagePlus(options)[0]
                imageStack = image.getImageStack()

                sliceNr = imageStack.getSize()
                for j in range(1, sliceNr+1):
                    concatStack.addSlice(imageStack.getProcessor(j))
                image.close()
                options.setSeriesOn(i, 0)
            except Exception, e:
                IJ.log("ERROR")
                IJ.log(file_ + str(e))
                raise
            IJ.showProgress(files.index(file_), len(files))

        concatImgPlus.setStack(concatStack, nchannels, nslices, nframes)
        concatImgPlus.setCalibration(image.getCalibration())
        concatImgPlus.setOpenAsHyperStack(True)
        concatImgPlus.setLuts(luts)
        concatImgPlus.close()
        IJ.saveAs(concatImgPlus, "Tiff",  outfile)
Exemple #2
0
    def readCZIattachment(imagefile,
                          stitchtiles=False,
                          setflatres=False,
                          readpylevel=0,
                          setconcat=False,
                          openallseries=False,
                          showomexml=False,
                          attach=False,
                          autoscale=True):
        
        # define the reader options
        reader_options, czireader = ImportTools.setReaderOptions(imagefile, stitchtiles=stitchtiles,
                                                                            setflatres=setflatres,
                                                                            setconcat=setconcat,
                                                                            openallseries=openallseries,
                                                                            showomexml=showomexml,
                                                                            attach=attach,
                                                                            autoscale=autoscale)

        # open the ImgPlus
        imps_attach = BF.openImagePlus(reader_options)

        # read image data using the specified pyramid level
        imp_attach, slices, width, height, pylevel = ImageTools.getImageSeries(imps_attach, series=readpylevel)
        czireader.close()

        return imp_attach
Exemple #3
0
    def openjpg(imagefile, metainfo, method='IJ',
                                     series=0):

        if method == 'IJ':

            # using IJ static method
            imp = IJ.openImage(imagefile)

        if method == 'Opener':

            # Using Opener class
            imp = Opener().openImage(imagefile)

        if method == 'BF':

            # using BioFormats library
            imps = BF.openImagePlus(imagefile)

            # read image data using the specified pyramid level
            imp, slices, width, height, pylevel = ImageTools.getImageSeries(imps, series=series)
            metainfo['Output Slices'] = slices
            metainfo['Output SizeX'] = width
            metainfo['Output SizeY'] = height

        return imp, metainfo
def findclearcell(inDir, currentDir, fileName):
  print "Opening", fileName
  file_path= os.path.join(currentDir, fileName)
  options = ImporterOptions()
  options.setId(file_path)
  options.setSplitChannels(True)
  imps = BF.openImagePlus(options)
  for imp in imps:
  	imp.show()
  if not imps:
  	return
  IJ.selectWindow(fileName + " - C=2")
  IJ.run("Close")
  IJ.selectWindow(fileName + " - C=1")
  IJ.run("Close")
  IJ.selectWindow(fileName + " - C=0")
  IJ.run("Close")
  IJ.selectWindow(fileName + " - C=3")
  IJ.run("8-bit")
  IJ.run("Options...", "iterations=1 count=1 black edm=8-bit")
  IJ.setThreshold(62, 255)
  IJ.run("Convert to Mask", "method=Default backgorund=Dark black")
  Macro.setOptions("Stack position")
  for n in range(4,15):
	n+=1
	IJ.setSlice(n)
	IJ.run(imp, "Analyze Particles...", "size=7.2-9 circularity=0.7-0.95 display")
Exemple #5
0
def open_from_lif_series(fpath, i):
  options = ImporterOptions()
  options.setId(fpath)
  options.clearSeries()
  options.setSeriesOn(i, True)
  imps = BF.openImagePlus(options)
  return imps[0]
Exemple #6
0
	def showimage(self):
		roim = RoiManager.getInstance()
		if roim is None:
			roim = RoiManager()
		IJ.run("Close All")
		IJ.run("Clear Results")
		try:
			roim.reset()
		except AttributeError:
			roim.runCommand("reset")
		obj = self.fcsimages[self.idximg][0]
		imgName = self.fcsimages[self.idximg][1]

		img =  BF.openImagePlus(imgName)[0]
		img.setZ(obj[1][2]+1)
		img.setC(3)
		IJ.run(img, "Grays", "");
		img.setC(1)
		img.show()

		#draw rois
		for i in range(1, len(obj)+1):
			PR = PointRoi(obj[i][0],obj[i][1])
			try:
				PR.setSize(3)
				PR.setPointType(0)
				roim.addRoi(PR)
			except:
				roim.addRoi(PR)
		roim.runCommand('Show All with Labels')
Exemple #7
0
def main(argv):
    """Segment mitochondria."""

    datadir = '/Users/michielk/M3S1GNUds7'
    filename = 'M3S1GNUds7_tiff.tif'
    filepath = os.path.join(datadir, filename)
    imp = BF.openImagePlus(filepath)
def readSingleChannelImg(imgFile):
	options = ImporterOptions()
	options.setColorMode(ImporterOptions.COLOR_MODE_GRAYSCALE)
	options.setId(imgFile)
	imps = BF.openImagePlus(options)
	ip = imps[0]
	return(ip)
def createOutputData( jobs ):
    """ Reads out the meta data.
    """
    failedImages = []
    nJobs = len( jobs )
    for n, j in enumerate( jobs ):
        print( "Job " + str(n+1) + "/" + str( nJobs ) )
        # load every image
        metadata = []
        nImages = len( j.sourceImages )
        nChannels = -1
        for m, img in enumerate( j.sourceImages ):
            print( "\tReading image " + str(m+1) + "/" + str( nImages ) )
            imgPath = os.path.join( j.sourcePath, img )
            options = ImporterOptions()
            options.setId( imgPath )
            options.setSplitChannels( False )
            options.setWindowless( True )
            options.setVirtual( True )
            imps = BF.openImagePlus( options )
            if len(imps) == 0:
                failedImages.append( imgPath )
                print("t\tCould not load image: " + imgPath)
                continue
            # get the meta data
            data = imps[0]
            if nChannels == -1:
                nChannels = data.getNChannels() 
            imgInfo = Info();
            info = imgInfo.getImageInfo( data, data.getChannelProcessor() )
            metadata.append( imgPath )
            metadata.append( info )
        j.outputData = '\n\n>>> next source file >>>\n\n'.join( metadata )
        j.numChannels = nChannels
Exemple #10
0
def concatenateImagePlus(files, outfile):
	"""concatenate images contained in files and save in outfile"""
	'''
	if len(files) == 1:
		IJ.log(files[0] + " has only one time point! Nothing to concatenate!")
		return
	'''
	options = ImporterOptions()
	options.setId(files[0])
	options.setVirtual(1)
	options.setOpenAllSeries(1)
	options.setQuiet(1)
	images = BF.openImagePlus(options)
	imageG = images[0]
	nrPositions = len(images)
	options.setOpenAllSeries(0)

	for i in range(0, nrPositions):
		concatImgPlus = IJ.createHyperStack("ConcatFile", imageG.getWidth(), imageG.getHeight(), imageG.getNChannels(), imageG.getNSlices(), len(files), imageG.getBitDepth())
		concatStack = ImageStack(imageG.getWidth(), imageG.getHeight())
		IJ.showStatus("Concatenating files")
		for file in files:
			try:
				IJ.log("	Add file " + file)
				options.setSeriesOn(i,1)
				options.setId(file)
				image = BF.openImagePlus(options)[0]
				imageStack = image.getImageStack()
				sliceNr = imageStack.getSize()
				for j in range(1, sliceNr+1):
					concatStack.addSlice(imageStack.getProcessor(j))
				image.close()
				options.setSeriesOn(i,0)
			except:
				traceback.print_exc()
				IJ.log(file + " failed to concatenate!")
			IJ.showProgress(files.index(file), len(files))
		concatImgPlus.setStack(concatStack)
		concatImgPlus.setCalibration(image.getCalibration())
		if len(images) > 1:
			outfileP = addPositionName(i+1,outfile)
			IJ.saveAs(concatImgPlus, "Tiff",  outfileP)
		else:
			IJ.saveAs(concatImgPlus, "Tiff",  outfile)
		concatImgPlus.close()
def getImps(fpath):
	opt = IO()
	opt.setId(fpath)
	opt.setOpenAllSeries(True) 
	impA = BF.openImagePlus(opt)
	print "Series number: " + str(len(impA))
	#impA = BF.openImagePlus()
	return impA
def set_options(image, series = None):
	"""
	creates ImporterOptions object and sets options
	returns the imps object
	"""
	if series is not None:
		options = ImporterOptions()
		options.setId(image)
		options.setSeriesOn(s,True)
		imps = BF.openImagePlus(options)
		return imps
	else:
		print("no series found")
		options = ImporterOptions()
		options.setId(image)
		imps = BF.openImagePlus(options)
		return imps
def get_reader(file, inputMeta):
	options = ImporterOptions()
	options.setId(file)
	imps = BF.openImagePlus(options)
	reader = ImageReader()
	reader.setMetadataStore(inputMeta)
	reader.setId(file)
	return reader
Exemple #14
0
def run_headless(filename, channel, target_folder = None, frames = None):
	
	importOpt = ImporterOptions()
	importOpt.setId(filename)
	importOpt.setVirtual(1)
	try:
		imp = BF.openImagePlus(importOpt)[0]
	except IOError, err:
		IJ.showMessage("Not able to open " + filename + " " +str(err))
Exemple #15
0
def get_image(input_file):
    imp = BF.openImagePlus(input_file)[0]
    
    # Reorder stack to swap Z and T if needed
    nframes = imp.getDimensions()[4]
    nslices = imp.getDimensions()[3]
    if nframes == 1:
        IJ.run("Re-order Hyperstack ...", "channels=[Channels (c)] slices=[Frames (t)] frames=[Slices (z)]");
    
    return imp
Exemple #16
0
def open_image(imgfile):
	options = ImporterOptions()
	options.setId(imgfile)
	options.setSplitChannels(False)
	options.setColorMode(ImporterOptions.COLOR_MODE_COMPOSITE)
	imps = BF.openImagePlus(options)
	splitimps = [ImagePlus("%s-C-%i" % (imps[0].getTitle(), i),imps[0].getStack().getProcessor(i)) for i in range(1,imps[0].getNChannels()+1)] 
	for si in splitimps:
		si.setCalibration(imps[0].getCalibration().copy())
	return imps[0], splitimps
def extractChannel(oirFile, ch):
	options = ImporterOptions()
	options.setColorMode(ImporterOptions.COLOR_MODE_GRAYSCALE)
	options.setId(oirFile)
	options.setCBegin(0, ch)
	options.setCEnd(0, ch)  
	#options.setSeriesOn(1,True)
	imps = BF.openImagePlus(options)
	ip = imps[0]
	return(ip)
Exemple #18
0
def openCroppedImageUsingBF(filepath,x,y,xw,yw,zs,ze, crop):
  # read in and display ImagePlus(es) with arguments
  options = ImporterOptions()
  options.setColorMode(ImporterOptions.COLOR_MODE_GRAYSCALE)
  if crop:
    options.setCrop(True)
    options.setCropRegion(0, Region(x,y,xw,yw))
    options.setTBegin(0, zs)
    options.setTEnd(0, ze)
  options.setId(filepath)
  imps = BF.openImagePlus(options)
  return imps[0]
Exemple #19
0
def open_msr(input_file):
    options = ImporterOptions()
    options.setId(input_file)
    #options.clearSeries()
    for s in [3,4,5]:
        options.setSeriesOn(s, True)
    imps = BF.openImagePlus(options)

    imp1 = imps[1]
    imp2 = imps[0]
    imp3 = imps[2] 
    
    return imp1, imp2, imp3
Exemple #20
0
def run(imagefile, useBF=True,
        series=0,
        filtertype='MEDIAN',
        filterradius='5'):

    #log.log(LogLevel.INFO, 'Image Filename : ' + imagefile)
    log.info('Image Filename : ' + imagefile)

    # get basic image metainfo
    metainfo = get_metadata(imagefile, imageID=series)
    for k, v in metainfo.items():
        #log.log(LogLevel.INFO, str(k) + ' : ' + str(v))
        log.info(str(k) + ' : ' + str(v))

    if not useBF:
        # using IJ static method
        imp = IJ.openImage(imagefile)

    if useBF:
        # initialize the importer options for BioFormats
        options = ImporterOptions()
        options.setOpenAllSeries(True)
        options.setShowOMEXML(False)
        options.setConcatenate(True)
        options.setAutoscale(True)
        options.setId(imagefile)
        options.setStitchTiles(True)

        # open the ImgPlus
        imps = BF.openImagePlus(options)
        imp = imps[series]

    # apply the filter
    if filtertype != 'NONE':

        # apply filter
        #log.log(LogLevel.INFO, 'Apply Filter  : ' + filtertype)
        #log.log(LogLevel.INFO, 'Filter Radius : ' + str(filterradius))
        log.info('Apply Filter  : ' + filtertype)
        log.info('Filter Radius : ' + str(filterradius))

        # apply the filter based on the chosen type
        imp = apply_filter(imp,
                           radius=filterradius,
                           filtertype=filtertype)

    if filtertype == 'NONE':
        #log.log(LogLevel.INFO, 'No filter selected. Do nothing.')
        log.info('No filter selected. Do nothing.')

    return imp
def open_czi(filepath,series):
    from loci.plugins import BF
    from loci.plugins.in import ImporterOptions
    from loci.common import Region
    options = ImporterOptions()
    options.setId( filepath )
    options.setSeriesOn(series-1,True)
    imp = BF.openImagePlus(options)[0]

    cal=imp.getCalibration()

    cal.pixelWidth  = cal.pixelWidth*2 **(series)
    cal.pixelHeight = cal.pixelHeight*2**(series)
    return imp    
Exemple #22
0
def imageloader(path, debug=False):
    '''
	Wrapper to deal with opening bioformat images properly in macros
	Returns an ImagePlus if successful and exception if not.
	Read ij.ImagePlus and loci.plugins.BF.openImagePlus for details.
	'''
    from ij import ImagePlus
    from loci.plugins import BF

    ext = os.path.splitext(path)[1]
    if ext in BIOFORMATS:
        return BF.openImagePlus(path)[0]
    else:
        return ImagePlus(path)
def main():
    files = []
    for filt in img_extensions.split(";"):
        if len(filt.strip()) > 0:
            files += glob.glob(os.path.join(str(input_dir), filt.strip()))
        else:
            files += glob.glob(os.path.join(str(input_dir), "*.*"))
            break

    if len(files) == 0:
        IJ.showMessage("No files found in '{}'\nfor extensions '{}'".format(
            str(input_dir), img_extensions))
    else:
        for fn in files:
            try:
                imp = BF.openImagePlus(fn)[0]
            except:
                IJ.showMessage(
                    "Could not open file '{}' (skipping).\nUse extension filter to filter non-image files..."
                    .format(str(fn)))
                continue

            img = IJF.wrap(imp)

            cali = imp.getCalibration().copy()
            if pixel_width > 0:
                cali.pixelWidth = pixel_width
                cali.pixelHeight = pixel_width
                cali.setUnit("micron")
            if frame_interval > 0:
                cali.frameInterval = frame_interval
                cali.setTimeUnit("sec.")

            imp_out = smooth_temporal_gradient(ops, img, sigma_xy, sigma_t,
                                               frame_start, frame_end,
                                               normalize_output)
            imp_out.setCalibration(cali)

            channels = ChannelSplitter.split(imp_out)

            fn_basename = os.path.splitext(fn)[0]
            IJ.save(channels[0], "{}_shrinkage.tiff".format(fn_basename))
            IJ.save(channels[1], "{}_growth.tiff".format(fn_basename))

            print("{} processed".format(fn_basename))

        IJ.showMessage(
            "Growth/shrinkage extraction of {} inputs finsihed.".format(
                len(files)))
Exemple #24
0
	def openImage(self, imageFile):
		try:
			images = BF.openImagePlus(imageFile)
			self.imp = images[0]
		except UnknownFormatException:
			return None
		if self.imp.getNChannels() < 2:
			IJ.error("Bad image format", "Image must contain at lease 2 channels!")
			return None
		if not self.pairs or \
			not self.methods:
			self.getOptionsDialog(self.imp)
		title = self.imp.title
		self.imp.title = title[:title.rfind('.')]
		return self.imp
Exemple #25
0
def main(argv):
    """Convert .dm3 files to tifs."""

    inputdir = 'INPUTDIR'
    outputdir = 'OUTPUTDIR'
    output_postfix = 'OUTPUT_POSTFIX'

    infiles = glob.glob(os.path.join(inputdir, '*.dm3'))

    for infile in infiles:
        imp = BF.openImagePlus(infile)
        tail = os.path.split(infile)[1]
        filename = os.path.splitext(tail)[0][-4:] + output_postfix + '.tif'
        outpath = os.path.join(outputdir, filename)
        IJ.save(imp[0], outpath)
Exemple #26
0
def open_msr(input_file):
    IJ.log("Reading images from {}".format(input_file))
    options = ImporterOptions()
    options.setId(input_file)
    #options.clearSeries()
    for s in [2,3,4,5]:
        options.setSeriesOn(s, True)
    imps = BF.openImagePlus(options)

    if len(imps) == 4:
        imp1 = imps[2]
        imp2 = imps[1]
        imp3 = imps[3] 
    elif len(imps) == 2:
        IJ.log(" -- Only two channels found. Replicating first as third.")
        imp1 = imps[1]
        imp2 = imps[0]
        imp3 = imps[0]
    else:
        raise RuntimeError("unknown channels")


    widths  = set([imp1.width, imp2.width, imp3.width])
    heights = set([imp1.height, imp2.height, imp3.height])

    if len(widths) > 1 or len(heights) > 1:
        new_width = max(widths)
        new_height = max(heights)

        IJ.log(" -- Resolution of images does not match. Resampling to highest resolution: {} x {}".format(new_width, new_height))
        
        cal = imp1.getCalibration()
        
        imp1 = imp1.resize(new_width, new_height, "bilinear")
        imp2 = imp2.resize(new_width, new_height, "bilinear")
        imp3 = imp3.resize(new_width, new_height, "bilinear")

        imp1.setCalibration(cal)
        imp2.setCalibration(cal)
        imp3.setCalibration(cal)

        
        

    
       
    
    return imp1, imp2, imp3
    def setUp(self):
        self.t = set_up_params(output_path_dir, test=False)
        self.cp = cab.cp
        self.change_ini()
        self.d, self.s = self.t.startScript()
        #self.cp.update("ChannelOptions", {"c1opt_boollist": "[False, False, False, True]"})
        #self.cp.readIni()
        from ij import IJ
        from loci.plugins import BF

        for i, f in enumerate(self.d.filenames):
            imp = BF.openImagePlus(f)[0]
            # imp.show()
            cab.headless = True
            self.imp = cab.Image(f, self.d, self.s, False)
        self.db = cab.db_interface(inipath, self.imp)
Exemple #28
0
def load_ome_img(file_name):
    """

    :param file_name:
    :return:
    """
    imps = BF.openImagePlus(file_name)
    imag = imps[0]
    # parse metadata
    reader = ImageReader()
    omeMeta = MetadataTools.createOMEXMLMetadata()
    reader.setMetadataStore(omeMeta)
    reader.setId(file_name)
    print(omeMeta)
    reader.close()

    return (imag, omeMeta)
def open_czi_series(file_name, series_number, rect=False):
    # see https://downloads.openmicroscopy.org/bio-formats/5.5.1/api/loci/plugins/in/ImporterOptions.html
    options = ImporterOptions()
    options.setId(file_name)
    options.setColorMode(ImporterOptions.COLOR_MODE_GRAYSCALE)
    # select image to open
    options.setOpenAllSeries(False)
    options.setAutoscale(False)
    options.setSeriesOn(series_number, True)
    # default is not to crop
    options.setCrop(False)
    if rect:  # crop if asked for
        options.setCrop(True)
        options.setCropRegion(series_number, Region(rect[0], rect[1], rect[2], rect[3]))
    imps = BF.openImagePlus(options)

    return imps[0]
def openImageFile(folder, imageFile):
    folder = folder.decode('utf8')
    imageFile = imageFile.decode('utf8')
    imagePath = str(folder)+"/"+str(imageFile)
    reader, options = readImageFile(imagePath)
    seriesCount = reader.getSeriesCount() #Nombre de séries
    zDepthByChannel = reader.getSizeZ() #Profondeur Z
    #imageStackImps = BF.openImagePlus(options)
    seriesOfImageFile = []
    for numberSerie in range(seriesCount):
        options.setSeriesOn(numberSerie,True); #Pour LIF - compter les séries - https://gist.github.com/ctrueden/6282856
        imageStackImps = BF.openImagePlus(options);
        #print imageStackImps
        mainImageStackImp = imageStackImps[-1] #0
        mainImageStackImp.setTitle(str(imageFile)+"_"+str(numberSerie))
        seriesOfImageFile.append(mainImageStackImp)
    #return mainImageStackImp
    return seriesOfImageFile
Exemple #31
0
def get_image(info, default_path, used_files):
	"""handle getting image from file"""
	check_for_file_overlap_OK = False;
	while not check_for_file_overlap_OK:
		info.set_input_file_path(file_location_chooser(default_path));
		if info.get_input_file_path() in used_files:
			dlg = GenericDialog("Image already used...");
			dlg.addMessage("This image has already been used in this analysis run.  \n " + 
					"Continue with this image, or choose a new one?");
			dlg.setOKLabel("Continue");
			dlg.setCancelLabel("Choose again...");
			dlg.showDialog();
			check_for_file_overlap_OK = False if dlg.wasCanceled() else True;
		else:
			check_for_file_overlap_OK = True;
	import_opts, info = choose_series(info.get_input_file_path(), info)

	imps = bf.openImagePlus(import_opts);
	imp = imps[0];
	
	try:
		memory_usage = IJ.currentMemory()/IJ.maxMemory();
		print("memory usage = " +str(memory_usage));
		# arbitrary limit...
		if memory_usage > 0.95: 
			IJ.run(imp, "8-bit", "");
			print("WARNING - IMAGE CONVERTED TO 8 BIT TO CONSERVE MEMORY!");
		info.set_metadata_file_path(os.path.splitext(info.get_input_file_path())[0] + ".txt");
		metadata = import_iq3_metadata(info.get_metadata_file_path());
		IJ.run(imp, "Properties...", "channels=" + str(int(metadata['n_channels'])) + 
										" slices=" + str(int(metadata['z_pixels'])) + 
										" frames=1 unit=" + str(metadata['x_unit']) + 
										" pixel_width=" + str(metadata['x_physical_size']) + 
										" pixel_height=" + str(metadata['y_physical_size']) + 
										" voxel_depth=" + str(metadata['z_extent']/metadata['z_pixels']));
		info.set_xy_pixel_size_um(metadata['x_physical_size']);
		info.set_z_plane_spacing_um(metadata['z_extent']/metadata['z_pixels']);
		info = parse_info_from_filename(info);
	except e as Exception:
		print(e.message);
	finally:
		if imp is not None:
			imp.close();
	return imp, info;
Exemple #32
0
def split_image(file_):
    print "Processing: %s" %(basename(file_))
    #load with loci (allows also to load *.czi)
    images = BF.openImagePlus(file_)
    image = images[0]
    #split channels
    chSp = ChannelSplitter()
    title = splitext(image.title)[0]
    imageC = chSp.split(image)
    print "Number of channels: ", len(imageC)
    for iCh in range(0, len(imageC)):
    	imageStack = imageC[iCh].getImageStack()
    	for iSlice in range(0,imageC[0].getNSlices()):
    		#print iSlice
    		impOut = ImagePlus("outImg", imageStack.getProcessor(iSlice+1))
	        ntitle = to_wellbased_nameing_scheme(title, iCh+1, iSlice+1)
	        IJ.log("Image: %s -> %s " %(title, ntitle))
	        IJ.saveAs(impOut, "Tiff", join(outdir, ntitle) )
def main(input_dir, file_contains, params):
    file_list = glob.glob(os.path.join(str(input_dir), "*.{}".format(file_ext)))

    file_contains = file_contains.strip()
    if len(file_contains) > 0:
        file_list = filter(lambda x: file_contains in os.path.basename(x), file_list)

    if len(file_list) == 0:
        IJ.showMessage("No files found to process.")
        return
        

    for input_file in file_list:
        imp = BF.openImagePlus(input_file)[0]
        path = os.path.dirname(input_file)
        file_name = os.path.basename(input_file)
    
        run_trackmate(imp, path, file_name, params, batch_mode=True)

    IJ.showMessage("Processing of {} input files done.".format(len(file_list)))
Exemple #34
0
def process(srcDir, dstDir, nameContains, currentDir, fileName, keepDirectories, anneBoleyn, overOut):
    print "Opening", fileName
    saveDir = currentDir.replace(srcDir, dstDir) if keepDirectories else dstDir
    head, tail = os.path.splitext(fileName)
    imps = BF.openImagePlus(os.path.join(currentDir, fileName))
    for imp in imps:
        if not anneBoleyn:
            print "Now showing image..."
            imp.show()
        IJ.run(imp, "Blue", "")
    fs = FileSaver(imp)
    if not os.path.exists(saveDir):
        os.makedirs(saveDir)
    if not overOut:
        if os.path.exists(saveDir + "\\" + head + ".jpg"):
            print "This JPG exists already and will not be overwritten. Moving on..."
    else:
        print "Saving to", os.path.join(saveDir, head + ".jpg")
        fs.saveAsJpeg(os.path.join(saveDir, head + ".jpg"))
    imp.close()
Exemple #35
0
def loadResultsFile(resfile):
	my_file = open(resfile, 'r')
	my_file.seek(0)
	for line in my_file:
		tabLine = line.split('\t')
		if tabLine[0].isdigit():
			#first pt
			if re.search( 'R\d_P(\d)_K\d_Ch\d-Ch\d.zen', tabLine[1]).group(1) == '1':
				filename =  re.split('_R\d_P(\d)_K\d_Ch\d-Ch\d.zen', os.path.basename(tabLine[2]))[0] + '.xml'
				dirName = os.path.dirname(tabLine[2])
				dirName = dirName.replace("Z:", "X:")
				filename = os.path.join(dirName,filename)
				obj, imgName = getPosition(filename)
				img =  BF.openImagePlus(imgName)[0]
				img.show()

			
	#while (line = my_file.readline()):
	#	print "aline"
	print "finished"
	my_file.close()
Exemple #36
0
def import_image(filename,
                 color_mode='color',
                 split_c=False, split_z=False, split_t=False):
    """Open an image file using the Bio-Formats importer.

    Parameters
    ----------
    filename : str
        The full path to the file to be imported through Bio-Formats.
    color_mode : str, optional
        The color mode to be used for the resulting ImagePlus, one of 'color',
        'composite', 'gray' and 'default'.
    split_c : bool, optional
        Whether to split the channels into separate ImagePlus objects.
    split_z : bool, optional
        Whether to split the z-slices into separate ImagePlus objects.
    split_t : bool, optional
        Whether to split the time points into separate ImagePlus objects.

    Returns
    -------
    ij.ImagePlus[]
        A list of ImagePlus objects resulting from the import.
    """
    options = ImporterOptions()
    mode = {
        'color' : ImporterOptions.COLOR_MODE_COLORIZED,
        'composite' : ImporterOptions.COLOR_MODE_COMPOSITE,
        'gray' : ImporterOptions.COLOR_MODE_GRAYSCALE,
        'default' : ImporterOptions.COLOR_MODE_DEFAULT,
    }
    options.setColorMode(mode[color_mode])
    options.setSplitChannels(split_c)
    options.setSplitFocalPlanes(split_z)
    options.setSplitTimepoints(split_t)
    options.setId(filename)
    log.info("Reading [%s]", filename)
    orig_imps = BF.openImagePlus(options)
    log.debug("Opened [%s] %s", filename, type(orig_imps))
    return orig_imps
Exemple #37
0
    def readbf(imagefile, metainfo,
               setflatres=False,
               readpylevel=0,
               setconcat=False,
               openallseries=True,
               showomexml=False,
               autoscale=True,
               stitchtiles=True):

        # initialize the importer options
        options = ImporterOptions()
        options.setOpenAllSeries(openallseries)
        options.setShowOMEXML(showomexml)
        options.setConcatenate(setconcat)
        options.setAutoscale(autoscale)
        options.setId(imagefile)
        options.setStitchTiles(stitchtiles)

        # in case of concat=True all series set number of series = 1
        # and set pyramidlevel = 0 (1st level) since there will be only one
        # unless setflatres = True --> read pyramid levels

        series = metainfo['SeriesCount_BF']
        if setconcat and setflatres:
            series = 1
            readpylevel = 0

        metainfo['Pyramid Level Output'] = readpylevel

        # open the ImgPlus
        imps = BF.openImagePlus(options)

        # read image data using the specified pyramid level
        imp, slices, width, height, pylevel = ImageTools.getImageSeries(imps, series=readpylevel)

        metainfo['Output Slices'] = slices
        metainfo['Output SizeX'] = width
        metainfo['Output SizeY'] = height

        return imp, metainfo
Exemple #38
0
def main():
	root = myDir.getPath() # get the root out the java file object
	print(root)
	
	import os, glob

	# set up bioformats
	from loci.plugins import BF
	from loci.plugins.in import ImporterOptions
	options = ImporterOptions()
	options.setColorMode(ImporterOptions.COLOR_MODE_COMPOSITE)
	options.setGroupFiles(True)  # if the files are named logically if will group them into a stack
  	
	# this will do the maximum intensity projection
	from ij.plugin import ZProjector
	Zproj = ZProjector()

	for path, subdirs, files in os.walk(root):
		print(path)
		# just get the one of the files that matches your image pattern
		flist = glob.glob(os.path.join(path,"*.tif"))
		print(len(flist))
		if( flist ):
			file = flist[0]
			print("Processing {}".format(file))
			options.setId(file)
			imp = BF.openImagePlus(options)[0]

			# show the image if you want to see it
			IJ.run(imp, "Grays", "")
			imp.show()

			imp_max = Zproj.run(imp,'max')
			IJ.run(imp_max, "Grays", "")
			imp_max.show()

			# save the Z projection
			IJ.save(imp_max,file.rsplit('_',1)[0]+'_processed.tif')
Exemple #39
0
def run(imagefile, useBF=True, series=0):

    log.info('Image Filename : ' + imagefile)

    if not useBF:
        # using IJ static method
        imp = IJ.openImage(imagefile)

    if useBF:

        # initialize the importer options
        options = ImporterOptions()
        options.setOpenAllSeries(True)
        options.setShowOMEXML(False)
        options.setConcatenate(True)
        options.setAutoscale(True)
        options.setId(imagefile)

        # open the ImgPlus
        imps = BF.openImagePlus(options)
        imp = imps[series]

    # apply the filter
    if FILTERTYPE != 'NONE':

        # apply filter
        log.info('Apply Filter  : ' + FILTERTYPE)
        log.info('Filter Radius : ' + str(FILTER_RADIUS))

        # apply the filter based on the choosen type
        imp = apply_filter(imp,
                           radius=FILTER_RADIUS,
                           filtertype=FILTERTYPE)

    if FILTERTYPE == 'NONE':
        log.info('No filter selected. Do nothing.')

    return imp
Exemple #40
0
import os, sys
from ij import IJ
from ij.io import FileSaver
from loci.plugins import BF
from subprocess import call
from ij.plugin import ZProjector 

try:
	filepath = getArgument()
except Exception, e:
	sys.exit(" no file " + e)
try:
	imp = BF.openImagePlus(filepath)
	image = imp[0]
	zProj = ZProjector(image)
	zProj.setMethod(zProj.MAX_METHOD)
	zProj.doProjection()
	imgMax = zProj.getProjection()
	#imgMax.show()
	FileSaver(imgMax).saveAsTiff(os.path.splitext(filepath)[0] + "_MAX.tif")
except Exception, e:
	sys.exit(e)
except Exception, e:
	sys.exit(e)
Exemple #41
0
arg = re.split('\s+-c', arg)
if len(arg)>1:
	xmlfile = arg[0]
	ch = int(arg[1])
else:
	xmlfile = arg[0]
	ch = 1

#open xml file and parse it
tree = ET.parse(xmlfile)
root = tree.getroot()
obj, imgName = getPosition(root)
print imgName

#open image
img =  BF.openImagePlus(imgName)[0] 
img.setZ(obj[1][2]+1)
img.setC(int(ch))
img.show()


#draw rois
for i in range(1, len(obj)+1):
	PR = PointRoi(obj[i][0],obj[i][1])
	try:
		PR.setSize(3)
		PR.setPointType(0)
		roim.addRoi(PR)
	except:
		roim.addRoi(PR)
from ij import IJ as ij
from ij.plugin.frame import RoiManager
from ij.gui import Roi, PolygonRoi 

from loci.plugins import BF
from loci.common import Region
from loci.plugins.in import ImporterOptions
from loci.formats import ImageReader, ImageWriter
from loci.formats import MetadataTools
from ome.xml.meta import OMEXMLMetadata

file = "%s"

options = ImporterOptions()
options.setId(file)
imps = BF.openImagePlus(options)

reader = ImageReader()
omeMeta = MetadataTools.createOMEXMLMetadata()
reader.setMetadataStore(omeMeta)
reader.setId(file)

roiCount = omeMeta.getROICount()

if roiCount > 1:
    sys.exit(0)

omeMetaStr =  omeMeta.dumpXML()
shape = omeMeta.getShapeType(0,0)

if 'Polygon' not in shape:
Exemple #43
0
	for ch in range(1, channels + 1):
		projector = ZProjector(ImagePlus("C%i" % ch, splitter.getChannel(image, ch)))
		projector.setMethod(ZProjector.MAX_METHOD)
		projector.doProjection()
		proj = projector.getProjection()
		enhancer.equalize(proj)
		chimps.append(proj)
		
	return RGBStackMerge.mergeChannels(chimps, False)

manders = MandersColocalization()
results = ResultsTable()
for imageFile in os.listdir(inputDir):
	print "Opening " + imageFile
	try:
		images = BF.openImagePlus(inputDir + imageFile)
		image = images[0]
	except UnknownFormatException:
		continue
	preview = getPreview(image)
	preview.show()
	rm = RoiManager()
	dialog = WaitForUserDialog("Action required", "Please select regions of interest in this image. Click OK when done.")
	dialog.show()
	rm.close()
	splitter = ChannelSplitter()
	imp1 = ImagePlus("CH1", splitter.getChannel(image, imageA))
	imp2 = ImagePlus("CH2", splitter.getChannel(image, imageB))
	title = image.getTitle()
	title = title[:title.rfind('.')]
	image.close()
Exemple #44
0
    else:
	pixels = False

    if flat and pixels:
        print("Both --flat and --pixels cannot be specified simultaneously.")
        sys.exit(1)

print referenceFile
print objectListFile
print outputFile

# Open source image
try:
    image = IJ.openImage(referenceFile)
except Exception:
    images = BF.openImagePlus(referenceFile)
    image = images[0]
	
calibration = image.getCalibration()
zscale = calibration.getZ(1) / calibration.getX(1)
channels = image.getNChannels()

# Read objects
objects = csv.reader(open(objectListFile))
fmin = []
fmax = []
thrF = 50.000
sx = image.getWidth() 
sy = image.getHeight() 
sz = image.getNSlices()
			options['edgeXY'] = True
	if args.exclude_edge_z:
		if str(args.exclude_edge_z).upper() == "TRUE":
			options['edgeZ'] = False
		else:
			options['edgeZ'] = True
else:
	options['inputFile'] = "sample.tif"
	options['outputDir'] = "./"

if options['paramsOut'] == None:
	results = []
	try:
		image = IJ.openImage(options['inputFile'])
	except Exception:
		images = BF.openImagePlus(options['inputFile'])
		image = images[0]
	
	if options['oneShot']:
		results.append(runSimulation(options, image))
	else:
		parameters = makeParameters(options)
		for index in range(0, len(parameters)):
			options.update(parameters[index])
			results.append(runSimulation(options, image))
	
	resultsTable = ResultsTable()
	resultsTable.showRowNumbers(False)

	for i in range(0, len(results)):
		if options['oneShot']:
Exemple #46
0
def processMovie(root, files, outfile):
    """Concatenate images and write ome.tiff file.
    If image contains already multiple time points just copy the image"""

    files.sort()

    options = ImporterOptions()
    options.setId(files[0])
    options.setVirtual(1)

    image = BF.openImagePlus(options)
    image = image[0]
    if image.getNFrames() > 1:
        msg = ("%s Contains multiple time points. Can only concatenate"
               " single time points!" %files[0])
        raise RuntimeError(msg)
        image.close()

    reader = ImageReader()
    reader.setMetadataStore(MetadataTools.createOMEXMLMetadata())
    reader.setId(files[0])
    timeInfo = []
    omeOut = reader.getMetadataStore()
    omeOut = setUpXml(omeOut, image, files)
    reader.close()
    image.close()
    itime = 0

    for fileName in files:
        omeMeta = MetadataTools.createOMEXMLMetadata()
        reader.setMetadataStore(omeMeta)
        reader.setId(fileName)
        timeInfo.append(getTimePoint(reader, omeMeta))

        nrImages = reader.getImageCount()
        for i in range(0, reader.getImageCount()):
            try:
                dT = round(timeInfo[files.index(fileName)]-timeInfo[0],2)
            except:
                dT = (timeInfo[files.index(fileName)]-timeInfo[0]).seconds
            omeOut.setPlaneDeltaT(dT, 0, i + itime*nrImages)
            omeOut.setPlanePositionX(omeOut.getPlanePositionX(0,i), 0, i + itime*nrImages)
            omeOut.setPlanePositionY(omeOut.getPlanePositionY(0,i), 0, i + itime*nrImages)
            omeOut.setPlanePositionZ(omeOut.getPlanePositionZ(0,i), 0, i + itime*nrImages)
            omeOut.setPlaneTheC(omeOut.getPlaneTheC(0,i), 0, i + itime*nrImages)
            omeOut.setPlaneTheT(omeOut.getPlaneTheT(0,i), 0, i + itime*nrImages)
            omeOut.setPlaneTheZ(omeOut.getPlaneTheZ(0,i), 0, i + itime*nrImages)
        itime = itime + 1
        reader.close()

        IJ.showProgress(files.index(fileName), len(files))

    try:
        omeOut.setPixelsTimeIncrement(float(dT/(len(files)-1)), 0)
    except:
        omeOut.setPixelsTimeIncrement(0, 0)

    if len(files) <= 1:
        raise RuntimeError('Found only one file. Nothing to concatenate')

    outfile = concatenateImagePlus(files, outfile)
    filein = RandomAccessInputStream(outfile)
    fileout = RandomAccessOutputStream(outfile)
    saver = TiffSaver(fileout, outfile)
    saver.overwriteComment(filein, omeOut.dumpXML())
    fileout.close()
    filein.close()
@String(label="Base Directory", style="") str_dir
@String(label="Image Title", style="") str_img_nam
@String(label="Image Extension", style="", value=".tif") str_img_ext
file = str_dir + "/" + str_img_nam + str_img_ext
# read in and display ImagePlus object(s)
from loci.plugins import BF
from loci.formats import ImageReader
from loci.formats import MetadataTools
from ij import IJ
from ome.units import UNITS

imps = BF.openImagePlus(file)
for imp in imps:
    imp.show()
    reader = ImageReader()
    omeMeta = MetadataTools.createOMEXMLMetadata()
    reader.setMetadataStore(omeMeta)
    reader.setId(file)
    seriesCount = reader.getSeriesCount()
    reader.close()
    # print out series count from two different places (they should always match!)
    imageCount = omeMeta.getImageCount()
    IJ.log("Total # of image series (from BF reader): " + str(seriesCount))
    IJ.log("Total # of image series (from OME metadata): " + str(imageCount))
    physSizeX = omeMeta.getPixelsPhysicalSizeX(0)
    physSizeY = omeMeta.getPixelsPhysicalSizeY(0)
    physSizeZ = omeMeta.getPixelsPhysicalSizeZ(0)
    IJ.log("Physical calibration:")
    if (physSizeX is not None):
    	IJ.log("\tX = " + str(physSizeX.value()) + " " + physSizeX.unit().getSymbol()
		+ " = " + str(physSizeX.value(UNITS.MICROM)) + " microns")
Exemple #48
0
# USER PARAMETERS TO CHANGE
#############################
#Diameter in microns
cellDiameter=3.0
# The minimum intensity for a peak to be considered
minPeak=0
#Use point(1), icosphere(2), or icosphere but limited to the first 3495 points in X (3)
plotType=USE_POINT
# diameter Cell visualization
cellIcosophere=3.0

#Open the image and duplicate it to get an 8 Bits version use to plot
od = OpenDialog("Open image file", None)
srcFile = od.getPath()
srcDir = od.getDirectory()
imp = BF.openImagePlus(srcFile)[0]
imp8Bits = imp.duplicate()
ImageConverter(imp8Bits).convertToGray8()
print "Image " + srcFile + " open successfully!"
#Create the coordinate.txt file to ouput the point coordinate
coordinateFile = open(srcDir + "coordinate.txt", "w")
print "Created " +srcDir + "coordinate.txt"
# If minPeak is set to 0, set it to automatically.
if minPeak == 0:
	minPeak = AutoThresholder().getThreshold("Percentile", imp.getStatistics().histogram); 

#Get the pixel calibration
cal=imp.getCalibration()
#Set Gaussian Sigma parameters for the Difference of Gaussian
sigmaLarge=[cellDiameter/cal.pixelWidth,cellDiameter/cal.pixelHeight,cellDiameter/cal.pixelDepth]
sigmaSmall=[a/2 for a in sigmaLarge]
def regBf(fn=None, imp=None, refId=None):
    """ 
        Register a time series stack to a specified reference slice, 
            from a file (imported by BioFormat) or a stack ImagePlus.
        Returns a registered ImagePlus.
        The stack must have only 1 z layer.
        refId is in the format of [int channel, int slice, int frame]
            If no refId is supplied, will use the first slice [1,1,1]

        Note: since TurboReg is used for registeration, there will be 
            temporary opened image windows.

    """

    ## Prepare the right ImagePlus
    if imp is None:
        if fn is None:
            od = OpenDialog("Choose a file", None)
            filename = od.getFileName()

            if filename is None:
                print "User canceled the dialog!"
                return
            else:
                directory = od.getDirectory()
                filepath = directory + filename
                print "Selected file path:", filepath
        else:
            if os.path.exists(fn) and os.path.isfile(fn):
                filepath = fn
            else:
                print "File does not exist!"
                return

        imps = BF.openImagePlus(filepath)
        imp = imps[0]
        if imp is None:
            print "Cannot load file!"
            return

    else:
        if fn is not None:
            print "File or ImagePlus? Cannot load both."
            return

    width = imp.getWidth()
    height = imp.getHeight()
    # C
    nChannels = imp.getNChannels()
    # Z
    nSlices = imp.getNSlices()
    # T
    nFrames = imp.getNFrames()
    # pixel size
    calibration = imp.getCalibration()

    # Only supoort one z layer
    if nSlices != 1:
        print "Only support 1 slice at Z dimension."
        return

    # set registration reference slice
    if refId is None:
        refC = 1
        refZ = 1
        refT = 1
    else:
        refC = refId[0]
        refZ = refId[1]
        refT = refId[2]
        if (refC not in range(1, nChannels+1) or
            refZ not in range(1, nSlices+1) or
            refT not in range(1, nFrames+1) ):
            print "Invalid reference image!"
            return

    stack = imp.getImageStack()
    registeredStack = ImageStack(width, height, nChannels*nFrames*nSlices)

    # setup windows, these are needed by TurboReg
    tmpip = FloatProcessor(width, height)
    refWin = ImageWindow(ImagePlus("ref", tmpip))
    bounds = refWin.getBounds()
    # refWin.setVisible(False)
    toRegWin = ImageWindow(ImagePlus("toReg", tmpip))
    toRegWin.setLocation(bounds.width + bounds.x, bounds.y)
    # toRegWin.setVisible(False)
    toTransformWin = ImageWindow(ImagePlus("toTransform", tmpip))
    toTransformWin.setLocation(2 * bounds.width + bounds.x, bounds.y)
    # toTransformWin.setVisible(False)

    # get reference image
    refImp = ImagePlus("ref", stack.getProcessor(imp.getStackIndex(refC, refZ, refT)))
    refWin.setImage(refImp)

    tr = TurboReg_()

    for t in xrange(1, nFrames+1):
        IJ.showProgress(t-1, nFrames)

        # print "t ", t
        # do TurboReg on reference channel
        toRegId = imp.getStackIndex(refC, refZ, t)
        toRegImp = ImagePlus("toReg", stack.getProcessor(toRegId))
        toRegWin.setImage(toRegImp)

        regArg =  "-align " +\
                  "-window " + toRegImp.getTitle() + " " +\
                  "0 0 " + str(width - 1) + " " + str(height - 1) + " " +\
                  "-window " + refImp.getTitle() + " " +\
                  "0 0 " + str(width - 1) + " " + str(height - 1) + " " +\
                  "-rigidBody " +\
                  str(width / 2) + " " + str(height / 2) + " " +\
                  str(width / 2) + " " + str(height / 2) + " " +\
                  "0 " + str(height / 2) + " " +\
                  "0 " + str(height / 2) + " " +\
                  str(width - 1) + " " + str(height / 2) + " " +\
                  str(width - 1) + " " + str(height / 2) + " " +\
                  "-hideOutput"
                
        tr = TurboReg_()
        tr.run(regArg)
        registeredImp = tr.getTransformedImage()
        sourcePoints = tr.getSourcePoints()
        targetPoints = tr.getTargetPoints()

        registeredStack.setProcessor(registeredImp.getProcessor(), toRegId)

        # toRegImp.flush()

        # apply transformation on other channels
        for c in xrange(1, nChannels+1):
            # print "c ", c
            if c == refC:
                continue

            toTransformId = imp.getStackIndex(c, 1, t)
            toTransformImp = ImagePlus("toTransform", stack.getProcessor(toTransformId))
            toTransformWin.setImage(toTransformImp)

            transformArg = "-transform " +\
                           "-window " + toTransformImp.getTitle() + " " +\
                           str(width) + " " + str(height) + " " +\
                           "-rigidBody " +\
                           str(sourcePoints[0][0]) + " " +\
                           str(sourcePoints[0][1]) + " " +\
                           str(targetPoints[0][0]) + " " +\
                           str(targetPoints[0][1]) + " " +\
                           str(sourcePoints[1][0]) + " " +\
                           str(sourcePoints[1][1]) + " " +\
                           str(targetPoints[1][0]) + " " +\
                           str(targetPoints[1][1]) + " " +\
                           str(sourcePoints[2][0]) + " " +\
                           str(sourcePoints[2][1]) + " " +\
                           str(targetPoints[2][0]) + " " +\
                           str(targetPoints[2][1]) + " " +\
                           "-hideOutput"

            tr = TurboReg_()
            tr.run(transformArg)
            registeredStack.setProcessor(tr.getTransformedImage().getProcessor(), toTransformId)

            # toTransformImp.flush()
            sourcePoints = None
            targetPoints = None

        IJ.showProgress(t, nFrames)
        IJ.showStatus("Frames registered: " + str(t) + "/" + str(nFrames))

    refWin.close()
    toRegWin.close()
    toTransformWin.close()

    imp2 = ImagePlus("reg_"+imp.getTitle(), registeredStack)
    imp2.setCalibration(imp.getCalibration().copy())
    imp2.setDimensions(nChannels, nSlices, nFrames)
    # print "type ", imp.getType()
    # print "type ", imp2.getType()
    # print nChannels, " ", nSlices, " ", nFrames
    # print registeredStack.getSize()

    for key in imp.getProperties().stringPropertyNames():
        imp2.setProperty(key, imp.getProperty(key))
    # comp = CompositeImage(imp2, CompositeImage.COLOR)  
    # comp.show()
    # imp2 = imp.clone()
    # imp2.setStack(registeredStack)
    # imp2.setTitle("reg"+imp.getTitle())
    # imp2.show()
    # imp.show()

    return imp2
from ij import IJ
from ij.io import DirectoryChooser
import os
from loci.plugins import BF
from loci.plugins.in import ImporterOptions

inputFolder = DirectoryChooser('Set input directory.').getDirectory()
outputFolder = DirectoryChooser('Set output directory.').getDirectory()
for filename in os.listdir(inputFolder):
	if '.zvi' in filename:
		
		id = inputFolder +'/'+ filename;
		options = ImporterOptions();
		options.setId(id);
		options.setAutoscale(True);
		options.setColorMode(ImporterOptions.COLOR_MODE_GRAYSCALE);
		
		image = BF.openImagePlus(options)[0];
		nameWithoutExt = os.path.splitext(filename)[0]
		# Export the image
		save_path =  outputFolder +'/' + nameWithoutExt + '.ome.tif'
		IJ.run(image, "Bio-Formats Exporter", "save=" + save_path + " compression=Uncompressed");
		image.close()
			overlayImage.setSlice(2)
			IJ.run(overlayImage, "Delete Slice", "")
	return overlayImage
	
#### Main Stuff #####

outputFilePath = inputDirectory + '/' + outputFile
if os.path.isfile(outputFilePath):
	os.remove(outputFilePath)
outputFile = open(outputFilePath, 'a')

for fileName in os.listdir(inputDirectory):
	print 'Processing Image ' , fileName
	if '.tif' in fileName:
		#print 'Opening image...'
		imps = BF.openImagePlus(os.path.join(inputDirectory, fileName))
		image = imps[0]
		image.show()
		# Select tumor
		WaitForUserDialog("Select the tumor by hand.").show()
		# Measure Area
		currentROI = image.getROI()
		image.setRoi(currentRoi)
		stats = image.getStatistics(Measurements.AREA)
		currentArea = stats.area
		image.killRoi()

		# Create an overlay
		if currentROI is not None:
			overlayImage = createOverlay(image, selectedROI)
		else: