def readHeader(self): """ read metadata """ self.dataOffset = 0 self._secExtraByteSize = 0 # ========== obtain reader ============ # getting the right reader for tiff is not always done by bioformats... self.is_ometiff = False if self.fn.lower().endswith(OMETIFF) or \ not self.fn.lower().endswith(READABLE_FORMATS): self.fp = bioformats.ImageReader(self.fn, perform_init=False) self.handle = self.fp rdr = self.fp.rdr = self._readOMETiffHeader( self.fn.lower().endswith(OMETIFF)) else: # reading meta data of standard file formats self.xml = bioformats.get_omexml_metadata(self.fn) self.fp = bioformats.ImageReader(self.fn) self.handle = self.fp rdr = self.fp.rdr # http://stackoverflow.com/questions/2365411/python-convert-unicode-to-ascii-without-errors if sys.version_info.major == 2: self.xml = self.xml.replace(u'\xb5', u'u') # micro -> "u" self.xml = unicodedata.normalize('NFKD', self.xml).encode( 'ascii', 'ignore') else: self.xml = self.xml.replace('µ', '\xb5') #'u') # micro -> "u" self.omexml = ome.OMEXML(self.xml) # ========== setup attributes =========== self.ome = OME_XML_Editor(self.omexml) self.setUpDynamicList(self.ome) self.setDim() # ========== obtain other data =========== self.nseries = self.omexml.get_image_count() # obtain meta data other than Image # TODO: This must be done in a more structured way in the future if hasattr(self.omexml, 'root_node'): for node in self.omexml.root_node.getchildren(): name = repr(node).split()[1].split('}')[1].replace("'", '') if name not in ('Image', 'StructuredAnnotations'): self.metadata[name] = dict(list(node.items())) for cnode in node.getchildren(): cname = repr(cnode).split()[1].split('}')[1].replace( "'", '') self.metadata[name][cname] = dict(list(cnode.items()))
def read_image(filelike): """Read an image volume from a file. Parameters ---------- filelike : string or bf.ImageReader Either a filename containing a BioFormats image, or a `bioformats.ImageReader`. Returns ------- image : numpy ndarray, 5 dimensions The read image. """ if not VM_STARTED: start() if VM_KILLED: raise RuntimeError("The Java Virtual Machine has already been " "killed, and cannot be restarted. See the " "python-javabridge documentation for more " "information. You must restart your program " "and try again.") if isinstance(filelike, bf.ImageReader): rdr = filelike else: rdr = bf.ImageReader(filelike) image = rdr.read(rescale=False) return image
def read_images(image_ids, max_zs, lif_file): """ Read rgb images from lif file :param image_ids: List of image ids (series #), to extract :param max_zs: List of max z-depths for each image :param lif_file: Path to lif file to extract images from :return: List of images containing image data """ images = [] with bf.ImageReader(path=lif_file) as reader: for i, s in enumerate(image_ids): for z in range(0, max_zs[i]): try: image_data = reader.read(c=None, z=z, t=0, series=s, index=None, rescale=False, wants_max_intensity=False, channel_names=None, XYWH=None) except: print('Error reading image data') continue # Need to add blue channel, as microscope only saves red and green rgb_image = add_blue_channel(image_data) images.append(rgb_image) return images
def merge_image_channel_files(data_path, dataset, i): """ Given the path to the folder containing all of the image files, look up the channel files corresponding to cell i of the dataset and merge its channel files into a plane generator. The plane generator should return an x-y plane of values for each z, channel, and time combination (in that order). In this case, we have a variable number of z planes, 3 channels, and 1 time. """ cell_name = 'cell{}'.format(i) prefix = dataset['file_prefix'] first_channel_file = '_'.join([prefix, cell_name, 'ch0', 't1.tif']) first_channel_path = os.path.join(data_path, first_channel_file) with bioformats.ImageReader(first_channel_path) as reader: z_count = reader.rdr.getImageCount() def plane_generator(): for z_i in xrange(z_count): for i in xrange(len(CHANNELS)): channel_infix = CHANNELS[i]['file_infix'] channel_file = '_'.join( [prefix, cell_name, channel_infix, 't1.tif']) channel_path = os.path.join(data_path, channel_file) with bioformats.ImageReader(channel_path) as reader: yield reader.read(index=z_i) return plane_generator, z_count
def _start_lif_reader(self): jv.start_vm(class_path=bf.JARS) log_level = 'ERROR' # reduce log level # currently does not work in new conda environment #rootLoggerName = jv.get_static_field("org/slf4j/Logger", "ROOT_LOGGER_NAME", "Ljava/lang/String;") #rootLogger = jv.static_call("org/slf4j/LoggerFactory", "getLogger", "(Ljava/lang/String;)Lorg/slf4j/Logger;", rootLoggerName) #logLevel = jv.get_static_field("ch/qos/logback/classic/Level", log_level, "Lch/qos/logback/classic/Level;") #jv.call(rootLogger, "setLevel", "(Lch/qos/logback/classic/Level;)V", logLevel) self.ir = bf.ImageReader(self.lif_file_path, perform_init=True) mdroot = et.ElementTree.fromstring(bf.get_omexml_metadata(self.lif_file_path)) mds = list(map(lambda e: e.attrib, mdroot.iter('{http://www.openmicroscopy.org/Schemas/OME/2016-06}Pixels'))) # lif can contain multiple images, select one that is likely to be the timeseries self.metadata = None self.lif_stack_idx = 0 for idx, md in enumerate(mds): if int(md['SizeT']) > 1: self.lif_stack_idx = idx self.metadata = md if not self.metadata: raise ValueError('lif does not contain an image with sizeT > 1')
def load_imgs_generator(self): axes = self.check_dims_equal() for fn in self.img_fns: dims = get_pixel_dimensions(fn) #print(" -- ", fn, dims) ir = bf.ImageReader(str(fn)) img = numpy.zeros((dims.t, dims.z, dims.y, dims.x, dims.c), numpy.float32) for t in range(dims.t): for z in range(dims.z): for c in range(dims.c): img[t, z, :, :, c] = ir.read(series=0, z=z, c=c, t=t, rescale=False) if "Z" not in axes: img = img[:, 0, ...] yield img ir.close()
def align(im, warp_matrix): dic = oib.image_info(im) x = int(dic['frame_size_x']) y = int(dic['frame_size_y']) c = int(dic['channels']) z = int(dic['z_steps']) t = int(dic['time_frames']) with bioformats.ImageReader(im, perform_init=True) as rdr: image = np.empty([t, z, y, x, c], np.uint16) for c in range(c): image[:, :, :, :, c] = rdr.read(c=1, rescale=False) image[:, :, :, :, c] = cv2.warpAffine( (rdr.read(c=0, rescale=False)), warp_matrix, (y, x), flags=cv2.INTER_LINEAR + cv2.WARP_INVERSE_MAP) for t in range(t): image[t, :, :, :, c] = cv2.warpAffine( (rdr.read(t=t, z=0, c=0, rescale=False)), warp_matrix, (y, x), flags=cv2.INTER_LINEAR + cv2.WARP_INVERSE_MAP) for z in range(z): image[:, z, :, :, c] = cv2.warpAffine( (rdr.read(z=z, c=0, rescale=False)), warp_matrix, (y, x), flags=cv2.INTER_LINEAR + cv2.WARP_INVERSE_MAP) return image
def __enter__(self): javabridge.start_vm(class_path=bioformats.JARS, run_headless=True) self.reader = bioformats.ImageReader(self.path) self.metadatastr = bioformats.get_omexml_metadata(self.path) self.metadata = ETree.fromstring(self.metadatastr.encode('utf-8')) self.initialize() return self
def __init__(self, imgfile, output_path): self.imgfile = imgfile try: self.image = I.ImarisImage(self.imgfile) if not os.path.isdir(output_path): raise IOError('Invalid output directory: ', output_path) else: # create unique output directory from image filename filename = basename(imgfile) new_folder = splitext(filename)[0] image_folder = join(output_path, new_folder) if not os.path.isdir(image_folder): os.makedirs(image_folder) self.output_folder = image_folder try: javabridge.start_vm(run_headless=True, class_path=bioformats.JARS) javabridge.attach() except Exception as e: raise (e) javabridge.attach() self.basicmeta = javabridge.jutil.to_string( bioformats.formatreader.make_iformat_reader_class().getMetadata(bioformats.ImageReader(imgfile).rdr)).split(',') self.basicmeta = sorted(self.basicmeta) self.omemeta = bioformats.get_omexml_metadata(imgfile).split("></") self.omemeta1 = self.omemeta[0].split(".xsd") self.omemeta2 = self.omemeta[1:] #javabridge.detach() except Exception as e: raise (e)
def read_bioformat(image, resize=False): '''Read Images in almost any format. Parameters ---------- resize : bool, optional If "true", will resize image to 1024, while keeping the ratio. Returns ------- image : numpy ndarray, 5 dimensions The read image. ''' if JVM_BEGIN == False: begin_javabridge() if JVM_END == True: raise RuntimeError("The java virtual Machine has already ended " "you should restart the program") else: with bioformats.ImageReader(image) as rdr: image = rdr.read(rescale=False) if resize == True: size = np.max(image.shape) if size > 1024: image = imresize(image, 1024. / size) return image
def test_read_subimage_tif(): path = os.path.join(os.path.dirname(__file__), 'resources', 'Channel1-01-A-01.tif') with bioformats.ImageReader(path) as f: data_0_10_0_10 = f.read(XYWH=(0, 0, 10, 10), rescale=False) # # Data as read by cellprofiler.modules.loadimages.load_using_PIL # expected_0_10_0_10 = numpy.array( [[ 0, 7, 7, 6, 5, 8, 4, 2, 1, 2], [ 0, 8, 8, 7, 6, 10, 4, 2, 2, 2], [ 0, 9, 9, 7, 8, 8, 2, 1, 3, 2], [ 0, 10, 9, 8, 10, 6, 2, 2, 3, 2], [ 0, 10, 10, 10, 9, 4, 2, 2, 2, 2], [ 0, 9, 9, 10, 8, 3, 2, 4, 2, 2], [ 0, 9, 9, 10, 8, 2, 2, 4, 3, 2], [ 0, 9, 8, 9, 7, 4, 2, 2, 2, 2], [ 0, 10, 11, 9, 9, 4, 2, 2, 2, 2], [ 0, 12, 13, 12, 9, 4, 2, 2, 2, 2]], dtype=numpy.uint8) expected_n10_n10 = numpy.array( [[2, 1, 1, 1, 2, 2, 1, 2, 1, 2], [1, 2, 2, 2, 2, 1, 1, 1, 2, 1], [1, 1, 1, 2, 1, 2, 2, 2, 2, 1], [2, 2, 2, 2, 3, 2, 2, 2, 2, 1], [1, 2, 2, 1, 1, 1, 1, 1, 2, 2], [2, 1, 2, 2, 2, 1, 1, 2, 2, 2], [2, 2, 3, 2, 2, 1, 2, 2, 2, 1], [3, 3, 1, 2, 2, 2, 2, 3, 2, 2], [3, 2, 2, 2, 2, 2, 2, 2, 3, 3], [5, 2, 3, 3, 2, 2, 2, 3, 2, 2]], dtype=numpy.uint8) assert numpy.all(expected_0_10_0_10 == data_0_10_0_10)
def imread_bioformats(path): """Thin wrapper around bioformats, slow and shitty, but works in a pinch, only reads z stack -- no time""" # import modules tp ise import javabridge import bioformats import gc import itertools # start the jave VM with the appropriate classes loaded javabridge.start_vm(class_path=bioformats.JARS) # init the reader with bioformats.ImageReader(path) as reader: # init container data = [] for i in itertool.count(): try: data.append(reader.read(z=i, rescale=False)) except javabridge.JavaException: # reached end of file, break break # clean up a little javabridge.kill_vm() gc.collect() # return ndarray return np.asarray(data)
def load_bioformats(path, serie=0): meta, _ = _metadata(path, serie=serie) image = np.empty((meta['SizeT'], meta['SizeZ'], meta['SizeX'], meta['SizeY'], meta['SizeC'])) with bioformats.ImageReader(path) as rdr: for t in range(0, meta['SizeT']): for z in range(0, meta['SizeZ']): for c in range(0, meta['SizeC']): image[t, z, :, :, c] = rdr.read(c=c, z=z, t=t, series=serie, index=None, rescale=False, wants_max_intensity=False, channel_names=None) img = np.squeeze(image) if img.ndim == 3: mip = np.amax(img, 0) elif img.ndim == 4: mip = np.amax(img[:, :, :, 1], 0) else: print("need to correct for ndim > 3") directory = _new_directory(path, meta) return (img, directory, mip, meta)
def get_series_from_well(imagefile, sizes, seriesseq): """ Reads all scenes from a single well and stores them in a array. """ if not VM_STARTED: start_jvm() if VM_KILLED: jvm_error() rdr = bioformats.ImageReader(imagefile, perform_init=True) sizes[0] = len(seriesseq) #img6dwell = np.empty(sizes, dtype=BF2NP_DTYPE[rdr.rdr.getPixelType()]) img6dwell = np.zeros(sizes, dtype=BF2NP_DTYPE[rdr.rdr.getPixelType()]) for seriesID in range(0, len(seriesseq)): for timepoint in range(0, sizes[1]): for zplane in range(0, sizes[2]): for channel in range(0, sizes[3]): img6dwell[seriesID, timepoint, zplane, channel, :, :] =\ rdr.read(series=seriesID, c=channel,z=zplane, t=timepoint, rescale=False) rdr.close() return img6dwell
def merge_image_channel_files(tif_name, infix): """ Given a path containing directories for each channel, grab the channel image for image_name in each of the channels, and merge them into a single plane generator which is returned. The plane generator should return an x-y plane of values for each z, channel, and time combination (in that order). In this case, we have a variable number of z planes, 3 channels, and 1 time. """ with bioformats.ImageReader(tif_name) as reader: z_count = reader.rdr.getImageCount() prefix = tif_name[:tif_name.rindex(infix)] def plane_generator(): for z_i in xrange(z_count): for channel in CHANNELS: if channel == "Cell membrane": channel_path = prefix + "cell.tif" elif channel == "DNA": channel_path = prefix + "nucleus.tif" elif channel == "protein": channel_path = tif_name with bioformats.ImageReader(channel_path) as reader: yield reader.read(index=z_i) return plane_generator, z_count
def read_series(img_path, img_meta): with bioformats.ImageReader(img_path) as rdr: for i, m in enumerate(img_meta): img = np.array([ rdr.read(c=c, series=i, rescale=False) for c in range(m.sizec) ]) yield img, m
def get_image6d(imagefile, sizes): """ This function will read the image data and store them into a 6D numpy array. The 6D array has the following dimension order: [Series, T, Z, C, X, Y]. """ if not VM_STARTED: start_jvm() if VM_KILLED: jvm_error() rdr = bioformats.ImageReader(imagefile, perform_init=True) #img6d = np.empty(sizes, dtype=BF2NP_DTYPE[rdr.rdr.getPixelType()]) img6d = np.zeros(sizes, dtype=BF2NP_DTYPE[rdr.rdr.getPixelType()]) # main loop to read the images from the data file for seriesID in range(0, sizes[0]): for timepoint in range(0, sizes[1]): for zplane in range(0, sizes[2]): for channel in range(0, sizes[3]): img6d[seriesID, timepoint, zplane, channel, :, :] =\ rdr.read(series=seriesID, c=channel, z=zplane, t=timepoint, rescale=False) rdr.close() return img6d
def save_images(self): """Saves the individual images as a npy file 2D might have more acquisitions +/- focal plane, (usually 3 images). focal_plane_idx corresponds to the plane to consider. Mid-plane is the one in focus and the +/- on either side would be blurred. For 2D acquisitions, this is stored along the Z dimension. How is this handled for 3D acquisitions? """ if not os.path.exists(self.lif_fname): raise FileNotFoundError("LIF file doesn't exist at:", self.lif_fname) os.makedirs(self.split_dir, exist_ok=True) jv.start_vm(class_path=bf.JARS, max_heap_size='8G') metadata = bf.get_omexml_metadata(self.lif_fname) omexml_object = bf.OMEXML(metadata) num_channels = omexml_object.image().Pixels.channel_count num_samples = omexml_object.get_image_count() num_timepoints = omexml_object.image().Pixels.SizeT num_pix_z = omexml_object.image().Pixels.SizeZ size_x_um = omexml_object.image().Pixels.PhysicalSizeX size_y_um = omexml_object.image().Pixels.PhysicalSizeY size_z_um = omexml_object.image().Pixels.PhysicalSizeZ reader = bf.ImageReader(self.lif_fname, perform_init=True) records = [] for timepoint_idx in range(num_timepoints): timepoint_dir = os.path.join(self.split_dir, 'timepoint_{}'.format(timepoint_idx)) os.makedirs(timepoint_dir, exist_ok=True) for channel_idx in range(num_channels): channel_dir = os.path.join(timepoint_dir, 'channel_{}'.format(channel_idx)) os.makedirs(channel_dir, exist_ok=True) for sample_idx in range(15, 412): # num_samples cur_records = self.save_each_image(reader, num_pix_z, channel_dir, timepoint_idx, channel_idx, sample_idx, size_x_um, size_y_um, size_z_um) records.extend(cur_records) msg = 'Wrote files for tp:{}, channel:{}'.format( timepoint_idx, channel_idx) self._log_info(msg) df = pd.DataFrame.from_records(records, columns=[ 'timepoint', 'channel_num', 'sample_num', 'slice_num', 'fname', 'size_x_microns', 'size_y_microns', 'size_z_microns' ]) metadata_fname = os.path.join(self.split_dir, 'split_images_info.csv') df.to_csv(metadata_fname, sep=',') jv.kill_vm()
def get_serie_stack(self, serie_ix: int): stack = [] with bf.ImageReader(self.fullpath) as rdr: for z in range(self.md.SizeZ[serie_ix]): # Loop through z slices im = rdr.read(z=z, series=serie_ix, rescale=False) stack.append(im) stack = np.array(stack) return stack
def read_psf(path,output_type=np.float32): NX,NY,NZ,NC,NT=get_movie_shape(path) #assert(NC==1) #assert(NT==1) psf=np.zeros((NX,NY,NZ),dtype=output_type) with bf.ImageReader(path=path) as reader: for z in range(NZ): psf[:, :, z] = reader.read(c=z, rescale=False) return psf
def __init__(self, frontend): super().__init__(frontend) self._rdr = bioformats.ImageReader(str(self.frontend._file_path)) # Test to see if the loci_tools.jar is present if bfio.JARS == None: raise FileNotFoundError( "The loci_tools.jar could not be found.")
def plane_generator(): for z_i in xrange(z_count): for i in xrange(len(CHANNELS)): channel_infix = CHANNELS[i]['file_infix'] channel_file = '_'.join( [prefix, cell_name, channel_infix, 't1.tif']) channel_path = os.path.join(data_path, channel_file) with bioformats.ImageReader(channel_path) as reader: yield reader.read(index=z_i)
def __init__(self, file_path): ImagingExtractor.__init__(self) self.file_path = Path(file_path) self._start_javabridge_vm() self._reader = bioformats.ImageReader(str(self.file_path)) # read metadata self._read_metadata() self._validate_metadata()
def get_image6d_subset(imagefile, sizes, seriesstart=0, seriesend=0, tstart=0, tend=0, zstart=0, zend=0, chstart=0, chend=0): """ Attention: Still Experimental !!! This function will read a subset of the image file store them into a 6D numpy array. The 6D array has the following dimension order: [Series, T, Z, C, X, Y]. """ if not VM_STARTED: start_jvm() if VM_KILLED: jvm_error() rdr = bioformats.ImageReader(imagefile, perform_init=True) subsetSizeS = seriesend - seriesstart subsetSizeT = tend - tstart subsetSizeZ = zend - zstart subsetSizeC = chend - chstart subsetsizes = [ subsetSizeS, subsetSizeT, subsetSizeZ, subsetSizeC, sizes[4], sizes[5] ] img6dsubset = np.zeros(subsetsizes, dtype=BF2NP_DTYPE[rdr.rdr.getPixelType()]) readstate = 'OK' readproblems = [] # main loop to read the images from the data file for seriesID in range(seriesstart, seriesend): for timepoint in range(tstart, tend): for zplane in range(zstart, zend): for channel in range(chstart, chend): try: img6dsubset[seriesID, timepoint, zplane, channel, :, :] =\ rdr.read(series=seriesID, c=channel, z=zplane, t=timepoint, rescale=False) except: print( 'Problem reading data into Numpy Array for Series', seriesID, sys.exc_info()[1]) readstate = 'NOK' readproblems = sys.exc_info()[1] rdr.close() return img6dsubset, readstate
def get_image6d_multires(imagefile, MetaInfo): """ This function will read the image data series by series. Every series will be stored inside a tuple as a 5D numpy array. The 5D array has the following dimension order: [T, Z, C, X, Y]. """ if not VM_STARTED: start_jvm() if VM_KILLED: jvm_error() rdr = bioformats.ImageReader(imagefile, perform_init=True) readstate = 'OK' readproblems = [] # initialize the empty list that will hold all the 5D image arrays series_list = [] numseries = MetaInfo['Sizes'][0] sizeT = MetaInfo['Sizes'][1] sizeZ = MetaInfo['Sizes'][2] sizeC = MetaInfo['Sizes'][3] for seriesID in range(0, numseries): # read the XY dimension of the first series current_sizeX = MetaInfo['SeriesDimensions'][seriesID][0] current_sizeY = MetaInfo['SeriesDimensions'][seriesID][1] newsize = [sizeT, sizeZ, sizeC, current_sizeX, current_sizeY] # create the 5D numpy array img5d = np.zeros(newsize, dtype=BF2NP_DTYPE[rdr.rdr.getPixelType()]) # main loop to read the images from the data file for timepoint in range(0, sizeT): for zplane in range(0, sizeZ): for channel in range(0, sizeC): try: img5d[timepoint, zplane, channel, :, :] =\ rdr.read(series=seriesID, c=channel, z=zplane, t=timepoint, rescale=False) except: print( 'Problem reading data into Numpy Array for Series', seriesID, sys.exc_info()[1]) readstate = 'NOK' readproblems = sys.exc_info()[1] # store the 5D array inside a tuple series_list.append(img5d) # clear the array from memory img5d = None rdr.close() return series_list, readstate
def image_5d(file_name, series=0, rescale=False, frames=None, zslices=None, channels=None): """Read a single series as 5d numpy array Args: file_name (str): path to file series (int, optional): series to open. Defaults to 0. rescale (bool, optional): rescale each plane to min/max. Defaults to False. frames (list[int], optional): list of frame indices to read. Defaults to None. zslices (list[int], optional): list of zslice indices to read. Defaults to None. channels (list[int], optional): list of channel indices to read. Defaults to None. Returns: numpy.array: 5d numpy array (TZCYX) """ JVM().start() with bf.ImageReader(file_name) as reader: reader.rdr.setSeries(series) dtype = get_numpy_pixel_type(reader.rdr.getPixelType()) t_size, z_size, c_size, y_size, x_size = _get_TXCYX_shape(reader) t_list = range(t_size) if frames is not None: t_list = sorted(list(set(frames) & set(t_list))) assert len(t_list) > 0, "Please choose at least one valid frame" z_list = range(z_size) if zslices is not None: z_list = sorted(list(set(zslices) & set(z_list))) assert len(z_list) > 0, "Please choose at least one valid z-slice" c_list = range(c_size) if channels is not None: c_list = sorted(list(set(channels) & set(c_list))) assert len(c_list) > 0, "Please choose at least one valid channel" img_5d = np.zeros( (len(t_list), len(z_list), len(c_list), y_size, x_size), dtype=dtype) for ti, t in enumerate(t_list): for zi, z in enumerate(z_list): for ci, c in enumerate(c_list): img_5d[ti, zi, ci, :, :] = reader.read(series=series, z=z, t=t, c=c, rescale=rescale) return img_5d
def load_bioformats(path, folder_batch="", channel=None, no_meta_direct=False): meta = metadata(path) if channel: image = np.empty( (meta['SizeT'], meta['SizeZ'], meta['SizeX'], meta['SizeY'], 1)) with bioformats.ImageReader(path) as rdr: for t in range(0, meta['SizeT']): for z in range(0, meta['SizeZ']): image[t, z, :, :, 0] = rdr.read(c=channel, z=z, t=t, series=None, index=None, rescale=False, wants_max_intensity=False, channel_names=None) else: image = np.empty((meta['SizeT'], meta['SizeZ'], meta['SizeX'], meta['SizeY'], meta['SizeC'])) with bioformats.ImageReader(path) as rdr: for t in range(0, meta['SizeT']): for z in range(0, meta['SizeZ']): for c in range(0, meta['SizeC']): image[t, z, :, :, c] = rdr.read(c=c, z=z, t=t, series=None, index=None, rescale=False, wants_max_intensity=False, channel_names=None) if no_meta_direct == True: return (np.squeeze(image)) else: if folder_batch: path = folder_batch return (np.squeeze(image), meta, _new_directory_batch(path, meta)) else: return (np.squeeze(image), meta, _new_directory(path, meta))
def load_timelapse(self, name): "Loads a TXY record" numframes = self.get_size('T') axes = self.get_axes() reader = bioformats.ImageReader(name) kw = dict(series=self.index, rescale=False) images = np.array( [reader.read(t=i, **kw) for i in range(1, numframes)]) out = fseq.from_array(images) out.meta['axes'] = axes return out
def plane_generator(): for z_i in xrange(z_count): for channel in CHANNELS: if channel == "Cell membrane": channel_path = prefix + "cell.tif" elif channel == "DNA": channel_path = prefix + "nucleus.tif" elif channel == "protein": channel_path = tif_name with bioformats.ImageReader(channel_path) as reader: yield reader.read(index=z_i)
def get_tiled_omexml_metadata(path=None, url=None, *, group_file=True): """ Read tiled czi image and get ZeissCZIReader without stitching Parameters --------- path : str, default None path to the czi file url : str, default None url to the czi file (optional) groupfiles: bool, default True utilize the groupfiles option to take the directory structure into account. Returns ------- xml : str the OME-XML string Notes ----- Copied & modified from bioformats.get_omexml_metadata """ with bioformats.ImageReader(path=path, url=url, perform_init=False) as rdr: # # Below, "in" is a keyword and Rhino's parser is just a little wonky I fear. # # It is critical that setGroupFiles be set to false, goodness knows # why, but if you don't the series count is wrong for flex files. # script = f""" importClass(Packages.loci.common.services.ServiceFactory, Packages.loci.formats.services.OMEXMLService, Packages.loci.formats['in'].ZeissCZIReader, Packages.loci.formats['in'].DefaultMetadataOptions, Packages.loci.formats['in'].DynamicMetadataOptions, Packages.loci.formats['in'].MetadataLevel); reader.setGroupFiles({'true' if group_file else 'false'}); reader.setOriginalMetadataPopulated(true); var service = new ServiceFactory().getInstance(OMEXMLService); var metadata = service.createOMEXMLMetadata(); reader.setMetadataStore(metadata); reader.setMetadataOptions(new DefaultMetadataOptions(MetadataLevel.ALL)); var dynop=DynamicMetadataOptions(); dynop.set(ZeissCZIReader.ALLOW_AUTOSTITCHING_KEY,'false'); dynop.set(ZeissCZIReader.INCLUDE_ATTACHMENTS_KEY,'false'); reader.setMetadataOptions(dynop); reader.setId(path); var xml = service.getOMEXML(metadata); xml; """ xml = jutil.run_script(script, dict(path=rdr.path, reader=rdr.rdr)) return xml