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 SubmitAction(self): roi_buff = [ int(self.roi_xbuff_line.text()), int(self.roi_ybuff_line.text()) ] analyzer = RecruitmentMovieAnalyzer() analyzer.SetParameters(protein_channel=self.prot_channel_line.text(), nuclear_channel=self.nuc_channel_line.text(), additional_rois=int(self.roi_spinbox.value()), irrad_frame=int(self.irrad_frame_line.text()), bleach_frames=int(self.irrad_frame_line.text()), save_direct=self.out_direct_line.text(), roi_buffer=roi_buff) if self.single_file_button.isChecked(): analyzer.LoadFile(video_file=self.movie_file_line.text(), roi_file=self.roi_file_line.text()) else: analyzer.LoadDirectory(video_direct=self.batch_direct_line.text(), extension=self.movie_file_line.text(), roi_extension=self.roi_file_line.text()) javabridge.start_vm(class_path=bioformats.JARS) t0 = time.time() #try: if 1: analyzer.ProcessFileList() #except: # print("Error processing the filelist!!!") tf = time.time() print("Processed file(s) in "\ +str(np.around((tf-t0)/60,decimals=3))\ +" minutes.") javabridge.kill_vm() pass
def __init__(self, dv_path, tag_path=None, cache_all=True, speak=True): self.dv_path = dv_path self.tag_path = tag_path self.cache_all = cache_all javabridge.start_vm(class_path=bioformats.JARS) if speak: print('Getting DV metadata....') self.meta_str = bioformats.get_omexml_metadata(path=self.dv_path) if speak: print('Solving metadata...') self.meta_xml = bioformats.omexml.OMEXML(self.meta_str) if cache_all: if speak: print('Caching all images') self.cache_image = self.__read_image() else: self.cache_image = np.empty(0) self.reader = bioformats.get_image_reader(None, self.dv_path) if tag_path is not None: tmp = sio.loadmat(tag_path)['tag'] if len(tmp.shape) < 3: tmp = np.reshape(tmp, newshape=(1, tmp.shape[0], tmp.shape[1])) self.tags = tmp.astype(np.int32) else: self.tags = np.empty(0)
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 extract_merged_images(lif_file, out_dir): """ Extract merged images, in lif, into output directory :param lif: path to lif file :param out_dir: path to directory to store images :return: {path: (physical_size)} - metadata of images written. """ jv.start_vm(class_path=bf.JARS, max_heap_size='8G') merged_images = get_merged_image_ids(lif_file) image_data = {} for series in merged_images: image_ids, max_z, physical_size = merged_images[series] image_data[series] = (read_images(image_ids, max_z, lif_file), physical_size[0]) # Only read first merged image break # Finished reading data from the lif file jv.kill_vm() image_metadata = {} # Write images to out_dir for series in image_data: image_data, physical_size = image_data[series] # Write data in image_data for i, data in enumerate(image_data): out_path = out_dir + "/" + series + "_Z" + str(i) + ".tif" cv2.imwrite(out_path, data) image_metadata[out_path] = (physical_size) return image_metadata
def read_file(input_directory, pixelsize, output_directory): img_pixelsize_x = pixelsize img_pixelsize_y = pixelsize modelfile_path = "2d_cell_net_v0-cytoplasm.modeldef.h5" weightfile_path = "snapshot_cytoplasm_iter_1000.caffemodel.h5" iofile_path = "output.h5" out_path = Path(output_directory) rootdir1 = Path(input_directory) """ Convert the tif to tiled tiff """ javabridge.start_vm(args=["-Dlog4j.configuration=file:{}".format(LOG4J)], class_path=JARS, run_headless=True) i = 0 try: for PATH in rootdir1.glob('**/*'): tile_grid_size = 1 tile_size = tile_grid_size * 1024 # Set up the BioReader with BioReader(PATH, backend='java', max_workers=cpu_count()) as br: # Loop through timepoints for t in range(br.T): # Loop through channels for c in range(br.C): with BioWriter(out_path.joinpath(f"final{i}.ome.tif"), metadata=br.metadata, backend='java') as bw: # Loop through z-slices for z in range(br.Z): # Loop across the length of the image for y in range(0, br.Y, tile_size): y_max = min([br.Y, y + tile_size]) # Loop across the depth of the image for x in range(0, br.X, tile_size): x_max = min([br.X, x + tile_size]) input_img = np.squeeze(br[y:y_max, x:x_max, z:z + 1, c, t]) img = unet_segmentation( input_img, img_pixelsize_x, img_pixelsize_y, modelfile_path, weightfile_path, iofile_path) bw[y:y_max, x:x_max, ...] = img os.remove("output.h5") i += 1 finally: # Close the javabridge. Since this is in the finally block, it is always run javabridge.kill_vm()
def convert_and_resample_from_tif(file_name, output_file='image_cropped_ana.h5', z_factor=2.35, path_to_image='data'): import javabridge import bioformats javabridge.start_vm(class_path=bioformats.JARS) r = bioformats.ImageReader(file_name) shape = (r.rdr.getSizeT(), r.rdr.getSizeC(), r.rdr.getSizeZ(), r.rdr.getSizeY(), r.rdr.getSizeX()) shape_r = (r.rdr.getSizeT(), r.rdr.getSizeC(), int(z_factor * r.rdr.getSizeZ()), r.rdr.getSizeY(), r.rdr.getSizeX()) img = numpy.zeros(shape, dtype=numpy.float32) img_r = numpy.zeros(shape_r, dtype=numpy.float32) img_r_prefilter = numpy.zeros(shape_r, dtype=numpy.float32) for t in range(shape[0]): print "T:", t, for c in range(shape[1]): for z in range(shape[2]): img[t, c, z, :, :,] = r.read(c=c, t=t, z=z) img_r[t,c,:,:,:] = vigra.sampling.resizeVolumeSplineInterpolation(img[t,c,:,:,:], shape_r[2:]) img_r_prefilter[t, c, :, :, :] = ndimage.spline_filter(img_r[t,c,:,:,:]) f = h5py.File(output_file, 'w') f["/"].create_dataset(path_to_image, data=img) f["/"].create_dataset(path_to_image + "_resampled", data=img_r) f["/"].create_dataset(path_to_image + "_resampled_prefiltered", data=img_r_prefilter) f.close() javabridge.kill_vm()
def ensure_VM(): global numVMRefs if numVMRefs <1: javabridge.start_vm(class_path=bioformats.JARS, run_headless=True) numVMRefs += 1
def main(): javabridge.start_vm(class_path=bioformats.JARS) app = QApplication(sys.argv) form = AppForm() form.show() sys.exit(app.exec_()) javabridge.kill_vm()
def convert_nd2_all_samples(config, parallelize=0): """ """ # TODO: Fill in docstring workspace_directory = config["workspace_directory"] input_directory = Path(config["data_directory"]) output_directory = Path(workspace_directory, "unstitched") output_directory.mkdir(exist_ok=True) samples = config["samples"] # TODO: Figure out if it's possible to parallelize by sample here. # TODO: Figure out better error handling here (e.g. catch error and # kill JVM if error occurs) javabridge.start_vm(class_path=bioformats.JARS) processes = [] for sample in samples: if parallelize > 0: process = mp.Process(target=convert_nd2_single_sample, args=(sample, input_directory, output_directory, parallelize - 1)) process.start() processes.append(process) else: convert_nd2_single_sample(sample, input_directory, output_directory) for process in processes: process.join() javabridge.kill_vm()
def main(args): if hasattr(sys, 'frozen'): jar_path = os.path.join(os.path.dirname(sys.executable), "jars") jars = [os.path.join(jar_path, os.path.split(jar)[1]) for jar in bioformats.JARS] else: jars = bioformats.JARS javabridge.start_vm(class_path=jars) try: filenames = sum(map(glob.glob, sys.argv[1:]), []) app = wx.PySimpleApp() if len(filenames) == 0: with wx.FileDialog( None, "Pick files for z-stack", wildcard="Tiff files (*.tif)|*.tif|All files (*.*)|*.*", style = wx.FD_FILE_MUST_EXIST | wx.FD_MULTIPLE | wx.FD_OPEN) as dlg: assert isinstance(dlg, wx.FileDialog) if dlg.ShowModal() != wx.ID_OK: return filenames = dlg.Paths planes = [bioformats.load_image(filename) for filename in filenames] img_red, img_green, img_blue = [ np.dstack([plane[:, :, i] for plane in planes]) *255 for i in range(3)] frame = Q3DFrame(img_red, img_green, img_blue, None, size=(1024, 768)) frame.SetTitle("Q3DStack: %s" %filenames[0]) app.MainLoop() finally: javabridge.kill_vm()
def _startJavabridge(logger): global _javabridgeStarted if _javabridgeStarted is None: # Only import these when first asked. They are slow to import. global bioformats global javabridge if bioformats is None: import bioformats if javabridge is None: import javabridge # We need something to wake up at exit and shut things down monitor = threading.Thread(target=_monitor_thread) monitor.daemon = True monitor.start() try: javabridge.start_vm(class_path=bioformats.JARS, run_headless=True) _reduceLogging() atexit.register(_stopJavabridge) logger.info('Started JVM for Bioformats tile source.') _javabridgeStarted = True except RuntimeError as exc: logger.exception('Cannot start JVM for Bioformats tile source.', exc) _javabridgeStarted = False return _javabridgeStarted
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 __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 main(*args): jars = javabridge.JARS classpath = os.getenv("CLASSPATH", None) if not classpath: classpath = subprocess.check_output("clj -Spath", shell=True).decode('utf-8') if classpath: jars = jars + [classpath] javabridge.start_vm(run_headless=True, class_path=jars) env = javabridge.get_env() stringclass = env.find_class("java/lang/String") if len(args) == 0: args = ["-r"] args = ["-e", "(require 'clj-python-trampoline.interpreter)"] + list(args) cljargs = env.make_object_array(len(args), stringclass) for i, arg in enumerate(args): env.set_object_array_element(cljargs, i, env.new_string_utf(arg)) c = env.find_class("clojure/main") method_id = env.get_static_method_id(c, "main", "([Ljava/lang/String;)V") env.call_static_method(c, method_id, cljargs)
def readZPositions(stk_files): # the only entry parameter for this function is a list with # the stk files print('\n\t\treading z-values... ') javabridge.start_vm(class_path=bioformats.JARS) zs = [] # array with z-positions ts = [] # array with time point (got from data files) print('starting loop...') for file_path in stk_files: print('reading file: {}'.format(file_path)) md = bioformats.get_omexml_metadata(file_path) ome = bioformats.OMEXML(md) # create an instance of an image to read z-position zp = ome.image().Pixels.Plane().get_PositionZ() time = int(file_path[:-4].split('t')[-1]) zs.append(zp) ts.append(time) z_offsets = np.array([item - min(np.array(zs)) for item in zs]) javabridge.kill_vm() return np.array(zs), np.array(ts), z_offsets
def __init__(self): jb.start_vm(class_path=bf.JARS) self.omexml = bf.metadatatools.createOMEXMLMetadata() self.ImageReader = bf.formatreader.make_image_reader_class() self.reader = self.ImageReader() self.reader.setMetadataStore(self.omexml)
def start_vm(args=None, class_path=None, max_heap_size=None, run_headless=False): """ Start the JVM via Javabridge. """ if class_path is None: class_path = get_java_class_path() # Start the JVM. javabridge.start_vm(args=args, class_path=class_path, max_heap_size=max_heap_size, run_headless=run_headless) # Suppress Java logging to stdout. java_stack = javabridge.make_instance('java/io/ByteArrayOutputStream', "()V") java_stack_ps = javabridge.make_instance('java/io/PrintStream', "(Ljava/io/OutputStream;)V", java_stack) javabridge.static_call('Ljava/lang/System;', "setErr", '(Ljava/io/PrintStream;)V', java_stack_ps) java_out = javabridge.make_instance('java/io/ByteArrayOutputStream', "()V") java_out_ps = javabridge.make_instance('java/io/PrintStream', "(Ljava/io/OutputStream;)V", java_out) javabridge.static_call('Ljava/lang/System;', "setOut", '(Ljava/io/PrintStream;)V', java_out_ps) javabridge.attach()
def OnInit(self): """Initialize CPA """ """List of tables created by the user during this session""" self.user_tables = [] # splashscreen splashimage = cpa.icons.cpa_splash.ConvertToBitmap() # If the splash image has alpha, it shows up transparently on # windows, so we blend it into a white background. splashbitmap = wx.EmptyBitmapRGBA(splashimage.GetWidth(), splashimage.GetHeight(), 255, 255, 255, 255) dc = wx.MemoryDC() dc.SelectObject(splashbitmap) dc.DrawBitmap(splashimage, 0, 0) dc.Destroy() # necessary to avoid a crash in splashscreen splash = wx.SplashScreen(splashbitmap, wx.SPLASH_CENTRE_ON_SCREEN | wx.SPLASH_TIMEOUT, 2000, None, -1) self.splash = splash p = Properties.getInstance() if not p.is_initialized(): from cpa.guiutils import show_load_dialog splash.Destroy() if not show_load_dialog(): logging.error("CellProfiler Analyst requires a properties file. Exiting.") return False self.frame = MainGUI(p, None, size=(860, -1)) self.frame.Show(True) db = cpa.dbconnect.DBConnect.getInstance() # Black magic: Bus errors occur on Mac OS X if we wait until # the JVM or the wx event look has started to connect. But it # has to be done after we have read the properties file. So we # do it here. db.connect() db.register_gui_parent(self.frame) # The JVM has to be started after db.connect(), otherwise bus errors # occur on Mac OS X. javabridge.start_vm(class_path=bioformats.JARS, run_headless=False) javabridge.attach() javabridge.activate_awt() try: if __version__ != -1: import cellprofiler.utilities.check_for_updates as cfu cfu.check_for_updates( "http://cellprofiler.org/CPAupdate.html", max(__version__, cpaprefs.get_skip_version()), new_version_cb, user_agent="CPAnalyst/2.0.%d" % (__version__), ) except ImportError: logging.warn( "CPA was unable to check for updates. Could not import cellprofiler.utilities.check_for_updates." ) return True
def readBioFormats(fn,debug=True): """Reads bioformats image file. Args: fn (str): Path to file. Keyword Args: debug (bool): Show debugging output. Returns: tuple: Tuple containing: * images (list): List of datasets * meta (OMEXML): meta data of all data. """ javabridge.start_vm(class_path=bioformats.JARS) meta=readBioFormatsMeta(fn) #Empty list to put datasets in images=[] #Open with reader class with bioformats.ImageReader(fn) as reader: #Loop through all images for i in range(meta.image_count): channels=[] #Check if there is a corrupt zstack for this particular dataset problematicStacks=checkProblematicStacks(reader,meta,i,debug=debug) #Loop through all channels for j in range(meta.image(i).Pixels.SizeC): zStacks=[] #Loop through all zStacks for k in range(meta.image(i).Pixels.SizeZ): #Check if corrupted if k not in problematicStacks: img=reader.read(series=i, c=j, z=k, rescale=False) zStacks.append(img) #Append to channels channels.append(zStacks) #Append to list of datasets and converts it to numpy array images.append(np.asarray(channels)) #Kill java VM javabridge.kill_vm() return images,meta
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 start_vm(self, java_max_heap_size = None): tetrad_libdir = os.path.join(os.path.dirname(__file__), 'lib') for l in glob.glob(tetrad_libdir + os.sep + "*.jar"): javabridge.JARS.append(str(l)) javabridge.start_vm(run_headless=True, max_heap_size = java_max_heap_size) javabridge.attach()
def get_decompounder(): """ Restarts the JVM with the decompounder. It is necessary once in a while. """ javabridge.start_vm(class_path=["tf/jwordsplitter/target/jwordsplitter-4.2-SNAPSHOT.jar"]) java_instance = javabridge.make_instance("de/danielnaber/jwordsplitter/GermanWordSplitter", "(Z)V", False) decompounder = javabridge.JWrapper(java_instance) return decompounder
def __init__(self, thoughtland_jar=None, *args, **kwargs): kwargs.setdefault("class_path", []).append( thoughtland_jar or THOUGTHLAND_JAR ) kwargs.setdefault("run_headless", True) import ipdb; ipdb.set_trace() javabridge.start_vm(*args, **kwargs)
def __init__(self): try: jb.start_vm( class_path=jb.JARS + [resource_filename('noesis', Noesis.__DEFAULT_JAR_FILE__)], run_headless=False) except: jb.kill_vm()
def command(input, output, channels, image_size, verbose): input_directory = os.path.realpath(input) output_directory = os.path.realpath(output) if not os.path.exists(output_directory): os.mkdir(output_directory) # Collect subdirectories. subdirectories = [ directory for directory in glob.glob(os.path.join(input_directory, "*")) if os.path.isdir(directory) ] # Collect channels to parse. if channels: channels = _parse_channels(channels) jvm_started = False for subdirectory in subdirectories: # Collect images in subdirectory, filtering out unsupported image formats. paths = _collect(subdirectory) ext = os.path.splitext(paths[0])[-1].lower() if ext == ".cif" and not jvm_started: import javabridge log_config = pkg_resources.resource_filename( "deepometry", "resources/logback.xml") javabridge.start_vm(args=[ "-Dlogback.configurationFile={}".format(log_config), "-Dloglevel={}".format("DEBUG" if verbose else "OFF") ], class_path=bioformats.JARS, max_heap_size="8G", run_headless=True) jvm_started = True label = os.path.split(subdirectory)[-1] label_directory = os.path.join(output_directory, label) try: deepometry.parse.parse(paths, output_directory=label_directory, size=image_size, channels=channels) except Exception as exception: if jvm_started: javabridge.kill_vm() raise exception if jvm_started: javabridge.kill_vm()
def __init__(self, pythonEncoding, encodingName): self.pythonEncoding = pythonEncoding self.encodingName = encodingName self.controlCharRegex = self.buildControlCharRegex() if(not self.pythonEncoding): if JAVABRIDGEINCLUDED: javabridge.start_vm(run_headless=True)
def test_java_bridge(): javabridge.start_vm(run_headless=True) try: print( javabridge.run_script( 'java.lang.String.format("Hello, %s!", name);', dict(name='world'))) finally: javabridge.kill_vm()
def begin(self): import javabridge javabridge.start_vm(self.extra_jvm_args, class_path=self.class_path.split(os.pathsep), run_headless=self.headless, max_heap_size=self.max_heap_size) if not self.headless: javabridge.activate_awt()
def __main__(image, output, image_size, montage_size): try: javabridge.start_vm(class_path=bioformats.JARS, max_heap_size='8G') os.mkdir(output) __stitch(image, output, image_size, montage_size) finally: javabridge.kill_vm()
def init_javabridge(): #max_heap_size='4G'): if not vm_is_active(): javabridge.start_vm(class_path=bioformats.JARS, run_headless=True) # max_heap_size=max_heap_size) suppressMsgs() #atexit.register(uninit_javabridge) else: attach()
def JVstart(max_heap_size='8G'): """Start the Java Virtual Machine, enabling bioformats IO. max_heap_size : string, optional The maximum memory usage by the virtual machine. Valid strings include '256M', '64k', and '2G'. Expect to need a lot. """ jv.start_vm(class_path=bf.JARS, max_heap_size=max_heap_size) global VM_STARTED VM_STARTED = True
def init_javabridge(): #max_heap_size='4G'): if not vm_is_active(): #print 'activate' javabridge.start_vm(class_path=bioformats.JARS, run_headless=True) # max_heap_size=max_heap_size) suppressMsgs() else: #print 'trying to attach' attach()
def get(self): total = dm.get_total_object_count() objKeys = dm.GetRandomObjects(total) # Start the virtual machine javabridge.start_vm(class_path=bioformats.JARS, run_headless=True) javabridge.attach() javabridge.activate_awt() return calculateAllJSON(objKeys, base64=True)
def jvm(): print() print('Starting javabridge...') log_config = Path(__file__).parent.joinpath("log4j.properties") jutil.start_vm(args=["-Dlog4j.configuration=file:{}".format(bfio.LOG4J)], class_path=bfio.JARS) yield print() print('Closing javabridge...') jutil.kill_vm()
def process(self, i, o): javabridge.start_vm( class_path=javabridge.JARS + ["/apps/whyis/jars/whyis-java-jar-with-dependencies.jar"], run_headless=True) try: javabridge.run_script('edu.rpi.tw.whyis.HermiTAgent.reason();', dict(greetee='world')) finally: javabridge.kill_vm()
def run_javabridge(java_code_to_run): javabridge.start_vm(run_headless=True) try: output = javabridge.run_script(java_code_to_run) print(output) # need to process and return some stuff here finally: javabridge.kill_vm()
def get_decompounder(): """ Restarts the JVM with the decompounder. It is necessary once in a while. """ javabridge.start_vm( class_path=["tf/jwordsplitter/target/jwordsplitter-4.2-SNAPSHOT.jar"]) java_instance = javabridge.make_instance( "de/danielnaber/jwordsplitter/GermanWordSplitter", "(Z)V", False) decompounder = javabridge.JWrapper(java_instance) return decompounder
def get(self): if cached_json["base64"] == False: # Start the virtual machine javabridge.start_vm(class_path=bioformats.JARS, run_headless=True) javabridge.attach() javabridge.activate_awt() # Calculate the Training DataSet and store it cached_json["json"] = calculateTrainingSetJSON(base64=True) cached_json["base64"] = True return cached_json["json"]
def main(): # Parse command line input parser = configure_parser() args = parser.parse_args() experiment_path = path.expanduser(args.experiment_path) net_path = path.expanduser(args.net_path) model_path = path.expanduser(args.model_path) # Configure io managers for the output database and for the metadata db_manager = io.ImageDbManager(args.output_db_path, readonly=False) metadata_manager = io.MetadataManager(experiment_path=args.experiment_path) # Configure fish_net. This will be done internally when CellDetectors are initialized at some point.... fish_net = caffe.Net(net_path, model_path, caffe.TEST) # Configure a cell detector # The cell_radius is important for processing the output of fish_net (ex. separating nearby cells) # The signal_channel specifies the channel in the input image that contains the relevant signal (i.e. the ISH stain) cell_detector = detection.CellDetector(net=fish_net, cell_radius=12, signal_channel=0) # Configure and start the JVM for loading vsi images with bioformats javabridge.start_vm(class_path=bioformats.JARS) log4j.basic_config() metadata = metadata_manager.load_metadata() for i, image_metadata in enumerate(metadata): print "Analyzing image %d of %d" % (i, len(metadata)) try: # Load an image descriptor using an images metadata. # The experiment path is necessary to locate files that are mentioned in the metadata image_descriptor = data.ImageDescriptor.from_metadata(image_metadata, experiment_path=args.experiment_path) # Load the vsi image that the metadata references, and pass it to the cell_detector vsi_path = path.join(args.experiment_path, image_metadata['vsiPath']) vsi_image = load_vsi(vsi_path) vsi_chunker = detection.ImageChunker(vsi_image.transpose(2,0,1), chunk_size=args.chunk_size) for chunk in vsi_chunker: cell_detector.set_image(chunk.transpose(1,2,0)) detected_cells = filter_duplicates(cell_detector.detect_cells(), vsi_chunker.current_chunk_row, vsi_chunker.current_chunk_col, args.chunk_size) image_descriptor.cells += map(lambda cell: data.PhysicalCell.from_cell(cell, VSI_PIXEL_SCALE), detected_cells) # Compute and set the offset of the region map vsi_resolution = numpy.asarray(vsi_image.shape[:1], dtype=numpy.int32) image_descriptor.region_map_offset = compute_offset(vsi_resolution) # Send the image descriptor to the database db_manager.add_image(image_descriptor) except: print "Cell detection failed for %s" % image_metadata['vsiPath']
def setup_and_teardown(): log_config = os.path.join(os.path.split(__file__)[0], "resources", "log4j.properties") javabridge.start_vm( args=[ "-Dlog4j.configuration=file:{}".format(log_config), ], class_path=bioformats.JARS, run_headless=True ) yield javabridge.kill_vm()
def start(class_path=None, bundled=True, packages=False, system_cp=False, max_heap_size=None): """ Initializes the javabridge connection (starts up the JVM). :param class_path: the additional classpath elements to add :type class_path: list :param bundled: whether to add jars from the "lib" directory :type bundled: bool :param packages: whether to add jars from Weka packages as well (bool) or an alternative Weka home directory (str) :type packages: bool or str :param system_cp: whether to add the system classpath as well :type system_cp: bool :param max_heap_size: the maximum heap size (-Xmx parameter, eg 512m or 4g) :type max_heap_size: str """ global started if started is not None: logger.info("JVM already running, call jvm.stop() first") return # add user-defined jars first if class_path is not None: for cp in class_path: logger.debug("Adding user-supplied classpath=" + cp) javabridge.JARS.append(cp) if bundled: logger.debug("Adding bundled jars") add_bundled_jars() if packages is not None: if isinstance(packages, bool): if packages: logger.debug("Adding Weka packages") add_weka_packages() else: logger.debug("Adding Weka packages, using: " + packages) add_weka_packages(packages) if system_cp: logger.debug("Adding system classpath") add_system_classpath() logger.debug("Classpath=" + str(javabridge.JARS)) logger.debug("MaxHeapSize=" + ("default" if (max_heap_size is None) else max_heap_size)) javabridge.start_vm(run_headless=True, max_heap_size=max_heap_size) javabridge.attach() started = True
def start_vm( args=None, class_path=None, max_heap_size=None, run_headless=False ): """ Start the JVM via Javabridge. """ if class_path is None: class_path = get_java_class_path() # Start the JVM. javabridge.start_vm( args=args, class_path=class_path, max_heap_size=max_heap_size, run_headless=run_headless ) # Suppress Java logging to stdout. java_stack = javabridge.make_instance( 'java/io/ByteArrayOutputStream', "()V" ) java_stack_ps = javabridge.make_instance( 'java/io/PrintStream', "(Ljava/io/OutputStream;)V", java_stack ) javabridge.static_call( 'Ljava/lang/System;', "setErr", '(Ljava/io/PrintStream;)V', java_stack_ps ) java_out = javabridge.make_instance( 'java/io/ByteArrayOutputStream', "()V" ) java_out_ps = javabridge.make_instance( 'java/io/PrintStream', "(Ljava/io/OutputStream;)V", java_out ) javabridge.static_call( 'Ljava/lang/System;', "setOut", '(Ljava/io/PrintStream;)V', java_out_ps ) javabridge.attach()
def setUpModule(): try: os.environ["PYJNIUS_ACTIVATE"] except KeyError: import javabridge try: # include user added classpath classpath = os.environ["CLASSPATH"] classpath = classpath.split(os.pathsep) javabridge.JARS.extend(classpath) except KeyError: None javabridge.start_vm() javabridge.attach()
def check_and_start_jvm(): """ Checks global to see whether a JVM is running and if not starts a new one. If JVM starts successfully the global variable mtbf_jvm_started is updated to ensure that another JVM is not started. """ global mtbf_jvm_started if not mtbf_jvm_started: logger.debug("Starting a new JVM") try: mh_size = getattr(settings, 'MTBF_MAX_HEAP_SIZE', '4G') javabridge.start_vm(class_path=bioformats.JARS, max_heap_size=mh_size, run_headless=True) mtbf_jvm_started = True except javabridge.JVMNotFoundError, e: logger.debug(e)
def cp_start_vm(): '''Start CellProfiler's JVM via Javabridge JVM parameters are harvested from preferences and the environment variables: CP_JDWP_PORT - port # for debugging Java within the JVM cpprefs.get_awt_headless() - controls java.awt.headless to prevent awt from being invoked ''' args = ["-Dloci.bioformats.loaded=true", "-Djava.util.prefs.PreferencesFactory=" + "org.cellprofiler.headlesspreferences.HeadlessPreferencesFactory"] logback_path = find_logback_xml() if logback_path is not None: if sys.platform.startswith("win"): logback_path = logback_path.replace("\\", "/") if logback_path[1] == ':': # \\localhost\x$ is same as x: logback_path = "//localhost/" + logback_path[0] + "$" + \ logback_path[2:] args.append("-Dlogback.configurationFile=%s" % logback_path) class_path = get_jars() awt_headless = cellprofiler.preferences.get_awt_headless() if awt_headless: logger.debug("JVM will be started with AWT in headless mode") args.append("-Djava.awt.headless=true") heap_size = str(cellprofiler.preferences.get_jvm_heap_mb()) + "m" if os.environ.has_key("CP_JDWP_PORT"): args.append( ("-agentlib:jdwp=transport=dt_socket,address=127.0.0.1:%s" ",server=y,suspend=n") % os.environ["CP_JDWP_PORT"]) javabridge.start_vm(args=args, class_path=class_path, max_heap_size=heap_size) # # Enable Bio-Formats directory cacheing # c_location = javabridge.JClassWrapper("loci.common.Location") c_location.cacheDirectoryListings(True) logger.debug("Enabled Bio-formats directory cacheing")
def main(): parser = configure_parser() args = parser.parse_args() metadata_path = path.join(args.experiment_path, '.registrationData', 'metadata.json') metadata = json.load(open(metadata_path)) javabridge.start_vm(class_path=bioformats.JARS) log4j.basic_config() image_descriptors = ifilter( lambda d: d is not None, (get_image_descriptor(label_path, metadata, args) for label_path in args.image_paths) ) df = dataframes.get_dataframe_from_image_sequence(image_descriptors) df.to_csv(args.output_path) javabridge.kill_vm()
def begin_javabridge(max_heap_size='8G'): ''' Begin the jave virtual machine. Parameters ---------- max_heap_size : string, optional Allocated memory for the virtual machine. Notes ----- Remember to end the javabridge! ''' global JVM_BEGIN javabridge.start_vm(class_path=bioformats.JARS,max_heap_size=max_heap_size) log4j.basic_config() JVM_BEGIN = True
def start_jvm(max_heap_size='4G'): """ Start the Java Virtual Machine, enabling BioFormats IO. Optional: Specify the path to the bioformats_package.jar to your needs by calling. set_bfpath before staring to read the image data Parameters ---------- max_heap_size : string, optional The maximum memory usage by the virtual machine. Valid strings include '256M', '64k', and '2G'. Expect to need a lot. """ # TODO - include check for the OS, so that the file paths are always working jars = jv.JARS + [BFPATH] jv.start_vm(class_path=jars, max_heap_size=max_heap_size) VM_STARTED = True
def upload_3d_hela_collection(data_path, is_test=False): """ The HeLa images are all in the same directory with the dataset, channel, and cell indicated by the filename. We combine each cell's channel files into a single image and upload it to OMERO, organizing the datasets together under the HeLa project, which is created it if it doesn't exist. If is_test is true, only upload one image. """ check_structure(data_path) conn = get_omero_connection() dataset_to_ids = dict() javabridge.start_vm(class_path=bioformats.JARS) bioformats.log4j.basic_config() for dataset in DATASETS: im_ids = upload_dataset(conn, data_path, dataset, is_test) dataset_to_ids[dataset['name']] = im_ids if is_test: break organize_uploaded_images(conn, dataset_to_ids) javabridge.kill_vm() conn._closeSession()
def main(): parser = configure_parser() args = parser.parse_args() meta_man = io.MetadataManager(experiment_path=args.experiment_path) number_of_vsi_samples = numpy.ceil(len(meta_man.metadata) * args.vsi_fraction) metadata_sample = list(numpy.random.choice(meta_man.metadata, number_of_vsi_samples, replace=False)) output_file = open(args.output_file, "w") javabridge.start_vm(class_path=bioformats.JARS) log4j.basic_config() (histogram, bins) = numpy.histogram([], bins=args.number_of_bins, range=(0.0, 2 ** 16 - 1), density=True) n = 0.0 for entry in metadata_sample: image = load_vsi(os.path.join(args.experiment_path, entry["vsiPath"])) number_of_samples = numpy.ceil(image.size * args.pixel_fraction) samples = numpy.random.choice(image.flatten(), number_of_samples, replace=False) sample_hist, sample_bins = numpy.histogram(samples, bins=args.number_of_bins, range=(0.0, 2 ** 16 - 1)) sample_hist = sample_hist.astype(numpy.float64) / number_of_samples if n > 0: gamma = number_of_samples / n histogram = update_histogram(histogram, sample_hist, gamma) else: histogram = sample_hist n += samples.size javabridge.kill_vm() output_obj = {"bins": list(bins), "histogram": list(histogram), "n": n} json.dump(output_obj, output_file) output_file.close()
def start(tassel_dir=None): """ Starts the JVM and connects to the TASSEL JAR Arguments: tassel_dir -- The directory containing the TASSEL JAR """ if tassel_dir is None: use_jars = javabridge.JARS + list(iglob(os.path.join(os.path.dirname(__file__), 'lib', '*.jar'))) else: use_jars = javabridge.JARS + [os.path.join(tassel_dir, 'sTASSEL.jar')] use_jars += list(iglob(os.path.join(tassel_dir, 'lib', '*.jar'))) # Start VM try: try: javabridge.start_vm(['-Djava.class.path=' + os.pathsep.join(use_jars)], class_path=use_jars, run_headless=True) except: javabridge.start_vm(class_path=use_jars, run_headless=True) except: print "Could not start JVM!"
def main(): parser = configure_parser() args = parser.parse_args() meta_man = io.MetadataManager(experiment_path=args.experiment_path) output_file = open(args.output_file, 'w') entry = meta_man.get_entry_from_name(os.path.basename(args.vsi_filename)) javabridge.start_vm(class_path=bioformats.JARS) log4j.basic_config() if entry is not None: image = load_vsi(os.path.join(args.experiment_path, entry['vsiPath'])) number_of_samples = numpy.ceil(image.size * args.pixel_fraction) samples = numpy.random.choice(image.flatten(), number_of_samples, replace=False) histogram, bins = numpy.histogram(samples, bins=args.number_of_bins, range=(0.0, 2**16 - 1)) percentiles = map(float, range(0, 101)) percentile_values = numpy.percentile(image, percentiles) else: print "Could not locate %s in metadata!" %s args.vsi_filename javabridge.kill_vm() return javabridge.kill_vm() output_obj = { 'bins': list(bins), 'histogram': list(histogram), 'n': number_of_samples, 'percentiles': percentiles, 'percentile_values': list(percentile_values) } json.dump(output_obj, output_file) output_file.close()
def upload_3d_synthetic_hela_collection(data_path, is_test=False): """ Given the path to the 3d synthetic hela images, they are in a one-image-per-channel format. For each dataset, merge corresponding channels of the same image into one and upload them to an OMERO instance. Look for a HeLa project and create it if it doesn't exist. Otherwise, upload the datasets to the existing HeLa project. If is_test is true, only upload one image. """ check_structure(data_path) conn = get_omero_connection() dataset_to_ids = dict() javabridge.start_vm(class_path=bioformats.JARS) bioformats.log4j.basic_config() for dataset in DATASETS: name, infix = dataset['name'], dataset['infix'] im_ids = upload_dataset(conn, dataset, data_path, is_test) dataset_to_ids[name] = im_ids if is_test: break organize_uploaded_images(conn, dataset_to_ids) javabridge.kill_vm() conn._closeSession()
def start(class_path=None, bundled=True, packages=False, system_cp=False, max_heap_size=None): """ Initializes the javabridge connection (starts up the JVM). :param class_path: the additional classpath elements to add :type class_path: str :param bundled: whether to add jars from the "lib" directory :type bundled: bool :param packages: whether to add jars from Weka packages as well :type packages: bool :param system_cp: whether to add the system classpath as well :type system_cp: bool :param max_heap_size: the maximum heap size (-Xmx parameter, eg 512m or 4g) :type max_heap_size: str """ global started if not started is None: return # add user-defined jars first if not class_path is None: for cp in class_path: javabridge.JARS.append(cp) if bundled: add_bundled_jars() if packages: add_weka_packages() if system_cp: add_system_classpath() javabridge.start_vm(run_headless=True, max_heap_size=max_heap_size) javabridge.attach() started = True
import numpy as np import sys from PIL import Image import os import glob import time from subprocess import call import tifffile from scipy import stats from scipy import ndimage import javabridge as jv import bioformats as bf jv.start_vm(class_path=bf.JARS) ##print(sys.argv[1]) os.chdir(sys.argv[1]) ##CtrlWhile = 0 ##MedSize = 101 ##Make it even MedSteps = 10 GaussRad = 100##LinSTD_fn = "LinearSTD.dat" ##SqrSTD_fn = "SquareSTD.dat" Counts = 0##np.loadtxt('Count.STD') #FileNamePattern = '*.tif' #File8bitSuff = '-8B' #ConvertOpt = "-quiet"##" -quiet -auto-level -depth 8" FolderName = sys.argv[1] CfgFile = 'Cfg.tmp'
def cp_start_vm(): '''Start CellProfiler's JVM via Javabridge JVM parameters are harvested from preferences and the environment variables: CP_JDWP_PORT - port # for debugging Java within the JVM cpprefs.get_awt_headless() - controls java.awt.headless to prevent awt from being invoked ''' args = ["-Dloci.bioformats.loaded=true", "-Djava.util.prefs.PreferencesFactory="+ "org.cellprofiler.headlesspreferences.HeadlessPreferencesFactory"] add_logback_xml_arg(args) class_path = get_jars() args += get_patcher_args(class_path) awt_headless = cpprefs.get_awt_headless() if awt_headless: logger.debug("JVM will be started with AWT in headless mode") args.append("-Djava.awt.headless=true") heap_size = str(cpprefs.get_jvm_heap_mb())+"m" if os.environ.has_key("CP_JDWP_PORT"): args.append( ("-agentlib:jdwp=transport=dt_socket,address=127.0.0.1:%s" ",server=y,suspend=n") % os.environ["CP_JDWP_PORT"]) javabridge.start_vm(args=args, class_path=class_path, max_heap_size = heap_size) # # Enable Bio-Formats directory cacheing # try: c_location = javabridge.JClassWrapper("loci.common.Location") c_location.cacheDirectoryListings(True) logger.debug("Enabled Bio-formats directory cacheing") except: logger.warning("Bioformats version does not support directory cacheing") # # Monkey-patch bioformats.formatreader.get_class_list to add # the classes we added to loci.formats.in # import bioformats.formatreader old_get_class_list = bioformats.formatreader.get_class_list def get_class_list(): "Return a wrapped instance of loci.formats.ClassList" env = javabridge.get_env() class_list = old_get_class_list() rais_classname = 'loci/common/RandomAccessInputStream' # # Move any class to the back that thinks it can read garbage # fd, path = tempfile.mkstemp(suffix=".garbage", dir=cpprefs.get_temporary_directory()) stream = None try: os.write(fd, "This is not an image file") os.fsync(fd) stream = javabridge.make_instance( rais_classname, '(Ljava/lang/String;)V', path) problem_classes = [] for klass in env.get_object_array_elements(class_list.get_classes()): try: instance = javabridge.call( klass, "newInstance", "()Ljava/lang/Object;") can_read_garbage = javabridge.call( instance, "isThisType", "(L%s;)Z" % rais_classname, stream) if can_read_garbage: problem_classes.append(klass) class_list.remove_class(klass) except: logger.info("Caught exception in %s.isThisType", javabridge.to_string(klass)) finally: os.close(fd) javabridge.call(stream, "close", "()V") os.remove(path) for classname in ("loci.formats.in.FlowSightReader", "loci.formats.in.IM3Reader"): try: klass = javabridge.class_for_name(classname) class_list.add_class(klass) except: logger.warn("Could not find Bio-formats reader %s" % classname, exc_info=1) for klass in problem_classes: class_list.add_class(klass) return class_list bioformats.formatreader.get_class_list = get_class_list