python-microscopy 25.6.5__cp39-cp39-win_amd64.whl

PYME/IO/load_psf.py

@@ -0,0 +1,26 @@
+"""
+Common logic for loading a PSF
+"""
+import numpy as np
+from collections import namedtuple
+from PYME.IO.image import ImageStack
+
+import logging
+logger = logging.getLogger(__name__)
+
+#VoxNM = namedtuple('VoxNM', 'x, y, z')
+
+def load_psf(filename, haveGUI=False):
+    """Load a PSF from an image file"""
+    img = ImageStack(filename=filename, haveGUI=haveGUI)
+    ps = img.data_xytc[:, :, :,0].squeeze()
+    vox_nm = img.voxelsize_nm
+    
+    #sanity checks
+    if not issubclass(ps.dtype.type, np.floating):
+        raise RuntimeError('Expecting floating point PSF data. Was the PSF generated by PYME?')
+    
+    if (ps.shape[0] < 40) or (ps.shape[0] > 100):
+        logging.warning('PSF shape (%s) seems odd. Expecting a shape around [61,61,61]' % str(ps.shape))
+    
+    return ps, vox_nm

PYME/IO/pyme_h5ls.py

@@ -0,0 +1,58 @@
+import logging
+logger = logging.getLogger(__name__)
+import sys
+
+def list_h5(filename):
+    import tables
+    from PYME.IO import MetaDataHandler
+    from PYME.IO import tabular
+    from PYME.IO import unifiedIO
+    import json
+    
+    with unifiedIO.local_or_temp_filename(filename) as fn:
+        with tables.open_file(fn, mode='r') as h5f:
+            #make sure our hdf file gets closed
+            
+            try:
+                mdh = MetaDataHandler.NestedClassMDHandler(MetaDataHandler.HDFMDHandler(h5f))
+                print('Metadata:\n____________')
+                print(repr(mdh))
+            except tables.FileModeError:  # Occurs if no metadata is found, since we opened the table in read-mode
+                logger.warning('No metadata found, proceeding with empty metadata')
+                mdh = MetaDataHandler.NestedClassMDHandler()
+                
+            print('\n\n')
+            
+            for t in h5f.list_nodes('/'):
+                # FIXME - The following isinstance tests are not very safe (and badly broken in some cases e.g.
+                # PZF formatted image data, Image data which is not in an EArray, etc ...)
+                # Note that EArray is only used for streaming data!
+                # They should ideally be replaced with more comprehensive tests (potentially based on array or dataset
+                # dimensionality and/or data type) - i.e. duck typing. Our strategy for images in HDF should probably
+                # also be improved / clarified - can we use hdf attributes to hint at the data intent? How do we support
+                # > 3D data?
+                
+                if not isinstance(t, tables.Group):
+                    print(t.name)
+                    print('______________')
+                    
+                    if isinstance(t, tables.VLArray):
+                        data = h5f.get_node(h5f.root, t.name)
+                        print('Ragged (VLArray) with %d rows' % len(data))
+                        print('Row 0: %s' % data)
+                    
+                    elif isinstance(t, tables.table.Table):
+                        #  pipe our table into h5r or hdf source depending on the extension
+                        data = h5f.get_node(h5f.root, t.name)
+                        
+                        print('Table with %d rows\n dtype = %s' % (len(data), data[0].dtype))
+                    
+                    elif isinstance(t, tables.EArray):
+                        data = h5f.get_node(h5f.root, t.name)
+                        
+                        print('Image, shape = %s' % data.shape)
+                        
+                    print('\n\n')
+                
+if __name__ == '__main__':
+    list_h5(sys.argv[1])

PYME/IO/ragged.py

@@ -0,0 +1,138 @@
+
+import six
+
+class RaggedBase(object):
+    """Base class for ragged or free-form objects in recipes. Looks like a read-only list of
+    arbitrary objects. Objects should be json serializable (ie simple combinations of base types)."""
+    
+    def __init__(self, mdh=None):
+        self.mdh = mdh
+        
+    def __getitem__(self, item):
+        """Implement this in derived classes to mimic list semantics"""
+        raise NotImplementedError
+    
+    def __len__(self):
+        """Implement this in derived classes to mimic list semantics"""
+        raise NotImplementedError
+
+    def _jsify(self, obj):
+        import json
+        import numpy as np
+        """call a custom to_JSON method, if available"""
+        #if isinstance(obj, np.integer):
+        #    return int(obj)
+        #elif isinstance(obj, np.number):
+        #    return float(obj)
+        if isinstance(obj, np.generic):
+            return obj.tolist()
+    
+        try:
+            return obj.to_JSON()
+        except AttributeError:
+            return obj
+    
+    def to_json(self):
+        #TODO - write me
+        import json
+        return json.dumps([self._jsify(o) for o in self])
+    
+    def to_hdf(self, filename, tablename, mode='w', metadata=None):
+        #TODO - write me / re-evaluate. This should be cluster aware and use h5r file. Ragged array logic belongs in h5rfile
+        from PYME.IO import h5rFile
+        import json
+        
+        with h5rFile.H5RFile(filename, mode) as h5f:
+            for item in self:
+                item_js = self._jsify(item)
+                if not isinstance(item_js, str):
+                    item_js = json.dumps(item_js)
+                h5f.appendToTable(tablename, item_js.encode())
+
+            # handle metadata
+            if metadata is not None:
+                h5f.updateMetadata(metadata)
+
+class RaggedCache(RaggedBase):
+    def __init__(self, iterable=None, mdh=None):
+        if iterable:
+            self._data = list(iterable)
+        else:
+            self._data = list()
+            
+        RaggedBase.__init__(self, mdh)
+        
+    def __getitem__(self, item):
+        return self._data[item]
+    
+    def __len__(self):
+        return len(self._data)
+
+
+class RaggedJSON(RaggedCache):
+    def __init__(self, filename, mdh=None):
+        import json
+        
+        with open(filename, 'r') as f:
+            data = list(json.loads(f.read()))
+        
+        RaggedCache.__init__(self, data, mdh)
+     
+    
+class RaggedVLArray(RaggedBase):
+    def __init__(self, h5f, tablename, mdh=None, copy=False):
+        """
+        Ragged type which wraps an HDF table variable-length array
+        
+        Parameters
+        ----------
+        h5f : HDF table or str
+            Either an open HDF table instance, or a str of the filepath to open one
+        tablename : str
+            Name of the table to open and wrap (beyond root, i.e. h5f.root.tablename
+        mdh : PYME.MetaDataHandler.MDHandlerBase or derived class
+            Metadata to initialize RaggedVLArray with. If None, will be initialized with blank metadata
+            
+        copy: load entire data into memory so we can close the original file
+            
+        """
+        RaggedBase.__init__(self, mdh)
+
+        if isinstance(h5f, six.string_types):
+            import tables
+            h5f = tables.open_file(h5f)
+            self._h5file = h5f  # if we open it, grab a reference so we can close it later
+            self._own_hdf = True
+        else:
+            self._own_hdf = False
+
+        self._data = h5f.get_node(h5f.root, tablename)
+        
+        if copy:
+            self._data = self._data[:]
+            if self._own_hdf:
+                self._h5file.close()
+                
+
+    def __del__(self):
+        """
+        Make sure we close our h5 file if we opened one. If it was created outside the scope of this class, it should be
+        handled elsewhere.
+
+        """
+        try:
+            if self._own_hdf:
+                self._h5file.close()
+        except AttributeError:
+            pass
+    
+    def __getitem__(self, item):
+        import json
+        
+        return json.loads(self._data[item].decode())
+    
+    def __len__(self):
+        return len(self._data)
+        
+
+    

