def test_plugins_load_using_pairwise_stitching(self, ij_fixture): try: sj.jimport("plugin.Stitching_Pairwise") except TypeError: pytest.skip( "No Pairwise Stitching plugin available. Skipping test.") if not ij_fixture.legacy: pytest.skip("No original ImageJ. Skipping test.") if ij_fixture.ui().isHeadless(): pytest.skip("No GUI. Skipping test.") macro = """ newImage("Tile1", "8-bit random", 512, 512, 1); newImage("Tile2", "8-bit random", 512, 512, 1); """ plugin = "Pairwise stitching" args = {"first_image": "Tile1", "second_image": "Tile2"} ij_fixture.script().run("macro.ijm", macro, True).get() ij_fixture.py.run_plugin(plugin, args) result_name = ij_fixture.WindowManager.getCurrentImage().getTitle() ij_fixture.script().run("macro.ijm", 'run("Close All");', True).get() assert result_name == "Tile1<->Tile2"
def detections_to_imagej(dataset, detections: np.ndarray, add_to_roi_manager=False): """ Convert blob detections to ImageJ oval ROIs. Optionally add the ROIs to the RoiManager. """ # get ImageJ resources ImagePlus = sj.jimport('ij.ImagePlus') OvalRoi = sj.jimport('ij.gui.OvalRoi') Overlay = sj.jimport('ij.gui.Overlay') ov = Overlay() # convert Dataset to ImagePlus imp = ij.convert().convert(dataset, ImagePlus) if add_to_roi_manager: RoiManager = sj.jimport('ij.plugin.frame.RoiManager')() rm = RoiManager.getRoiManager() for i in range(len(detections)): values = detections[i].tolist() y = values[0] x = values[1] r = values[2] d = r * 2 roi = OvalRoi(x - r, y - r, d, d) imp.setRoi(roi) ov.add(roi) if add_to_roi_manager: rm.addRoi(roi) imp.setOverlay(ov) imp.getProcessor().resetMinAndMax() imp.show()
def _get_imgplus(ij_fixture): """Get a 7D ImgPlus.""" # get java resources Random = sj.jimport("java.util.Random") Axes = sj.jimport("net.imagej.axis.Axes") UnsignedByteType = sj.jimport( "net.imglib2.type.numeric.integer.UnsignedByteType") DatasetService = ij_fixture.get("net.imagej.DatasetService") # test image parameters foo = Axes.get("foo") bar = Axes.get("bar") shape = [13, 17, 5, 2, 3, 7, 11] axes = [Axes.X, Axes.Y, foo, bar, Axes.CHANNEL, Axes.TIME, Axes.Z] # create image dataset = DatasetService.create(UnsignedByteType(), shape, "fabulous7D", axes) imgplus = dataset.typedImg(UnsignedByteType()) # fill the image with noise rng = Random(123456789) t = UnsignedByteType() for t in imgplus: t.set(rng.nextInt(256)) return imgplus
def detections_to_bdv(image, detections: np.ndarray): """ Display image and ROIs in BigDataViewer. """ # get useful classes BdvFunctions = sj.jimport('bdv.util.BdvFunctions') BdvOptions = sj.jimport('bdv.util.BdvOptions') # show image BdvFunctions.show(image, 'test', BdvOptions.options().is2D())
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 test_slice_int(self, ij_fixture, img): Views = sj.jimport("net.imglib2.view.Views") expected = Views.hyperSlice(img, 0, 0) actual = img[0] for i in range(3): for j in range(4): assert expected[i, j] == actual[i, j]
def get_dataframe(table): """ Convert results table to pandas Dataframe. """ Table = sj.jimport('org.scijava.table.Table') sci_table = ij.convert().convert(table, Table) return ij.py.from_java(sci_table)
def _java_setup(): """ Lazy initialization function for Java-dependent data structures. Do not call this directly; use scyjava.start_jvm() instead. """ global BoundedSoftRefLoaderCache BoundedSoftRefLoaderCache = scyjava.jimport( 'net.imglib2.cache.ref.BoundedSoftRefLoaderCache') global GuardedStrongRefLoaderCache GuardedStrongRefLoaderCache = scyjava.jimport( 'net.imglib2.cache.ref.GuardedStrongRefLoaderCache') global SoftRefLoaderCache SoftRefLoaderCache = scyjava.jimport( 'net.imglib2.cache.ref.SoftRefLoaderCache') global WeakRefLoaderCache WeakRefLoaderCache = scyjava.jimport( 'net.imglib2.cache.ref.WeakRefLoaderCache')
def test_step_not_enough_dims(self, ij_fixture, img): # Create a stepped img via Views Views = sj.jimport("net.imglib2.view.Views") steps = JArray(JLong)([2, 1, 1]) expected = Views.subsample(img, steps) expected = Views.dropSingletonDimensions(expected) # Create a stepped img via slicing notation actual = img[::2] for i in range(3): for j in range(4): assert expected[i, j] == actual[i, j]
def test_slice_and_step(self, ij_fixture, img): # Create a stepped img via Views Views = sj.jimport("net.imglib2.view.Views") intervaled = Views.hyperSlice(img, 0, 0) steps = JArray(JLong)([1, 2]) expected = Views.subsample(intervaled, steps) # Create a stepped img via slicing notation actual = img[:1, :, ::2] for i in range(3): for j in range(2): assert expected[i, j] == actual[i, j]
def img(self): # Create img ArrayImgs = sj.jimport("net.imglib2.img.array.ArrayImgs") img = ArrayImgs.bytes(2, 3, 4) # Insert a different value into each index tmp_val = 1 cursor = img.cursor() while cursor.hasNext(): cursor.next().set(tmp_val) tmp_val += 1 # Return the new img return img
def testGentle(self): Object = jimport('java.lang.Object') unknown_thing = Object() converted_thing = to_python(unknown_thing, gentle=True) assert type(converted_thing) == Object bad_conversion = None try: bad_conversion = to_python(unknown_thing) except: # NB: Failure is expected here. pass self.assertIsNone(bad_conversion)
def process(image, detections: np.ndarray, add_to_roi_manager=True, multimeasure=True): """ Process the blob rois. """ # get ImageJ resoures ImagePlus = sj.jimport('ij.ImagePlus') OvalRoi = sj.jimport('ij.gui.OvalRoi') Overlay = sj.jimport('ij.gui.Overlay') ov = Overlay() # convert image to imp imp = ij.convert().convert(image, ImagePlus) if add_to_roi_manager: rm = ij.RoiManager().getRoiManager() for i in range(len(detections)): values = detections[i].tolist() y = values[0] x = values[1] r = values[2] d = r * 2 roi = OvalRoi(x - r, y - r, d, d) imp.setRoi(roi) ov.add(roi) if add_to_roi_manager: rm.addRoi(roi) imp.setOverlay(ov) imp.show() if rm != None and multimeasure: rm.runCommand(imp, "Measure") return ij.ResultsTable.getResultsTable() return None
def test_top_hat(self, ij_fixture): ArrayList = sj.jimport("java.util.ArrayList") HyperSphereShape = sj.jimport( "net.imglib2.algorithm.neighborhood.HyperSphereShape") Views = sj.jimport("net.imglib2.view.Views") result = [] correct_result = [0, 0, 0, 1000, 2000, 4000, 7000, 12000, 20000, 33000] input_array = np.array([[1000, 1000, 1000, 2000, 3000], [5000, 8000, 13000, 21000, 34000]]) output_array = np.zeros(input_array.shape) java_out = Views.iterable(ij_fixture.py.to_java(output_array)) java_in = ij_fixture.py.to_java(input_array) shapes = ArrayList() shapes.add(HyperSphereShape(5)) ij_fixture.op().morphology().topHat(java_out, java_in, shapes) itr = java_out.iterator() while itr.hasNext(): result.append(itr.next().get()) assert result == correct_result
def _get_img(): # Create img CreateNamespace = sj.jimport("net.imagej.ops.create.CreateNamespace") dims = JArray(JLong)([1, 2, 3, 4, 5]) ns = ij_fixture.op().namespace(CreateNamespace) img = ns.img(dims) # Populate img with random data cursor = img.cursor() while cursor.hasNext(): val = random.random() cursor.next().set(val) return img
def java_labeling(ij_fixture): img = np.zeros((4, 4), dtype=np.int32) img[:2, :2] = 6 img[:2, 2:] = 3 img[2:, :2] = 7 img[2:, 2:] = 4 img_java = ij_fixture.py.to_java(img) sets = [[], [1], [2], [1, 2], [2, 3], [3], [1, 4], [3, 4]] sets = [set(l) for l in sets] sets_java = ij_fixture.py.to_java(sets) ImgLabeling = sj.jimport("net.imglib2.roi.labeling.ImgLabeling") return ImgLabeling.fromImageAndLabelSets(img_java, sets_java)
def test_image_math(self, ij_fixture): Views = sj.jimport("net.imglib2.view.Views") input_array = np.array([[1, 1, 2], [3, 5, 8]]) result = [] correct_result = [192, 198, 205, 192, 198, 204] java_in = Views.iterable(ij_fixture.py.to_java(input_array)) java_out = (ij_fixture.op().image().equation( java_in, "64 * (Math.sin(0.1 * p[0]) + Math.cos(0.1 * p[1])) + 128")) itr = java_out.iterator() while itr.hasNext(): result.append(itr.next().get()) assert result == correct_result
def test_plugins_load_using_pairwise_stitching(self, ij_fixture): macro = """ newImage("Tile1", "8-bit random", 512, 512, 1); newImage("Tile2", "8-bit random", 512, 512, 1); """ plugin = 'Pairwise stitching' args = {'first_image': 'Tile1', 'second_image': 'Tile2'} ij_fixture.script().run('macro.ijm', macro, True).get() ij_fixture.py.run_plugin(plugin, args) WindowManager = sj.jimport('ij.WindowManager') result_name = WindowManager.getCurrentImage().getTitle() ij_fixture.script().run('macro.ijm', 'run("Close All");', True).get() assert result_name == 'Tile1<->Tile2'
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 _java_setup(): """ Lazy initialization function for Java-dependent data structures. Do not call this directly; use scyjava.start_jvm() instead. """ # java global Random Random = scyjava.jimport('java.util.Random') # imglib try: global Helpers Helpers = scyjava.jimport('net.imglib2.python.Helpers') global NumpyToImgLibConversions NumpyToImgLibConversions = scyjava.jimport( 'net.imglib2.python.NumpyToImgLibConversions') global NumpyToImgLibConversionsWithStride NumpyToImgLibConversionsWithStride = scyjava.jimport( 'net.imglib2.python.NumpyToImgLibConversionsWithStride') global Views Views = scyjava.jimport('net.imglib2.view.Views') except TypeError as e: _logger.error( "Failed to import ImgLib2 helper classes. Please ensure imglib2-imglyb is present on the classpath." ) raise e # Guard global ReferenceGuardingRandomAccessibleInterval ReferenceGuardingRandomAccessibleInterval = scyjava.jimport( 'net.imglib2.python.ReferenceGuardingRandomAccessibleInterval') global numpy_dtype_to_conversion_method numpy_dtype_to_conversion_method = { np.dtype('complex64'): NumpyToImgLibConversions.toComplexFloat, np.dtype('complex128'): NumpyToImgLibConversions.toComplexDouble, np.dtype('float32'): NumpyToImgLibConversions.toFloat, np.dtype('float64'): NumpyToImgLibConversions.toDouble, np.dtype('int8'): NumpyToImgLibConversions.toByte, np.dtype('int16'): NumpyToImgLibConversions.toShort, np.dtype('int32'): NumpyToImgLibConversions.toInt, np.dtype('int64'): NumpyToImgLibConversions.toLong, np.dtype('uint8'): NumpyToImgLibConversions.toUnsignedByte, np.dtype('uint16'): NumpyToImgLibConversions.toUnsignedShort, np.dtype('uint32'): NumpyToImgLibConversions.toUnsignedInt, np.dtype('uint64'): NumpyToImgLibConversions.toUnsignedLong } global numpy_dtype_to_conversion_with_stride_method numpy_dtype_to_conversion_with_stride_method = { np.dtype('complex64'): NumpyToImgLibConversionsWithStride.toComplexFloat, np.dtype('complex128'): NumpyToImgLibConversionsWithStride.toComplexDouble, np.dtype('float32'): NumpyToImgLibConversionsWithStride.toFloat, np.dtype('float64'): NumpyToImgLibConversionsWithStride.toDouble, np.dtype('int8'): NumpyToImgLibConversionsWithStride.toByte, np.dtype('int16'): NumpyToImgLibConversionsWithStride.toShort, np.dtype('int32'): NumpyToImgLibConversionsWithStride.toInt, np.dtype('int64'): NumpyToImgLibConversionsWithStride.toLong, np.dtype('uint8'): NumpyToImgLibConversionsWithStride.toUnsignedByte, np.dtype('uint16'): NumpyToImgLibConversionsWithStride.toUnsignedShort, np.dtype('uint32'): NumpyToImgLibConversionsWithStride.toUnsignedInt, np.dtype('uint64'): NumpyToImgLibConversionsWithStride.toUnsignedLong } global ReferenceGuard @JImplements( 'net.imglib2.python.ReferenceGuardingRandomAccessibleInterval$ReferenceHolder' ) class ReferenceGuard(): def __init__(self, *args, **kwargs): self.args = args global GenericMouseMotionListener @JImplements('java.awt.event.MouseMotionListener') class GenericMouseMotionListener(): def __init__(self, mouse_dragged=lambda e: None, mouse_moved=lambda e: None): self.mouse_dragged = mouse_dragged self.mouse_moved = mouse_moved @JOverride def mouseDragged(self, e): self.mouse_dragged(e) @JOverride def mouseMoved(self, e): self.mouse_moved(e) global RunnableFromFunc @JImplements('java.lang.Runnable') class RunnableFromFunc(): def __init__(self, func): self.func = func @JOverride def run(self): _logger.debug('Running function %s', self.func) self.func()
def _java_setup(): """ Lazy initialization function for Java-dependent data structures. Do not call this directly; use scyjava.start_jvm() instead. """ global PythonHelpers PythonHelpers = scyjava.jimport('net.imglib2.python.Helpers') # non-owning global _ByteUnsafe _ByteUnsafe = scyjava.jimport( 'net.imglib2.img.basictypelongaccess.unsafe.ByteUnsafe') global _CharUnsafe _CharUnsafe = scyjava.jimport( 'net.imglib2.img.basictypelongaccess.unsafe.CharUnsafe') global _DoubleUnsafe _DoubleUnsafe = scyjava.jimport( 'net.imglib2.img.basictypelongaccess.unsafe.DoubleUnsafe') global _FloatUnsafe _FloatUnsafe = scyjava.jimport( 'net.imglib2.img.basictypelongaccess.unsafe.FloatUnsafe') global _IntUnsafe _IntUnsafe = scyjava.jimport( 'net.imglib2.img.basictypelongaccess.unsafe.IntUnsafe') global _LongUnsafe _LongUnsafe = scyjava.jimport( 'net.imglib2.img.basictypelongaccess.unsafe.LongUnsafe') global _ShortUnsafe _ShortUnsafe = scyjava.jimport( 'net.imglib2.img.basictypelongaccess.unsafe.ShortUnsafe') global _unsafe_for_dtype _unsafe_for_dtype = { np.dtype('complex64'): _FloatUnsafe, np.dtype('complex128'): _DoubleUnsafe, np.dtype('float32'): _FloatUnsafe, np.dtype('float64'): _DoubleUnsafe, np.dtype('int8'): _ByteUnsafe, np.dtype('int16'): _ShortUnsafe, np.dtype('int32'): _IntUnsafe, np.dtype('int64'): _LongUnsafe, np.dtype('uint8'): _ByteUnsafe, np.dtype('uint16'): _ShortUnsafe, np.dtype('uint32'): _IntUnsafe, np.dtype('uint64'): _LongUnsafe } # owning global _OwningByteUnsafe _OwningByteUnsafe = scyjava.jimport( 'net.imglib2.img.basictypelongaccess.unsafe.owning.OwningByteUnsafe') global _OwningCharUnsafe _OwningCharUnsafe = scyjava.jimport( 'net.imglib2.img.basictypelongaccess.unsafe.owning.OwningCharUnsafe') global _OwningDoubleUnsafe _OwningDoubleUnsafe = scyjava.jimport( 'net.imglib2.img.basictypelongaccess.unsafe.owning.OwningDoubleUnsafe') global _OwningFloatUnsafe _OwningFloatUnsafe = scyjava.jimport( 'net.imglib2.img.basictypelongaccess.unsafe.owning.OwningFloatUnsafe') global _OwningIntUnsafe _OwningIntUnsafe = scyjava.jimport( 'net.imglib2.img.basictypelongaccess.unsafe.owning.OwningIntUnsafe') global _OwningLongUnsafe _OwningLongUnsafe = scyjava.jimport( 'net.imglib2.img.basictypelongaccess.unsafe.owning.OwningLongUnsafe') global _OwningShortUnsafe _OwningShortUnsafe = scyjava.jimport( 'net.imglib2.img.basictypelongaccess.unsafe.owning.OwningShortUnsafe') global _unsafe_owning_for_dtype _unsafe_owning_for_dtype = { np.dtype('complex64'): lambda size: _OwningFloatUnsafe(2 * size), np.dtype('complex128'): lambda size: _OwningDoubleUnsafe(2 * size), np.dtype('float32'): _OwningFloatUnsafe, np.dtype('float64'): _OwningDoubleUnsafe, np.dtype('int8'): _OwningByteUnsafe, np.dtype('int16'): _OwningShortUnsafe, np.dtype('int32'): _OwningIntUnsafe, np.dtype('int64'): _OwningLongUnsafe, np.dtype('uint8'): _OwningByteUnsafe, np.dtype('uint16'): _OwningShortUnsafe, np.dtype('uint32'): _OwningIntUnsafe, np.dtype('uint64'): _OwningLongUnsafe } global MakeAccessFunction @JImplements('java.util.function.LongFunction') class MakeAccessFunction(): """ Implements a java `LongFunction` that can be passed into `PythonHelpers.imgFromFunc` and `PythonHelpers.imgWithCellLoaderFromFunc`. """ def __init__(self, func): self.func = func @JOverride def apply(self, index): access = self.func(index) return access
def test_dtype(self, ij_fixture, img): assert hasattr(img, "dtype") ByteType = sj.jimport("net.imglib2.type.numeric.integer.ByteType") assert img.dtype == ByteType
def assert_permuted_rai_equal_to_source_rai(imgplus): # get java resources Axes = sj.jimport("net.imagej.axis.Axes") # define extra axes foo = Axes.get("foo") bar = Axes.get("bar") # permute the rai to python order axis_types = [axis.type() for axis in imgplus.dim_axes] permute_order = dims.prioritize_rai_axes_order( axis_types, dims._python_rai_ref_order()) permuted_rai = dims.reorganize(imgplus, permute_order) # extract values for assertion oc = imgplus.dimensionIndex(Axes.CHANNEL) ox = imgplus.dimensionIndex(Axes.X) oy = imgplus.dimensionIndex(Axes.Y) oz = imgplus.dimensionIndex(Axes.Z) ot = imgplus.dimensionIndex(Axes.TIME) of = imgplus.dimensionIndex(foo) ob = imgplus.dimensionIndex(bar) nc = permuted_rai.dimensionIndex(Axes.CHANNEL) nx = permuted_rai.dimensionIndex(Axes.X) ny = permuted_rai.dimensionIndex(Axes.Y) nz = permuted_rai.dimensionIndex(Axes.Z) nt = permuted_rai.dimensionIndex(Axes.TIME) nf = permuted_rai.dimensionIndex(foo) nb = permuted_rai.dimensionIndex(bar) oc_len = imgplus.dimension(oc) ox_len = imgplus.dimension(ox) oy_len = imgplus.dimension(oy) oz_len = imgplus.dimension(oz) ot_len = imgplus.dimension(ot) of_len = imgplus.dimension(of) ob_len = imgplus.dimension(ob) nc_len = permuted_rai.dimension(nc) nx_len = permuted_rai.dimension(nx) ny_len = permuted_rai.dimension(ny) nz_len = permuted_rai.dimension(nz) nt_len = permuted_rai.dimension(nt) nf_len = permuted_rai.dimension(nf) nb_len = permuted_rai.dimension(nb) # assert the number of pixels of each dimension assert oc_len == nc_len assert ox_len == nx_len assert oy_len == ny_len assert oz_len == nz_len assert ot_len == nt_len assert of_len == nf_len assert ob_len == nb_len # get RandomAccess imgplus_access = imgplus.randomAccess() permuted_rai_access = permuted_rai.randomAccess() # assert pixels between source and permuted rai for c in range(oc_len): imgplus_access.setPosition(c, oc) permuted_rai_access.setPosition(c, nc) for x in range(ox_len): imgplus_access.setPosition(x, ox) permuted_rai_access.setPosition(x, nx) for y in range(oy_len): imgplus_access.setPosition(y, oy) permuted_rai_access.setPosition(y, ny) for z in range(oz_len): imgplus_access.setPosition(z, oz) permuted_rai_access.setPosition(z, nz) for t in range(ot_len): imgplus_access.setPosition(t, ot) permuted_rai_access.setPosition(t, nt) for f in range(of_len): imgplus_access.setPosition(f, of) permuted_rai_access.setPosition(f, nf) for b in range(ob_len): imgplus_access.setPosition(b, ob) permuted_rai_access.setPosition(b, nb) sample_name = f"C: {c}, X: {x}, Y: {y}, Z: {z}, T: {t}, F: {f}, B: {b}" assert (imgplus_access.get() == permuted_rai_access.get()), sample_name
def test_slice_not_enough_dims(self, ij_fixture, img): Views = sj.jimport("net.imglib2.view.Views") expected = Views.hyperSlice(Views.hyperSlice(img, 0, 0), 0, 0) actual = img[0, 0] for i in range(4): assert expected[i] == actual[i]
def _java_setup(): """ Lazy initialization function for Java-dependent data structures. Do not call this directly; use scyjava.start_jvm() instead. """ Intervals = scyjava.jimport('net.imglib2.util.Intervals')
def test_slice_1d_negative(self, ij_fixture, img): Views = sj.jimport("net.imglib2.view.Views") expected = Views.hyperSlice(Views.hyperSlice(img, 0, 1), 0, 1) actual = img[-1, -2, :] for i in range(4): assert expected[i] == actual[i]
pointer = ctypes.cast(address, ctypes.POINTER(ctype_conversions_imglib[imglib_type])) order = 'C' obj = np.ndarray.__new__(cls, buffer=np.ctypeslib.as_array(pointer, shape=shape), shape=shape, dtype=dtype) obj.setflags(write=True) obj.rai = rai return obj def __array_finalize__(self, obj): if obj is None: return self.rai = obj.rai if __name__ == "__main__": ArrayImgs = scyjava.jimport('net.imglib2.img.array.ArrayImgs') UnsafeUtil = scyjava.jimport('net.imglib2.img.basictypelongaccess.unsafe.UnsafeUtil') Arrays = scyjava.jimport('java.util.Arrays') OwningFloatUnsafe = scyjava.jimport('net.imglib2.img.basictypelongaccess.unsafe.owning.OwningFloatUnsafe') Fraction = scyjava.jimport('net.imglib2.util.Fraction') LongStream = scyjava.jimport('java.util.stream.LongStream') shape = (2, 3, 4) n_elements = int(np.prod(shape)) data_store = OwningFloatUnsafe(n_elements) dim_array = LongStream.of(*shape).toArray() print(Arrays.toString(dim_array)) rai = util.Helpers.toArrayImg(jpype.JObject(util.Helpers.className(data_store), data_store), dim_array) # rai = ArrayImgs.floats( *shape ) c = rai.cursor() count = 23
def _java_setup(): """ Lazy initialization function for Java-dependent data structures. Do not call this directly; use scyjava.start_jvm() instead. """ global Accesses Accesses = scyjava.jimport('net.imglib2.img.basictypeaccess.Accesses') global ByteArray ByteArray = scyjava.jimport( 'net.imglib2.img.basictypeaccess.array.ByteArray') global CharArray CharArray = scyjava.jimport( 'net.imglib2.img.basictypeaccess.array.CharArray') global DoubleArray DoubleArray = scyjava.jimport( 'net.imglib2.img.basictypeaccess.array.DoubleArray') global FloatArray FloatArray = scyjava.jimport( 'net.imglib2.img.basictypeaccess.array.FloatArray') global IntArray IntArray = scyjava.jimport( 'net.imglib2.img.basictypeaccess.array.IntArray') global LongArray LongArray = scyjava.jimport( 'net.imglib2.img.basictypeaccess.array.LongArray') global ShortArray ShortArray = scyjava.jimport( 'net.imglib2.img.basictypeaccess.array.ShortArray') global VolatileByteArray VolatileByteArray = scyjava.jimport( 'net.imglib2.img.basictypeaccess.volatiles.array.VolatileByteArray') global VolatileCharArray VolatileCharArray = scyjava.jimport( 'net.imglib2.img.basictypeaccess.volatiles.array.VolatileCharArray') global VolatileDoubleArray VolatileDoubleArray = scyjava.jimport( 'net.imglib2.img.basictypeaccess.volatiles.array.VolatileDoubleArray') global VolatileFloatArray VolatileFloatArray = scyjava.jimport( 'net.imglib2.img.basictypeaccess.volatiles.array.VolatileFloatArray') global VolatileIntArray VolatileIntArray = scyjava.jimport( 'net.imglib2.img.basictypeaccess.volatiles.array.VolatileIntArray') global VolatileLongArray VolatileLongArray = scyjava.jimport( 'net.imglib2.img.basictypeaccess.volatiles.array.VolatileLongArray') global VolatileShortArray VolatileShortArray = scyjava.jimport( 'net.imglib2.img.basictypeaccess.volatiles.array.VolatileShortArray') global ByteUnsafe ByteUnsafe = scyjava.jimport( 'net.imglib2.img.basictypelongaccess.unsafe.ByteUnsafe') global CharUnsafe CharUnsafe = scyjava.jimport( 'net.imglib2.img.basictypelongaccess.unsafe.CharUnsafe') global DoubleUnsafe DoubleUnsafe = scyjava.jimport( 'net.imglib2.img.basictypelongaccess.unsafe.DoubleUnsafe') global FloatUnsafe FloatUnsafe = scyjava.jimport( 'net.imglib2.img.basictypelongaccess.unsafe.FloatUnsafe') global IntUnsafe IntUnsafe = scyjava.jimport( 'net.imglib2.img.basictypelongaccess.unsafe.IntUnsafe') global LongUnsafe LongUnsafe = scyjava.jimport( 'net.imglib2.img.basictypelongaccess.unsafe.LongUnsafe') global ShortUnsafe ShortUnsafe = scyjava.jimport( 'net.imglib2.img.basictypelongaccess.unsafe.ShortUnsafe')
def disable_loci_logs(): DebugTools = scyjava.jimport("loci.common.DebugTools") DebugTools.setRootLevel("WARN")
def _java_setup(): """ Lazy initialization function for Java-dependent data structures. Do not call this directly; use scyjava.start_jvm() instead. """ global NativeType NativeType = scyjava.jimport('net.imglib2.type.NativeType') global FloatType FloatType = scyjava.jimport('net.imglib2.type.numeric.real.FloatType') global DoubleType DoubleType = scyjava.jimport('net.imglib2.type.numeric.real.DoubleType') global ByteType ByteType = scyjava.jimport('net.imglib2.type.numeric.integer.ByteType') global UnsignedByteType UnsignedByteType = scyjava.jimport('net.imglib2.type.numeric.integer.UnsignedByteType') global ShortType ShortType = scyjava.jimport('net.imglib2.type.numeric.integer.ShortType') global UnsignedShortType UnsignedShortType = scyjava.jimport('net.imglib2.type.numeric.integer.UnsignedShortType') global IntType IntType = scyjava.jimport('net.imglib2.type.numeric.integer.IntType') global UnsignedIntType UnsignedIntType = scyjava.jimport('net.imglib2.type.numeric.integer.UnsignedIntType') global LongType LongType = scyjava.jimport('net.imglib2.type.numeric.integer.LongType') global UnsignedLongType UnsignedLongType = scyjava.jimport('net.imglib2.type.numeric.integer.UnsignedLongType') global VolatileFloatType VolatileFloatType = scyjava.jimport('net.imglib2.type.volatiles.VolatileFloatType') global VolatileDoubleType VolatileDoubleType = scyjava.jimport('net.imglib2.type.volatiles.VolatileDoubleType') global VolatileByteType VolatileByteType = scyjava.jimport('net.imglib2.type.volatiles.VolatileByteType') global VolatileUnsignedByteType VolatileUnsignedByteType = scyjava.jimport('net.imglib2.type.volatiles.VolatileUnsignedByteType') global VolatileShortType VolatileShortType = scyjava.jimport('net.imglib2.type.volatiles.VolatileShortType') global VolatileUnsignedShortType VolatileUnsignedShortType = scyjava.jimport('net.imglib2.type.volatiles.VolatileUnsignedShortType') global VolatileIntType VolatileIntType = scyjava.jimport('net.imglib2.type.volatiles.VolatileIntType') global VolatileUnsignedIntType VolatileUnsignedIntType = scyjava.jimport('net.imglib2.type.volatiles.VolatileUnsignedIntType') global VolatileLongType VolatileLongType = scyjava.jimport('net.imglib2.type.volatiles.VolatileLongType') global VolatileUnsignedLongType VolatileUnsignedLongType = scyjava.jimport('net.imglib2.type.volatiles.VolatileUnsignedLongType')