def testMixed(self): d = {'a':'b', 'c':'d'} l = ['e', 'f', 'g', 'h'] s = set(['i', 'j', 'k']) # mixed types in a dictionary md = {'d': d, 'l': l, 's': s, 'str': 'hello'} jmd = to_java(md) self.assertEqual(len(md), jmd.size()) for k, v in md.items(): jk = to_java(k) self.assertTrue(jmd.containsKey(jk)) self.assertEqual(v, to_python(jmd.get(jk))) pmd = to_python(jmd) self.assertEqual(md, pmd) self.assertEqual(str(md), str(pmd)) # mixed types in a list ml = [d, l, s, 'hello'] jml = to_java(ml) for e, a in zip(ml, jml): self.assertEqual(e, to_python(a)) pml = to_python(jml) self.assertEqual(ml, pml) self.assertEqual(str(ml), str(pml))
def testDict(self): d = { 'access_log': [ {'stored_proc': 'getsomething'}, {'uses': [ {'usedin': 'some->bread->crumb'}, {'usedin': 'something else here'}, {'stored_proc': 'anothersp'} ]}, {'uses': [ {'usedin': 'blahblah'} ]} ], 'reporting': [ {'stored_proc': 'reportingsp'}, {'uses': [{'usedin': 'breadcrumb'}]} ] } jd = to_java(d) self.assertEqual(len(d), jd.size()) for k, v in d.items(): jk = to_java(k) self.assertTrue(jd.containsKey(jk)) self.assertEqual(v, to_python(jd.get(jk))) pd = to_python(jd) self.assertEqual(d, pd) self.assertEqual(str(d), str(pd))
def testSet(self): s = set(['orange', 'apple', 'pineapple', 'plum']) js = to_java(s) self.assertEqual(len(s), js.size()) for e in s: self.assertTrue(js.contains(to_java(e))) ps = to_python(js) self.assertEqual(s, ps) self.assertEqual(str(s), str(ps))
def testBoolean(self): jt = to_java(True) self.assertEqual(True, jt.booleanValue()) pt = to_python(jt) self.assertEqual(True, pt) self.assertEqual('True', str(pt)) jf = to_java(False) self.assertEqual(False, jf.booleanValue()) pf = to_python(jf) self.assertEqual(False, pf) self.assertEqual('False', str(pf))
def testPandasToTable(self): # Float table. columns = ["header1", "header2", "header3", "header4", "header5"] array = np.random.random(size=(7, 5)) df = pd.DataFrame(array, columns=columns) table = to_java(df) assert_same_table(table, df) assert type(table) == jimport('org.scijava.table.DefaultFloatTable') # Int table. columns = ["header1", "header2", "header3", "header4", "header5"] array = np.random.random(size=(7, 5)) * 100 array = array.astype('int') df = pd.DataFrame(array, columns=columns) table = to_java(df) assert_same_table(table, df) assert type(table) == jimport('org.scijava.table.DefaultIntTable') # Bool table. columns = ["header1", "header2", "header3", "header4", "header5"] array = np.random.random(size=(7, 5)) > 0.5 df = pd.DataFrame(array, columns=columns) table = to_java(df) assert_same_table(table, df) assert type(table) == jimport('org.scijava.table.DefaultBoolTable') # Mixed table. columns = ["header1", "header2", "header3", "header4", "header5"] array = np.random.random(size=(7, 5)) df = pd.DataFrame(array, columns=columns) # Convert column 0 to integer df.iloc[:, 0] = (df.iloc[:, 0] * 100).astype('int') # Convert column 1 to bool df.iloc[:, 1] = df.iloc[:, 1] > 0.5 # Convert column 2 to string df.iloc[:, 2] = df.iloc[:, 2].to_string(index=False).split('\n') table = to_java(df) # Table types cannot be the same here, unless we want to cast. # assert_same_table(table, df) assert type(table) == jimport('org.scijava.table.DefaultGenericTable')
def testInteger(self): i = 5 ji = to_java(i) self.assertEqual(i, ji.intValue()) pi = to_python(ji) self.assertEqual(i, pi) self.assertEqual(str(i), str(pi))
def testLong(self): l = 4000000001 jl = to_java(l) self.assertEqual(l, jl.longValue()) pl = to_python(jl) self.assertEqual(l, pl) self.assertEqual(str(l), str(pl))
def testBigInteger(self): bi = 9879999999999999789 jbi = to_java(bi) self.assertEqual(bi, int(str(jbi.toString()))) pbi = to_python(jbi) self.assertEqual(bi, pbi) self.assertEqual(str(bi), str(pbi))
def run_script(self, language, script, args=None): """ Run a script in an IJ scripting language :param language: The file extension for the scripting language :param script: A string containing the script code :param args: Arguments for the script as a dictionary of key/value pairs :return: """ script_lang = self._ij.script().getLanguageByName(language) if script_lang is None: script_lang = self._ij.script().getLanguageByExtension( language) if script_lang is None: raise ValueError("Unknown script language: " + language) exts = script_lang.getExtensions() if exts.isEmpty(): raise ValueError("Script language '" + script_lang.getLanguageName() + "' has no extensions") ext = exts.get(0) try: if args is None: return self._ij.script().run("script." + ext, script, True).get() return self._ij.script().run("script." + ext, script, True, to_java(args)).get() except Exception as exc: _dump_exception(exc) raise exc
def to_java(self, data): """ Converts the data into a java equivalent. For numpy arrays, the java image points to the python array """ if self._is_memoryarraylike(data): return imglyb.to_imglib(data) return to_java(data)
def to_java(self, data): """ Converts the data into a java equivalent. For numpy arrays, the java image points to the python array """ if type(data) == numpy.ndarray: return imglyb.to_imglib(data) return to_java(data)
def pandas_to_table(df): pd = _import_pandas() if len(df.dtypes.unique()) > 1: TableClass = jnius.autoclass('org.scijava.table.DefaultGenericTable') else: table_type = df.dtypes.unique()[0] if table_type.name.startswith('float'): TableClass = jnius.autoclass('org.scijava.table.DefaultFloatTable') elif table_type.name.startswith('int'): TableClass = jnius.autoclass('org.scijava.table.DefaultIntTable') elif table_type.name.startswith('bool'): TableClass = jnius.autoclass('org.scijava.table.DefaultBoolTable') else: msg = "The type '{}' is not supported.".format(table_type.name) raise Exception(msg) table = TableClass(*df.shape[::-1]) for c, column_name in enumerate(df.columns): table.setColumnHeader(c, column_name) for i, (index, row) in enumerate(df.iterrows()): for c, value in enumerate(row): header = df.columns[c] table.set(header, i, scyjava.to_java(value)) return table
def testString(self): s = 'Hello world!' js = to_java(s) for e, a in zip(s, js.toCharArray()): self.assertEqual(e, a) ps = to_python(js) self.assertEqual(s, ps) self.assertEqual(str(s), str(ps))
def testNone(self): d = {'key':None, None:'value', 'foo':'bar'} jd = to_java(d) self.assertEqual(3, jd.size()) self.assertEqual(None, jd.get('key')) self.assertEqual('value', jd.get(None)) self.assertEqual('bar', jd.get('foo')) pd = to_python(jd) self.assertEqual(d, pd)
def testList(self): l = 'The quick brown fox jumps over the lazy dogs'.split() jl = to_java(l) for e, a in zip(l, jl): self.assertEqual(e, to_python(a)) pl = to_python(jl) self.assertEqual(l, pl) self.assertEqual(str(l), str(pl)) self.assertEqual(pl[1], 'quick') pl[7] = 'silly' self.assertEqual('The quick brown fox jumps over the silly dogs', ' '.join(pl))
def to_java(self, data): """ Converts the data into a java equivalent. For numpy arrays, the java image points to the python array. In addition to the scyjava types, we allow ndarray-like and xarray-like variables """ if self._is_memoryarraylike(data): return imglyb.to_imglib(data) if self._is_xarraylike(data): return self.to_dataset(data) return to_java(data)
def run_macro(self, macro, args=None): """ Run an ImageJ1 style macro script :param macro: The macro code :param args: Arguments for the script as a dictionary of key/value pairs :return: """ if args is None: return self._ij.script().run("macro.ijm", macro, True).get() else: return self._ij.script().run("macro.ijm", macro, True, to_java(args)).get()
def run_macro(self, macro, args=None): """ Run an ImageJ1 style macro script :param macro: The macro code :param args: Arguments for the script as a dictionary of key/value pairs :return: """ if not ij.legacy().isActive(): raise ImportError( "Your IJ endpoint does not support IJ1, and thus cannot use IJ1 macros." ) try: if args is None: return self._ij.script().run("macro.ijm", macro, True).get() else: return self._ij.script().run("macro.ijm", macro, True, to_java(args)).get() except Exception as exc: _dump_exception(exc) raise exc
def testStructureWithSomeUnsupportedItems(self): # Create Java data structure with some challenging items. Object = jimport('java.lang.Object') jmap = to_java({ 'list': ['a', Object(), 1], 'set': {'x', Object(), 2}, 'object': Object(), 'foo': 'bar' }) self.assertEqual('java.util.LinkedHashMap', jclass(jmap).getName()) # Convert it back to Python. pdict = to_python(jmap) l = pdict['list'] self.assertEqual(pdict['list'][0], 'a') assert type(pdict['list'][1]) == Object assert pdict['list'][2] == 1 assert 'x' in pdict['set'] assert 2 in pdict['set'] assert len(pdict['set']) == 3 assert type(pdict['object']) == Object self.assertEqual(pdict['foo'], 'bar')
def testClass(self): """ Tests class detection from Java objects. """ int_class = jclass(to_java(5)) self.assertEqual('java.lang.Integer', int_class.getName()) long_class = jclass(to_java(4000000001)) self.assertEqual('java.lang.Long', long_class.getName()) bigint_class = jclass(to_java(9879999999999999789)) self.assertEqual('java.math.BigInteger', bigint_class.getName()) string_class = jclass(to_java('foobar')) self.assertEqual('java.lang.String', string_class.getName()) list_class = jclass(to_java([1, 2, 3])) self.assertEqual('java.util.ArrayList', list_class.getName()) map_class = jclass(to_java({'a':'b'})) self.assertEqual('java.util.LinkedHashMap', map_class.getName()) self.assertEqual('java.util.Map', jclass('java.util.Map').getName())
def process_example(sample, data_dir, ij): sample_dir = data_dir / sample["dataset_type"] / sample["color_type"] results_dir = sample_dir / "Results" results_dir.mkdir(exist_ok=True) fname = sample_dir / sample['name'] kappa_path = fname.with_suffix(".kapp") assert fname.exists() and kappa_path.exists() frame = KappaFrame(ij.context) frame.getKappaMenubar().openImageFile(str(fname)) frame.resetCurves() frame.drawImageOverlay() # Save screenshot screenshot_path = results_dir / f"{fname.stem}_1_Image.png" save(frame, fname=screenshot_path) frame.getKappaMenubar().loadCurveFile(str(kappa_path)) frame.getCurves().setAllSelected() # Set line thickness frame.setBaseStrokeThickness(sample['line_thickness']) # Set zoom frame.controlPanel.getScaleSlider().setValue(sample['zoom']) frame.drawImageOverlay() # Save screenshot screenshot_path = results_dir / f"{fname.stem}_2_Initial.png" save(frame, fname=screenshot_path) # Show thresholded data contours and pixels frame.infoPanel.getShowRadiusCheckBox().setSelected(True) frame.infoPanel.getShowDatapointsCheckBox().setSelected(True) # Set radius for the thresold frame.infoPanel.getThresholdRadiusSpinner().setValue( scyjava.to_java(sample['threshold_radius'])) # Set pixels to dark or not frame.infoPanel.getDataRangeComboBox().setSelectedIndex( 1 if sample['is_signal_dark'] else 0) # Set thresold value frame.getInfoPanel().thresholdSlider.setValue(sample['threshold_value']) frame.drawImageOverlay() # Save screenshot screenshot_path = results_dir / f"{fname.stem}_3_Threshold.png" save(frame, fname=screenshot_path) if sample['adjust_ctrl_point']: frame.setEnableCtrlPtAdjustment(True) else: frame.setEnableCtrlPtAdjustment(False) frame.fitCurves() frame.infoPanel.getShowRadiusCheckBox().setSelected(False) frame.infoPanel.getShowDatapointsCheckBox().setSelected(False) frame.drawImageOverlay() # Save screenshot screenshot_path = results_dir / f"{fname.stem}_4_Final.png" save(frame, fname=screenshot_path) # Save curvature values exporter = CurvesExporter(frame) curvature_path = sample_dir / f"{fname.stem}_Curvatures.csv" exporter.exportToFile(str(curvature_path), False) # plot curvature values curvatures = pd.read_csv(curvature_path) plt.ioff() for curve_name, curvature in curvatures.groupby('Curve Name'): fig, ax = plt.subplots(figsize=(8, 6)) y_data = curvature['Point Curvature (um-1)'] n_points = len(y_data) assert len(curvature['Curve Length (um)'].unique()) == 1 curve_length = curvature['Curve Length (um)'].unique()[0] x_data = np.linspace(0, curve_length, n_points) ax.plot(x_data, y_data, color="#d81920ff", lw=6) ax.set_xticks([]) ax.set_yticks([]) y_lim_max = curvatures['Point Curvature (um-1)'].max() * 1.05 ax.set_ylim(-0.02, y_lim_max) kwargs = dict(font="DejaVu Sans", font_size_ratio=1, axes_color="#231f20ff", x_axis_grid=False, y_axis_grid=False, tick_width=6) pykappa.mpl.set_ax_style(ax, **kwargs) ax.set_ylabel("Curvature", fontsize=28) ax.set_xlabel("Curve Length", fontsize=28) plot_path = results_dir / f"{fname.stem}_5_Curvatures_{curve_name}.png" fig.savefig(plot_path, dpi=300, transparent=False, bbox_inches='tight', pad_inches=0) plt.clf() plt.ion()