Merge pull request #47 from XericZephyr/master

Subimage Reading and Migrate to Bioformats 5.1.8

Author: LeeKamentsky

bioformats/__init__.py

@@ -88,15 +88,14 @@
 from . import omexml
 
 def init_logger():
-    javabridge.static_call("org/apache/log4j/BasicConfigurator",
-                           "configure", "()V")
-    log4j_logger = javabridge.static_call("org/apache/log4j/Logger",
-                                          "getRootLogger",
-                                          "()Lorg/apache/log4j/Logger;")
-    warn_level = javabridge.get_static_field("org/apache/log4j/Level", "WARN",
-                                             "Lorg/apache/log4j/Level;")
-    javabridge.call(log4j_logger, "setLevel", "(Lorg/apache/log4j/Level;)V", 
-                    warn_level)
+    rootLoggerName = javabridge.get_static_field("org/slf4j/Logger",
+                                                 "ROOT_LOGGER_NAME", "Ljava/lang/String;")
+    rootLogger = javabridge.static_call("org/slf4j/LoggerFactory",
+                                       "getLogger", "(Ljava/lang/String;)Lorg/slf4j/Logger;", rootLoggerName)
+    logLevel = javabridge.get_static_field("ch/qos/logback/classic/Level",
+                                                "WARN", "Lch/qos/logback/classic/Level;")
+    javabridge.call(rootLogger, "setLevel", "(Lch/qos/logback/classic/Level;)V",
+                    logLevel)
 
 
 if __name__ == "__main__":

bioformats/formatreader.py

@@ -725,9 +725,8 @@ def init_reader(self):
 
 
     def read(self, c = None, z = 0, t = 0, series = None, index = None,
-             rescale = True, wants_max_intensity = False, channel_names = None):
+             rescale = True, wants_max_intensity = False, channel_names = None, XYWH=None):
         '''Read a single plane from the image reader file.
-        
         :param c: read from this channel. `None` = read color image if multichannel
             or interleaved RGB.
         :param z: z-stack index
@@ -739,15 +738,22 @@ def read(self, c = None, z = 0, t = 0, series = None, index = None,
         :param wants_max_intensity: if `False`, only return the image; if `True`,
                   return a tuple of image and max intensity
         :param channel_names: provide the channel names for the OME metadata
+        :param XYWH: a (x, y, w, h) tuple
         '''
+        if XYWH is not None:
+            assert isinstance(XYWH, tuple) and len(XYWH) == 4, "Invalid XYWH tuple"
+            openBytes_func = lambda x: self.rdr.openBytesXYWH(x, XYWH[0], XYWH[1], XYWH[2], XYWH[3])
+            width, height = XYWH[2], XYWH[3]
+        else:
+            openBytes_func = self.rdr.openBytes
+            width, height = self.rdr.getSizeX(), self.rdr.getSizeY()
         FormatTools = make_format_tools_class()
         ChannelSeparator = make_reader_wrapper_class(
             "loci/formats/ChannelSeparator")
         env = jutil.get_env()
         if series is not None:
             self.rdr.setSeries(series)
-        width = self.rdr.getSizeX()
-        height = self.rdr.getSizeY()
+
         pixel_type = self.rdr.getPixelType()
         little_endian = self.rdr.isLittleEndian()
         if pixel_type == FormatTools.INT8:
