def test_01_09_jdictionary_to_string_dictionary(self):
properties = javabridge.static_call("java/lang/System", "getProperties",
"()Ljava/util/Properties;")
d = javabridge.get_dictionary_wrapper(properties)
pyd = javabridge.jdictionary_to_string_dictionary(properties)
keys = javabridge.jenumeration_to_string_list(d.keys())
for key in keys:
value = javabridge.to_string(d.get(key))
self.assertEqual(pyd[key], value)
def system_info():
"""
Returns a dictionary generated from the output of weka.core.SystemInfo.
:return: the system info as dictionary
:rtype: dict
"""
jobj = JavaObject.new_instance("weka.core.SystemInfo")
info = javabridge.call(jobj, "getSystemInfo", "()Ljava/util/Hashtable;")
return javabridge.jdictionary_to_string_dictionary(info)
def test_make_image_reader():
path = os.path.join(os.path.dirname(__file__), 'resources', 'Channel1-01-A-01.tif')
ImageReader = bioformats.formatreader.make_image_reader_class()
FormatTools = bioformats.formatreader.make_format_tools_class()
reader = ImageReader()
reader.setId(path)
assert reader.getDimensionOrder() == "XYCZT"
metadata = javabridge.jdictionary_to_string_dictionary(reader.getMetadata())
assert int(metadata["ImageWidth"]) == reader.getSizeX()
assert int(metadata["ImageLength"]) == reader.getSizeY()
assert reader.getImageCount() == 1
assert reader.getSizeC() == 1
assert reader.getSizeT() == 1
assert reader.getSizeZ() == 1
assert reader.getPixelType() == FormatTools.UINT8
assert reader.getRGBChannelCount() == 1
def test_02_01_make_image_reader(self):
path = os.path.join(os.path.dirname(__file__), "Channel1-01-A-01.tif")
ImageReader = F.make_image_reader_class()
FormatTools = F.make_format_tools_class()
reader = ImageReader()
reader.setId(path)
self.assertEqual(reader.getDimensionOrder(), "XYCZT")
metadata = J.jdictionary_to_string_dictionary(reader.getMetadata())
self.assertEqual(int(metadata["ImageWidth"]), reader.getSizeX())
self.assertEqual(int(metadata["ImageLength"]), reader.getSizeY())
self.assertEqual(reader.getImageCount(), 1)
self.assertEqual(reader.getSizeC(), 1)
self.assertEqual(reader.getSizeT(), 1)
self.assertEqual(reader.getSizeZ(), 1)
self.assertEqual(reader.getPixelType(), FormatTools.UINT8)
self.assertEqual(reader.getRGBChannelCount(), 1)
def test_02_01_make_image_reader(self):
path = os.path.join(os.path.dirname(__file__), 'Channel1-01-A-01.tif')
ImageReader = F.make_image_reader_class()
FormatTools = F.make_format_tools_class()
reader = ImageReader()
reader.setId(path)
self.assertEqual(reader.getDimensionOrder(), "XYCZT")
metadata = J.jdictionary_to_string_dictionary(reader.getMetadata())
self.assertEqual(int(metadata["ImageWidth"]), reader.getSizeX())
self.assertEqual(int(metadata["ImageLength"]), reader.getSizeY())
self.assertEqual(reader.getImageCount(), 1)
self.assertEqual(reader.getSizeC(), 1)
self.assertEqual(reader.getSizeT(), 1)
self.assertEqual(reader.getSizeZ(), 1)
self.assertEqual(reader.getPixelType(), FormatTools.UINT8)
self.assertEqual(reader.getRGBChannelCount(), 1)
def _getSeriesStarts(self, rdr):
self._metadata['frameSeries'] = [{
'series': [0],
'sizeX': self._metadata['sizeX'],
'sizeY': self._metadata['sizeY'],
}]
if self._metadata['seriesCount'] <= 1:
return 1
seriesMetadata = {}
for idx in range(self._metadata['seriesCount']):
rdr.setSeries(idx)
seriesMetadata.update(
javabridge.jdictionary_to_string_dictionary(
rdr.getSeriesMetadata()))
frameList = []
nextSeriesNum = 0
try:
for key, value in seriesMetadata.items():
frameNum = int(value)
seriesNum = int(key.split('Series ')[1].split('|')[0]) - 1
if seriesNum >= 0 and seriesNum < self._metadata['seriesCount']:
while len(frameList) <= frameNum:
frameList.append([])
if seriesNum not in frameList[frameNum]:
frameList[frameNum].append(seriesNum)
frameList[frameNum].sort()
nextSeriesNum = max(nextSeriesNum, seriesNum + 1)
except Exception as exc:
self.logger.debug('Failed to parse series information: %s', exc)
rdr.setSeries(0)
return 1
if not len(seriesMetadata):
frameList = [[0]]
nextSeriesNum = 1
for idx in range(1, self._metadata['seriesCount']):
rdr.setSeries(idx)
if rdr.getSizeX() == self.sizeX and rdr.getSizeY == self.sizeY:
frameList.append([idx])
if nextSeriesNum == idx:
nextSeriesNum = idx + 1
frameList = [fl for fl in frameList if len(fl)]
self._metadata['frameSeries'] = [{
'series': fl,
} for fl in frameList]
rdr.setSeries(0)
return nextSeriesNum
def start(class_path=None, bundled=True, packages=False, system_cp=False, max_heap_size=None, system_info=False):
"""
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
:param system_info: whether to print the system info (generated by weka.core.SystemInfo)
:type system_info: bool
"""
global started
global with_package_support
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 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))
args = []
weka_home = None
if packages is not None:
if isinstance(packages, bool):
if packages:
with_package_support = True
logger.debug("Package support enabled")
else:
logger.debug("Package support disabled")
args.append("-Dweka.packageManager.loadPackages=false")
if isinstance(packages, str):
if os.path.exists(packages) and os.path.isdir(packages):
logger.debug("Using alternative Weka home directory: " + packages)
weka_home = packages
with_package_support = True
else:
logger.warning("Invalid Weka home: " + packages)
javabridge.start_vm(args=args, run_headless=True, max_heap_size=max_heap_size)
javabridge.attach()
started = True
if weka_home is not None:
from weka.core.classes import Environment
env = Environment.system_wide()
logger.debug("Using alternative Weka home directory: " + packages)
env.add_variable("WEKA_HOME", weka_home)
# initialize package manager
javabridge.static_call(
"Lweka/core/WekaPackageManager;", "loadPackages",
"(Z)V",
False)
# output system info
if system_info:
logger.debug("System info:")
jobj = javabridge.make_instance("weka/core/SystemInfo", "()V")
hashtable = javabridge.call(jobj, "getSystemInfo", "()Ljava/util/Hashtable;")
info = javabridge.jdictionary_to_string_dictionary(hashtable)
for k in info.keys():
logger.debug(k + "=" + info[k])
def __init__(self, path, **kwargs): # noqa
"""
Initialize the tile class. See the base class for other available
parameters.
:param path: the associated file path.
:param maxSize: either a number or an object with {'width': (width),
'height': height} in pixels. If None, the default max size is
used.
"""
super().__init__(path, **kwargs)
self._logger = config.getConfig('logger')
largeImagePath = self._getLargeImagePath()
ext = os.path.splitext(largeImagePath)[1]
if not ext:
raise TileSourceException(
'File cannot be opened via bioformats because it has no '
'extension to specify the file type (%s).' % largeImagePath)
if ext.lower() in ('.jpg', '.jpeg', '.jpe', '.png'):
raise TileSourceException('File will not be opened by bioformats reader')
if not _startJavabridge(self._logger):
raise TileSourceException(
'File cannot be opened by bioformats reader because javabridge failed to start')
self._tileLock = threading.RLock()
try:
javabridge.attach()
try:
self._bioimage = bioformats.ImageReader(largeImagePath)
except AttributeError as exc:
self._logger.debug('File cannot be opened via Bioformats. (%r)' % exc)
raise TileSourceException('File cannot be opened via Bioformats. (%r)' % exc)
_openImages.append(self)
rdr = self._bioimage.rdr
# Bind additional functions not done by bioformats module.
# Functions are listed at https://downloads.openmicroscopy.org
# //bio-formats/5.1.5/api/loci/formats/IFormatReader.html
for (name, params, desc) in [
('getBitsPerPixel', '()I', 'Get the number of bits per pixel'),
('getEffectiveSizeC', '()I', 'effectiveC * Z * T = imageCount'),
('isNormalized', '()Z', 'Is float data normalized'),
('isMetadataComplete', '()Z', 'True if metadata is completely parsed'),
('getDomains', '()[Ljava/lang/String;', 'Get a list of domains'),
('getZCTCoords', '(I)[I', 'Gets the Z, C and T coordinates '
'(real sizes) corresponding to the given rasterized index value.'),
('getOptimalTileWidth', '()I', 'the optimal sub-image width '
'for use with openBytes'),
('getOptimalTileHeight', '()I', 'the optimal sub-image height '
'for use with openBytes'),
('getResolutionCount', '()I', 'The number of resolutions for '
'the current series'),
('setResolution', '(I)V', 'Set the resolution level'),
('getResolution', '()I', 'The current resolution level'),
('hasFlattenedResolutions', '()Z', 'True if resolutions have been flattened'),
('setFlattenedResolutions', '(Z)V', 'Set if resolution should be flattened'),
]:
setattr(rdr, name, types.MethodType(
javabridge.jutil.make_method(name, params, desc), rdr))
# rdr.setFlattenedResolutions(False)
self._metadata = {
'dimensionOrder': rdr.getDimensionOrder(),
'metadata': javabridge.jdictionary_to_string_dictionary(
rdr.getMetadata()),
'seriesMetadata': javabridge.jdictionary_to_string_dictionary(
rdr.getSeriesMetadata()),
'seriesCount': rdr.getSeriesCount(),
'imageCount': rdr.getImageCount(),
'rgbChannelCount': rdr.getRGBChannelCount(),
'sizeColorPlanes': rdr.getSizeC(),
'sizeT': rdr.getSizeT(),
'sizeZ': rdr.getSizeZ(),
'sizeX': rdr.getSizeX(),
'sizeY': rdr.getSizeY(),
'pixelType': rdr.getPixelType(),
'isLittleEndian': rdr.isLittleEndian(),
'isRGB': rdr.isRGB(),
'isInterleaved': rdr.isInterleaved(),
'isIndexed': rdr.isIndexed(),
'bitsPerPixel': rdr.getBitsPerPixel(),
'sizeC': rdr.getEffectiveSizeC(),
'normalized': rdr.isNormalized(),
'metadataComplete': rdr.isMetadataComplete(),
# 'domains': rdr.getDomains(),
'optimalTileWidth': rdr.getOptimalTileWidth(),
'optimalTileHeight': rdr.getOptimalTileHeight(),
'resolutionCount': rdr.getResolutionCount(),
'flattenedResolutions': rdr.hasFlattenedResolutions(),
}
self._checkSeries(rdr)
bmd = bioformats.metadatatools.MetadataRetrieve(self._bioimage.metadata)
try:
self._metadata['channelNames'] = [
bmd.getChannelName(0, c) or bmd.getChannelID(0, c)
for c in range(self._metadata['sizeColorPlanes'])]
except Exception:
self._metadata['channelNames'] = []
for key in ['sizeXY', 'sizeC', 'sizeZ', 'sizeT']:
if not isinstance(self._metadata[key], int) or self._metadata[key] < 1:
self._metadata[key] = 1
self.sizeX = self._metadata['sizeX']
self.sizeY = self._metadata['sizeY']
self._computeTiles()
self._computeLevels()
self._computeMagnification()
except javabridge.JavaException as exc:
es = javabridge.to_string(exc.throwable)
self._logger.debug('File cannot be opened via Bioformats. (%s)' % es)
raise TileSourceException('File cannot be opened via Bioformats. (%s)' % es)
except AttributeError:
self._logger.exception('The bioformats reader threw an unhandled exception.')
raise TileSourceException('The bioformats reader threw an unhandled exception.')
finally:
if javabridge.get_env():
javabridge.detach()
if self.levels < 1:
raise TileSourceException(
'OpenSlide image must have at least one level.')
if self.sizeX <= 0 or self.sizeY <= 0:
raise TileSourceException('Bioformats tile size is invalid.')
