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()
