def __init__(self,image_path=None): self._metaData=self._meta_init() if image_path is not None: self.importMeta(image_path) bioformats.clear_image_reader_cache() javabridge._javabridge.reap()
def get_filename(self, workspace, make_dirs=True, check_overwrite=True): """Concoct a filename for the current image based on the user settings""" measurements = workspace.measurements if self.file_name_method == FN_SINGLE_NAME: filename = self.single_file_name.value filename = workspace.measurements.apply_metadata(filename) elif self.file_name_method == FN_SEQUENTIAL: filename = self.single_file_name.value filename = workspace.measurements.apply_metadata(filename) n_image_sets = workspace.measurements.image_set_count ndigits = int(numpy.ceil(numpy.log10(n_image_sets + 1))) ndigits = max((ndigits, self.number_of_digits.value)) padded_num_string = str( measurements.image_set_number).zfill(ndigits) filename = "%s%s" % (filename, padded_num_string) else: file_name_feature = self.source_file_name_feature filename = measurements.get_current_measurement( "Image", file_name_feature) filename = os.path.splitext(filename)[0] if self.wants_file_name_suffix: suffix = self.file_name_suffix.value suffix = workspace.measurements.apply_metadata(suffix) filename += suffix filename = "%s.%s" % (filename, self.get_file_format()) pathname = self.pathname.get_absolute_path(measurements) if self.create_subdirectories: image_path = self.source_path(workspace) subdir = os.path.relpath(image_path, self.root_dir.get_absolute_path()) pathname = os.path.join(pathname, subdir) if len(pathname) and not os.path.isdir(pathname) and make_dirs: try: os.makedirs(pathname) except: # # On cluster, this can fail if the path was created by # another process after this process found it did not exist. # if not os.path.isdir(pathname): raise result = os.path.join(pathname, filename) if check_overwrite and not self.check_overwrite(result, workspace): return if check_overwrite and os.path.isfile(result): try: os.remove(result) except: import bioformats bioformats.clear_image_reader_cache() os.remove(result) return result
def get_filename(self, workspace, make_dirs=True, check_overwrite=True): "Concoct a filename for the current image based on the user settings" measurements = workspace.measurements if self.file_name_method == FN_SINGLE_NAME: filename = self.single_file_name.value filename = workspace.measurements.apply_metadata(filename) elif self.file_name_method == FN_SEQUENTIAL: filename = self.single_file_name.value filename = workspace.measurements.apply_metadata(filename) n_image_sets = workspace.measurements.image_set_count ndigits = int(numpy.ceil(numpy.log10(n_image_sets + 1))) ndigits = max((ndigits, self.number_of_digits.value)) padded_num_string = str(measurements.image_set_number).zfill(ndigits) filename = '%s%s' % (filename, padded_num_string) else: file_name_feature = self.source_file_name_feature filename = measurements.get_current_measurement('Image', file_name_feature) filename = os.path.splitext(filename)[0] if self.wants_file_name_suffix: suffix = self.file_name_suffix.value suffix = workspace.measurements.apply_metadata(suffix) filename += suffix filename = "%s.%s" % (filename, self.get_file_format()) pathname = self.pathname.get_absolute_path(measurements) if self.create_subdirectories: image_path = self.source_path(workspace) subdir = os.path.relpath(image_path, self.root_dir.get_absolute_path()) pathname = os.path.join(pathname, subdir) if len(pathname) and not os.path.isdir(pathname) and make_dirs: try: os.makedirs(pathname) except: # # On cluster, this can fail if the path was created by # another process after this process found it did not exist. # if not os.path.isdir(pathname): raise result = os.path.join(pathname, filename) if check_overwrite and not self.check_overwrite(result, workspace): return if check_overwrite and os.path.isfile(result): try: os.remove(result) except: import bioformats bioformats.clear_image_reader_cache() os.remove(result) return result
def __init__(self,image_path=None): super().__init__(image_path) if image_path is not None: self.pixels=np.zeros((self._metaData["size_z"],self._metaData["size_y"],self._metaData["size_x"],self._metaData["size_c"]), dtype=self.xml.image().Pixels.PixelType) self._metaData["DimensionOrder"] = "ZYXC" self._metaData["xml_original"].Pixels.DimensionOrder = "ZYXC" with ImageReader(image_path) as rdr: for channel in range(self._metaData["size_c"]): for z_index in range(self._metaData["size_z"]): self.pixels[z_index,:,:,channel]= rdr.read(c=channel,z=z_index,rescale=False) rdr.close() bioformats.clear_image_reader_cache() javabridge._javabridge.reap() self.sumprj=(np.sum(self.pixels,axis=0)) self.maxprj=(np.amax(self.pixels,axis=0)) self.meanprj=(np.mean(self.pixels,axis=0))
def loadBioImageSeriesFromFile(filepath, meta: BioMeta) -> np.ndarray: assert meta.shape is not None, "No parsed BioMeta provided" file = np.zeros(meta.shape) try: # loads a cached reader that reads every frame with bioformats.ImageReader(filepath, perform_init=True) as reader: for c in range(meta.sizec): for z in range(meta.sizez): for t in range(meta.sizet): # bioformats appears to swap axes for tif images and read all three channels at a time for RGB im1 = reader.read(c=c, z=z, t=t, series=meta.series, rescale=True, channel_names=None) if im1.ndim == 3: if im1.shape[2] == 3: # Three channels are red im2 = im1[:, :, c] else: im2 = im1 else: im2 = im1 if (meta.sizex == im2.shape[1]) and ( meta.sizey == im2.shape[0] ) and not meta.sizex == meta.sizey: # x and y are swapped logging.warning( "Image might be transposed. Swapping X and Y") im3 = im2.transpose() else: im3 = im2 file[:, :, c, z, t] = im3 logging.info("BioImage Parsed") except Exception as e: logging.error("Something went wrong whilst parsing the BioImageFile") logging.error(e) finally: bioformats.clear_image_reader_cache() return file
def get_filename(self, workspace, make_dirs=True, check_overwrite=True): """Concoct a filename for the current image based on the user settings""" measurements = workspace.measurements file_name_feature = self.source_file_name_feature filename = measurements.get_current_measurement( "Image", file_name_feature) filename = os.path.splitext(filename)[0] if self.wants_file_name_suffix: suffix = self.file_name_suffix.value suffix = workspace.measurements.apply_metadata(suffix) filename += suffix filename = "%s.%s" % (filename, self.get_file_format()) pathname = self.pathname.get_absolute_path(measurements) if self.create_subdirectories: image_path = self.source_path(workspace) subdir = os.path.relpath(image_path, self.root_dir.get_absolute_path()) pathname = os.path.join(pathname, subdir) if len(pathname) and not os.path.isdir(pathname) and make_dirs: try: os.makedirs(pathname) except: # # On cluster, this can fail if the path was created by # another process after this process found it did not exist. # if not os.path.isdir(pathname): raise result = os.path.join(pathname, filename) if check_overwrite and not self.check_overwrite(result, workspace): return if check_overwrite and os.path.isfile(result): try: os.remove(result) except: import bioformats bioformats.clear_image_reader_cache() os.remove(result) return result
raw_data = np.empty([y_range, x_range, z_range, c_range], dtype=np.uint8) #raw_data = [] with bioformats.get_image_reader(key="cached_bf_reader", path=path_to_data, \ url=None) as reader: # Read the stack for every channel for c in range(c_range): # Read the whole stack for z in range(z_range): # Ignore the time raw_image = reader.read(c=c, z=z, t=0, series=None, index=None, \ rescale=False, wants_max_intensity=False, \ channel_names=None, XYWH=None) raw_data[:, :, z, c] = raw_image bioformats.release_image_reader("cached_bf_reader") bioformats.clear_image_reader_cache() reader.close() if depth == 't': # Get the reader and read every image from the stack of the first image # series (series 0) in dimension order XYZC raw_data = np.empty([y_range, x_range, t_range, c_range], dtype=np.uint8) #raw_data = [] with bioformats.get_image_reader(key="cached_bf_reader", path=path_to_data, \ url=None) as reader: # Read the stack for every channel for c in range(c_range): # Read the whole stack for t in range(t_range): # Ignore the time raw_image = reader.read(c=c, z=0, t=t, series=None, index=None, \
async def convertBioImageToXArray(filepath, index, progress): await progress("Loading Biometa") biometa = loadBioMetaFromFile(filepath) imagemeta = biometa.findAll("Image")[index] # General Parsing Parameters name = imagemeta.attrs["Name"] parsedimagemeta = parseMeta(imagemeta, imagetree) scan = parsedimagemeta["scan"] shape = (scan["SizeX"], scan["SizeY"], scan["SizeC"], scan["SizeZ"], scan["SizeT"]) # Channels and Planes (TODO: Planes are given to be in z,c,t shape in xml format?, if error: sort) zlinearorderedplanes = constructDim(imagetree, parsedimagemeta, "planes", "z") zctorderplanes = zlinearorderedplanes.data.reshape((scan["SizeZ"], scan["SizeC"], scan["SizeT"])) channels = constructDim(imagetree, parsedimagemeta, "channels", "c") planes = xr.DataArray(zctorderplanes, dims=("z", "c", "t")) rescale, scalefactor = await calculateRescaleAndScaleFactor(scan, progress) if rescale: await progress(f"Rescaling because we want float64") await progress(f"Insignificant Bits detected: Scalefactor of {scalefactor}x applies") # Population newfile = da.zeros(shape) newfile = xr.DataArray(newfile, dims=["x", "y", "c", "z", "t"]) newfile = xr.DataArray(newfile, coords={"physx": newfile.x * float(scan["PhysicalSizeX"]), "physy": newfile.y * float(scan["PhysicalSizeY"]), "phsyz": newfile.z * float(scan["PhysicalSizeZ"]), "physt": newfile.t * float( scan.get("TimeIncrement", 1) if scan.get("TimeIncrement", 1) is not None else 1), "x": newfile.x, "y": newfile.y, "z": newfile.z, "t": newfile.t, "c": newfile.c, "channels": channels, "planes": planes }) try: # loads a cached reader that reads every frame with bioformats.ImageReader(filepath, perform_init=True) as reader: for c in range(shape[2]): await progress(f"Processing channel {channels[c].data['Name']}") for z in range(shape[3]): for t in range(shape[4]): # bioformats appears to swap axes for tif images and read all three channels at a time for RGB im1 = reader.read(c=c, z=z, t=t, series=index, rescale=rescale, channel_names=None) if scalefactor != 1: im1 = im1 * scalefactor if im1.ndim == 3: if im1.shape[2] == 3: # Three channels are red im2 = im1[:, :, c] else: im2 = im1 else: im2 = im1 if im2.shape[0] == shape[1] and im2.shape[0] != shape[0]: # Transposed axes for whatever reason im3 = np.swapaxes(im2, 0, 1) else: im3 = im2 newfile[:, :, c, z, t] = im3 await progress("BioImage Parsed") finally: bioformats.clear_image_reader_cache() newfile.attrs["scan"] = [scan] newfile.attrs["seriesname"] = name newfile.name = name return newfile, parsedimagemeta
def get_tif_stack(filepath, series=0, depth='z', return_dim_order='YXZC'): """ This function assumes, that the Javabridge-VM is started and initialized with the bioformats jars: javabridge.start_vm(class_path=bioformats.JARS) To kill the vom use: javabridge.kill_vm() Parameters: filepath (string): Path to the multistack tif file series: (int): Number of the image series which shuld be read. Default = 0 time_step: Number of the time step which should be read. Default = 0 (NOT IMPLEMENTED) depth (string): 'z', when the depth is the z-axis or 't', when the depth is the t-axis bit_depth (integer): Power of two from the bit-depth of the file to be read. return_dim_order (string): In which order the raw data should be returned. XYZC, YXZC ... Returns: meta_data (dictionary): Metadata Dictionary of the tif file raw_data (numpy-array): Numpy-Array which contains the raw data of the image stack in the tif file """ # Get XML metadata of complete file xml_string = bioformats.get_omexml_metadata(filepath) ome_xml = bioformats.OMEXML(xml_string) # Read the metadata from the image -> series 0 iome = ome_xml.image(series) series_count = ome_xml.get_image_count() image_name = iome.get_Name() image_id = iome.get_ID() image_acquisition = iome.get_AcquisitionDate() # Geth the pixel meta data from the image ch_count = iome.Pixels.get_channel_count() dim_order = iome.Pixels.get_DimensionOrder() pic_id = iome.Pixels.get_ID() phy_x = iome.Pixels.get_PhysicalSizeX() phy_x_unit = iome.Pixels.get_PhysicalSizeXUnit() phy_y = iome.Pixels.get_PhysicalSizeY() phy_y_unit = iome.Pixels.get_PhysicalSizeYUnit() phy_z = iome.Pixels.get_PhysicalSizeZ() phy_z_unit = iome.Pixels.get_PhysicalSizeZUnit() pix_type = iome.Pixels.get_PixelType() plane_count = iome.Pixels.get_plane_count() c_range = iome.Pixels.get_SizeC() t_range = iome.Pixels.get_SizeT() x_range = iome.Pixels.get_SizeX() y_range = iome.Pixels.get_SizeY() z_range = iome.Pixels.get_SizeZ() # Make a dictionary out of the metadata meta_data = {} meta_data['series_count'] = series_count meta_data['image_name'] = image_name meta_data['image_id'] = image_id meta_data['image_acquisition'] = image_acquisition meta_data['channel_count'] = ch_count meta_data['original_dimension_order'] = dim_order meta_data['numpy_array_dimension_order'] = 'XYZC' meta_data['picture_id'] = pic_id meta_data['physical_size_x'] = phy_x meta_data['physical_size_x_unit'] = phy_x_unit meta_data['physical_size_y'] = phy_y meta_data['physical_size_y_unit'] = phy_y_unit meta_data['physical_size_z'] = phy_z meta_data['physical_size_z_unit'] = phy_z_unit meta_data['pixel_data_type'] = pix_type meta_data['plane_count'] = plane_count meta_data['channel_size'] = c_range meta_data['time_size'] = t_range meta_data['x_size'] = x_range meta_data['y_size'] = y_range meta_data['z_size'] = z_range # Get the datatype of each pixel if pix_type == 'uint8': np_dtype = np.uint8 if pix_type == 'uint16': np_dtype = np.uint16 if depth == 'z': # Allocate a numpy array for the given dimension raw_data = np.empty([y_range, x_range, z_range, c_range], dtype=np_dtype) # Get the reader and read every image from the stack of the first image # series (series 0) in dimension order XYZC with bioformats.get_image_reader(key="cached_bf_reader", path=filepath, \ url=None) as reader: # Read the stack for every channel for c in range(c_range): # Read the whole stack for z in range(z_range): # Ignore the time-axis raw_image = reader.read(c=c, z=z, t=0, series=None, index=None, \ rescale=False, wants_max_intensity=False, \ channel_names=None, XYWH=None) raw_data[:, :, z, c] = raw_image if depth == 't': # Allocate a numpy array for the given dimension raw_data = np.empty([y_range, x_range, t_range, c_range], dtype=np_dtype) # Get the reader and read every image from the stack of the first image # series (series 0) in dimension order XYZC with bioformats.get_image_reader(key="cached_bf_reader", path=filepath, \ url=None) as reader: # Read the stack for every channel for c in range(c_range): # Read the whole stack for t in range(t_range): # Ignore the z-axis raw_image = reader.read(c=c, z=0, t=t, series=None, index=None, \ rescale=False, wants_max_intensity=False, \ channel_names=None, XYWH=None) raw_data[:, :, t, c] = raw_image # Clear the cache and close the reader bioformats.release_image_reader("cached_bf_reader") bioformats.clear_image_reader_cache() reader.close() if return_dim_order == 'XYZC': return meta_data, np.transpose(raw_data, axes=(1, 0, 2, 3)) else: # YXZC return meta_data, raw_data
parser.add_argument('--file', metavar='file', help='file containing the image .lif extension') parser.add_argument('--size', metavar='size', help='which series ranges to extract') parser.add_argument( '--dest', metavar='dest', help='the numpy array format text file name as destination of extraction') # Reading the file args = parser.parse_args() # Converting range t = tuple([int(x) for x in args.size.split(",")]) window = range(*t) # Program Here javabridge.start_vm(class_path=bf.JARS) reader = bf.get_image_reader('r1', path="./180509_Permeabilisation_Test.lif") #meta = bf.get_omexml_metadata(args.file) #xmlome = bf.OMEXML(meta) #mdroot = ETree.fromstring(meta.encode('utf-8')) for i in window: n, m = reader.read(c=0, series=i, rescale=False, wants_max_intensity=True) np.savetxt(str(i) + args.dest, n) bf.clear_image_reader_cache() javabridge.kill_vm()
def compaction_fish(pars): flowb_c = 0 global temp_report_dir temp_report_dir = tempfile.TemporaryDirectory(dir="./") flowb_c = angler.PDF_gen(angler.rep_first_page( pars, title="ANGLER: compaction FISH analysis"), temp_report_dir.name, counter=flowb_c) sample_style_sheet = getSampleStyleSheet() if pars["#ofImages"] is "all": files = glob.glob(pars['folder_path'] + "/*" + pars['file_ext'])[:] else: files = glob.glob(pars['folder_path'] + "/*" + pars['file_ext'])[:pars['#ofImages']] # files = glob.glob(pars['folder_path'] + "/*" + pars['file_ext'])[:150] tot = len(files) # report_cols=['file_name','ch#','crop#','feret-diameter','convex_hull'] measurements = pd.DataFrame() print("start") for j, file_path in enumerate(files): flowbs = [] # Open Image img = angler.MicImage(image_path=file_path) para = Paragraph(path_leaf(file_path), sample_style_sheet['Heading2']) flowbs.append(para) for i, ch in enumerate(pars["FISH_ch"]): ch_measurements = pd.DataFrame() # crds = angler.FISH_finder(img.maxprj[..., ch], thresh=pars['FISH_finder_threshold'][ch],crop_size=pars['crop_size']) # For 2D crds crds = angler.FISH_finder( img.pixels[..., ch], thresh=pars['FISH_finder_threshold'][ch], crop_size=pars['crop_size']) #For 3D crds crds = [[i, [j, k]] for i, j, k in crds] for crd_no, (z_crd, xy_crd) in enumerate(crds): try: measurement = {} measurement = {"file_name": path_leaf(file_path)} measurement.update({"channel": ch}) measurement.update({"crop#": crd_no}) measurement.update({"crop_coordinates": xy_crd}) # crop each crd # crp=img.crop(center_coord=crd,channel=ch,crop_size=pars['crop_size']) # For 2D if pars['use_z']: crp = crp = img.crop(center_coord=xy_crd, channel=ch, crop_size=pars['crop_size'], z_coord=z_crd, z_size=pars['number_of_stacks']) else: crp = crp = img.crop(center_coord=xy_crd, channel=ch, crop_size=pars['crop_size'], z_coord=None) if pars["noise_removal"]: # remove Background no_noise = angler.subtract_bkg(crp) # measure feret feret_m = angler.feret( prj=no_noise.getPRJ(pars["prj_method"]), pixel_size=angler.pixel_size(no_noise), threshold=pars['feret_threshold']) else: # measure feret feret_m = angler.feret( prj=crp.getPRJ(pars["prj_method"]), pixel_size=angler.pixel_size(crp), threshold=pars['feret_threshold']) #color code for plot measurement.update(feret_m) ch_measurements = ch_measurements.append(pd.DataFrame( [measurement]), ignore_index=True) except: print( 'Something went wrong with feret measurement of image', str(measurement['file_name']), str(measurement['crop#'])) # Make the graph measurements = measurements.append(ch_measurements, ignore_index=True) # try: fig = angler.compaction_plotter(img, ch, ch_measurements, pars) buf = BytesIO() fig.savefig(buf, dpi=300, format="tiff") buf.seek(0) plt.close(fig) fig_img = Image(buf, 6.3 * inch, 4.5 * inch) flowbs.append(fig_img) # except: # print('Something went wrong with crd plotting of image',str(measurement['file_name']),str(measurement['crop#'])) flowb_c = angler.PDF_gen(flowables=flowbs, path=temp_report_dir.name, counter=flowb_c) # buf.close() bioformats.clear_image_reader_cache() angler.update_progress("Compaction_FISH:", index=j + 1, total=tot) pdf_paths = glob.glob(temp_report_dir.name + '/*.pdf') pdf_paths.sort() angler.pdf_merger(pars["pdf_report_path"], pdf_paths) temp_report_dir.cleanup() print("\n PDF report created in:{}".format(pars["pdf_report_path"])) return measurements