PYME/IO/rgb_image.py

@@ -0,0 +1,94 @@
+import numpy as np
+from scipy import ndimage
+
+def image_to_rgb(image, zoom=1.0, scaling='min-max', scaling_factor=0.99):
+    data = np.zeros([int(image.data.shape[0] / zoom), int(image.data.shape[1] / zoom), 3], dtype='uint8')
+    
+    for i in range(min(3, image.data.shape[3])):
+        chan_i = ndimage.zoom(image.data[:, :, :, i].mean(2).squeeze(), 1. / zoom)
+        
+        if scaling == 'min-max':
+            chan_i = chan_i - chan_i.min()
+            chan_i = (255 * chan_i / chan_i.max()).astype('uint8')
+        elif scaling == 'percentile':
+            lb = np.percentile(chan_i, 100 * (1 - scaling_factor))
+            ub = np.percentile(chan_i, 100 * scaling_factor)
+            chan_i = (255 * np.minimum(np.maximum(chan_i - lb, 0) / float(ub - lb), 1)).astype('uint8')
+        
+        data[:, :, i] = chan_i
+    
+    if image.data.shape[3] == 1:
+        #make greyscale if a single colour channel
+        data[:, :, 1] = data[:, :, 0]
+        data[:, :, 2] = data[:, :, 0]
+    
+    return data
+
+def image_to_cmy(image, *args, **kwargs):
+    data = image_to_rgb(image, *args, **kwargs)
+    if image.data.shape[3] == 1:
+        return data  # grayscale, can't convert to CMY (rather than CMYK)
+    
+    output = np.zeros_like(data)
+    
+    k = 255 - data.max(2)
+    
+    output[:, :, 0] = 255 - (k + data[:, :, 0])
+    output[:, :, 1] = 255 - (k + data[:, :, 1])
+    output[:, :, 2] = 255 - (k + data[:, :, 2])
+    
+    return output
+    
+# jinja filters
+# these output an image as a base64 encoded string suitable for incorporating into an html page
+
+def base64_image(image, zoom=1.0, scaling='min-max', scaling_factor=0.99, colorblind_friendly=False, type='png'):
+    """
+    Jinga2 filter which converts an image stack (PYME.IO.image.ImageStack) into a base64 encoded image suitable for
+    inline incorporation into an html page.
+    
+    Use with the following (or similar) html template code:
+     
+    .. code-block:: html
+        
+        <img src="data:image/png;base64,{{ image|base64_image(scaling='percentile') }}">
+        
+    can also output as jpg (or anything supported by both html and PIL) if the type parameter is set AND the html code
+    is altered to give the correct mime type.
+     
+    Parameters
+    ----------
+    image: a PYME.io.image.ImageStack instance
+    zoom: float, how large to zoom the image
+    scaling: string, how to scale the intensity - one of 'min-max' or 'percentile'
+    scaling_factor: float, Percentile only - which percentile to use
+    colorblind_friendly: bool, Use cyan, magenta, and yellow rather than RGB to better accommodate colourblind users
+    type: string, image type. See PIL / Pillow documentation for details.
+
+    Returns
+    -------
+    
+    a b64 encoded string
+
+    """
+    from io import BytesIO
+    import base64
+    
+    try:
+        from PIL import Image
+    except ImportError:
+        import Image
+    
+    if colorblind_friendly:
+        im = image_to_cmy(image, zoom=zoom, scaling=scaling, scaling_factor = scaling_factor)
+    else:
+        im = image_to_rgb(image, zoom=zoom, scaling=scaling, scaling_factor=scaling_factor)
+
+    
+    outf = BytesIO()
+
+    Image.fromarray(im, mode='RGB').save(outf,type.upper())
+    s = outf.getvalue()
+    outf.close()
+
+    return base64.b64decode(s)