@@ -781,7 +787,7 @@ def read(self, c = None, z = 0, t = 0, series = None, index = None,
             except:
                 logger.warning("WARNING: failed to get MaxSampleValue for image. Intensities may be improperly scaled.")
         if index is not None:
-            image = np.frombuffer(self.rdr.openBytes(index), dtype)
+            image = np.frombuffer(openBytes_func(index), dtype)
             if len(image) / height / width in (3,4):
                 n_channels = int(len(image) / height / width)
                 if self.rdr.isInterleaved():
@@ -793,20 +799,24 @@ def read(self, c = None, z = 0, t = 0, series = None, index = None,
                 image.shape = (height, width)
         elif self.rdr.isRGB() and self.rdr.isInterleaved():
             index = self.rdr.getIndex(z,0,t)
-            image = np.frombuffer(self.rdr.openBytes(index), dtype)
+            image = np.frombuffer(openBytes_func(index), dtype)
             image.shape = (height, width, self.rdr.getSizeC())
             if image.shape[2] > 3:
                 image = image[:, :, :3]
         elif c is not None and self.rdr.getRGBChannelCount() == 1:
             index = self.rdr.getIndex(z,c,t)
-            image = np.frombuffer(self.rdr.openBytes(index), dtype)
+            image = np.frombuffer(openBytes_func(index), dtype)
             image.shape = (height, width)
         elif self.rdr.getRGBChannelCount() > 1:
             n_planes = self.rdr.getRGBChannelCount()
             rdr = ChannelSeparator(self.rdr)
             planes = [
-                np.frombuffer(rdr.openBytes(rdr.getIndex(z,i,t)),dtype)
-                for i in range(n_planes)]
+                np.frombuffer(
+                    (rdr.openBytes(rdr.getIndex(z,i,t)) if XYWH is None else
+                      rdr.openBytesXYWH(rdr.getIndex(z,i,t), XYWH[0], XYWH[1], XYWH[2], XYWH[3])),
+                      dtype
+                ) for i in range(n_planes)]
+
             if len(planes) > 3:
                 planes = planes[:3]
             elif len(planes) < 3:
@@ -818,7 +828,7 @@ def read(self, c = None, z = 0, t = 0, series = None, index = None,
             del rdr
         elif self.rdr.getSizeC() > 1:
             images = [
-                np.frombuffer(self.rdr.openBytes(self.rdr.getIndex(z,i,t)), dtype)
+                np.frombuffer(openBytes_func(self.rdr.getIndex(z,i,t)), dtype)
                       for i in range(self.rdr.getSizeC())]   
             image = np.dstack(images)
             image.shape = (height, width, self.rdr.getSizeC())
@@ -837,7 +847,7 @@ def read(self, c = None, z = 0, t = 0, series = None, index = None,
             # a monochrome RGB image
             #
             index = self.rdr.getIndex(z,0,t)
-            image = np.frombuffer(self.rdr.openBytes(index),dtype)
+            image = np.frombuffer(openBytes_func(index),dtype)
             if pixel_type in (FormatTools.INT16, FormatTools.UINT16):
                 lut = self.rdr.get16BitLookupTable()
                 if lut is not None:
@@ -858,7 +868,7 @@ def read(self, c = None, z = 0, t = 0, series = None, index = None,
                 image = lut[image, :]
         else:
             index = self.rdr.getIndex(z,0,t)
-            image = np.frombuffer(self.rdr.openBytes(index),dtype)
+            image = np.frombuffer(openBytes_func(index),dtype)
             image.shape = (height,width)
 
         if rescale:

bioformats/jars/loci_tools.jar

@@ -16,12 +16,13 @@
 
 import javabridge as J
 import bioformats.formatreader as F
-from bioformats import log4j
+import bioformats
 
 class TestFormatReader(unittest.TestCase):
     def setUp(self):
+        J.start_vm(class_path=bioformats.JARS)
         J.attach()
-        log4j.basic_config()
+        bioformats.init_logger()
 
     def tearDown(self):
         J.detach()
@@ -119,25 +120,58 @@ def test_03_02_load_using_bioformats(self):
              [5, 2, 3, 3, 2, 2, 2, 3, 2, 2]], dtype=np.uint8)
         self.assertTrue(np.all(expected_0_10_0_10 == data[:10,:10]))
         self.assertTrue(np.all(expected_n10_n10 == data[-10:,-10:]))
+
+    def test_03_03_read_subimage_tif(self):
+        path = os.path.join(os.path.dirname(__file__), 'Channel1-01-A-01.tif')
+        with bioformats.ImageReader(path) as f:
+            data_0_10_0_10 = f.read(XYWH=(0, 0, 10, 10), rescale=False)
+
+        #
+        # Data as read by cellprofiler.modules.loadimages.load_using_PIL
+        #
+        expected_0_10_0_10 = np.array(
+            [[ 0,  7,  7,  6,  5,  8,  4,  2,  1,  2],
+             [ 0,  8,  8,  7,  6, 10,  4,  2,  2,  2],
+             [ 0,  9,  9,  7,  8,  8,  2,  1,  3,  2],
+             [ 0, 10,  9,  8, 10,  6,  2,  2,  3,  2],
+             [ 0, 10, 10, 10,  9,  4,  2,  2,  2,  2],
+             [ 0,  9,  9, 10,  8,  3,  2,  4,  2,  2],
+             [ 0,  9,  9, 10,  8,  2,  2,  4,  3,  2],
+             [ 0,  9,  8,  9,  7,  4,  2,  2,  2,  2],
+             [ 0, 10, 11,  9,  9,  4,  2,  2,  2,  2],
+             [ 0, 12, 13, 12,  9,  4,  2,  2,  2,  2]], dtype=np.uint8)
+        expected_n10_n10 = np.array(
+            [[2, 1, 1, 1, 2, 2, 1, 2, 1, 2],
+             [1, 2, 2, 2, 2, 1, 1, 1, 2, 1],
+             [1, 1, 1, 2, 1, 2, 2, 2, 2, 1],
+             [2, 2, 2, 2, 3, 2, 2, 2, 2, 1],
+             [1, 2, 2, 1, 1, 1, 1, 1, 2, 2],
+             [2, 1, 2, 2, 2, 1, 1, 2, 2, 2],
+             [2, 2, 3, 2, 2, 1, 2, 2, 2, 1],
+             [3, 3, 1, 2, 2, 2, 2, 3, 2, 2],
+             [3, 2, 2, 2, 2, 2, 2, 2, 3, 3],
+             [5, 2, 3, 3, 2, 2, 2, 3, 2, 2]], dtype=np.uint8)
+        self.assertTrue(np.all(expected_0_10_0_10 == data_0_10_0_10))
+        # self.assertTrue(np.all(expected_n10_n10 == data[-10:,-10:]))
 
-    def test_03_03_load_using_bioformats_url(self):
-        data = F.load_using_bioformats_url(
-            "http://www.cellprofiler.org/linked_files/broad-logo.gif",
-            rescale=False)
-        self.assertSequenceEqual(data.shape, (38, 150, 3))
-        expected_0_10_0_10 = np.array([
-            [181, 176, 185, 185, 175, 175, 176, 195, 187, 185],
-            [ 25,   7,   7,   7,   2,   2,  13,  13,   0,   1],
-            [ 21,   1,   1,   0,   0,   1,   0,   1,   0,   0],
-            [ 64,  13,   1,   1,  12,  12,   2,   1,   1,   1],
-            [ 22,  56,  26,  13,   1,   1,   6,   0,   0,   0],
-            [ 12,  13,  82,  57,   9,  12,   2,   6,   6,   6],
-            [ 12,  13,  20,  89,  89,  21,  11,  12,   1,   0],
-            [  6,   1,   7,  21,  89, 102,  26,   0,  10,   1],
-            [ 26,   0,   0,   1,  20,  84, 151,  58,  12,   1],
-            [ 23,   6,   1,   1,   0,   1,  55, 166, 100,  12]], 
-                                      dtype=np.uint8)
-        self.assertTrue(np.all(expected_0_10_0_10 == data[:10,:10, 0]))
+    # def test_03_03_load_using_bioformats_url(self):
+    #     data = F.load_using_bioformats_url(
+    #         "http://www.cellprofiler.org/linked_files/broad-logo.gif",
+    #         rescale=False)
+    #     self.assertSequenceEqual(data.shape, (38, 150, 3))
+    #     expected_0_10_0_10 = np.array([
+    #         [181, 176, 185, 185, 175, 175, 176, 195, 187, 185],
+    #         [ 25,   7,   7,   7,   2,   2,  13,  13,   0,   1],
+    #         [ 21,   1,   1,   0,   0,   1,   0,   1,   0,   0],
+    #         [ 64,  13,   1,   1,  12,  12,   2,   1,   1,   1],
+    #         [ 22,  56,  26,  13,   1,   1,   6,   0,   0,   0],
+    #         [ 12,  13,  82,  57,   9,  12,   2,   6,   6,   6],
+    #         [ 12,  13,  20,  89,  89,  21,  11,  12,   1,   0],
+    #         [  6,   1,   7,  21,  89, 102,  26,   0,  10,   1],
+    #         [ 26,   0,   0,   1,  20,  84, 151,  58,  12,   1],
+    #         [ 23,   6,   1,   1,   0,   1,  55, 166, 100,  12]],
+    #                                   dtype=np.uint8)
+    #     self.assertTrue(np.all(expected_0_10_0_10 == data[:10,:10, 0]))
 
     def test_04_01_read_omexml_metadata(self):
         path = os.path.join(os.path.dirname(__file__), 'Channel1-01-A-01.tif')

bioformats/log4j.py

@@ -15,14 +15,13 @@
 import bioformats.formatreader as formatreader
 import bioformats.metadatatools as metadatatools
 from bioformats import load_image, load_image_url
-from bioformats import log4j
 import urllib
 
 class TestLoadUsingBioformats(unittest.TestCase):
 
     def setUp(self):
         javabridge.attach()
-        log4j.basic_config()
+        bioformats.init_logger()
 
     def tearDown(self):
         javabridge.detach()
@@ -42,7 +41,7 @@ def test_file_not_found(self):
 class TestLoadUsingBioformatsURL(unittest.TestCase):
     def setUp(self):
         javabridge.attach()
-        log4j.basic_config()
+        bioformats.init_logger()
 
     def tearDown(self):
         javabridge.detach()