python-microscopy 25.6.5__cp39-cp39-win_amd64.whl

PYME/IO/DataSources/SupertileDatasource.py

@@ -0,0 +1,148 @@
+#!/usr/bin/python
+
+##################
+# TiffDataSource.py
+#
+# Copyright David Baddeley, 2009
+# d.baddeley@auckland.ac.nz
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+##################
+
+from PYME.IO.FileUtils.nameUtils import getFullExistingFilename
+from PYME.IO import MetaDataHandler
+#from PYME.IO.FileUtils import readTiff
+#from PIL import Image
+import glob
+import os
+import numpy as np
+from .BaseDataSource import XYTCDataSource
+#from PYME.misc import TiffImagePlugin #monkey patch PIL with improved tiff support from Priithon
+
+from urllib.parse import parse_qs
+#import numpy as np
+
+#from PYME.misc import tifffile
+
+class SupertileDataSource(XYTCDataSource):
+    moduleName = 'SupertileDataSource'
+    def __init__(self, pyramid, level=0, stride=3, overlap=1):
+        # NOTE: We cheat a bit here to allow this to be constructed from an existing pyramid - the cannonical module.DataSource(filename) instantiation 
+        # is handled in the function below
+        self.level = int(level)
+        self.stride = int(stride)
+        self.overlap = int(overlap)
+
+        self.mdh = MetaDataHandler.NestedClassMDHandler()
+        self.mdh.copyEntriesFrom(pyramid.mdh)
+        
+        voxelsize = self.mdh['Pyramid.PixelSize'] * (2 ** self.level)
+        self.mdh['voxelsize.x'], self.mdh['voxelsize.y'] = (voxelsize, voxelsize)
+
+        self._pyr = pyramid
+        
+        self.tile_size = self._pyr.tile_size*(self.stride + self.overlap)
+    
+    @staticmethod
+    def from_raw_tile_series(filename):
+        # TODO - do we really want/need this?? We should not be creating the pyramid from scratch in the datasource as this violates the assumption that
+        # datasource loading is comparatively fast / lightweight. Delete me??
+        import warnings
+        warnings.warn('This function might dissappear')
+        from PYME.Analysis.tile_pyramid import create_pyramid_from_dataset
+        from tempfile import TemporaryDirectory
+        
+        tile_base, query = filename.split('?')
+        qp = parse_qs(query)
+        level = int(qp.get('level', [0])[0])
+        stride = int(qp.get('stride', [3])[0])
+        overlap = int(qp.get('overlap', [1])[0])
+        tile_size = int(qp.get('tilesize', [256])[0])
+        
+        p = create_pyramid_from_dataset(tile_base, TemporaryDirectory(), tile_size)
+        
+        return SupertileDataSource(p, level, stride, overlap)
+    
+    @staticmethod
+    def from_filename(filename):
+        from PYME.Analysis.tile_pyramid import ImagePyramid
+        
+        tile_base, query = filename.split('?')
+        qp = parse_qs(query)
+        level = int(qp.get('level', [0])[0])
+        stride = int(qp.get('stride', [3])[0])
+        overlap = int(qp.get('overlap', [1])[0])        
+        p = ImagePyramid.load_existing(tile_base)
+        
+        return SupertileDataSource(p, level, stride, overlap)
+
+    @property
+    def tile_coords(self):
+        tc = np.array(self._pyr.get_layer_tile_coords(self.level))
+
+        x0, y0 = tc.min(axis=0)
+        xm, ym  = tc.max(axis=0)
+        
+        xvs = np.arange(x0, xm + self.stride, self.stride)
+        yvs = np.arange(y0, ym + self.stride, self.stride)
+        
+        
+        xc = (xvs[:,None]*np.ones_like(yvs)[None,:]).ravel()
+        yc = (yvs[None, :] * np.ones_like(xvs)[:, None]).ravel()
+        
+        return np.vstack([xc, yc]).T
+    
+    @property
+    def tile_coords_um(self):
+        """
+        Returns
+        -------
+        ndarray
+            coordinates of each frame, in micrometers, referenced to the origin
+            of the camera chip.
+        """
+        px_size = self.mdh['voxelsize.x']
+        
+        # Pyramid.x0 and Pyramid.y0 should be referenced to the camera origin
+        p0 = np.array([self.mdh['Pyramid.x0'], self.mdh['Pyramid.y0']])
+        
+        return px_size*self._pyr.tile_size*self.tile_coords + p0[None,:]
+        
+    
+    def getSlice(self, ind):
+        x, y = self.tile_coords[ind, :]
+        return self._pyr.get_oversize_tile(self.level, x, y, span=(self.stride+self.overlap))
+
+    def getSliceShape(self):
+        return (self.tile_size, self.tile_size)
+        #return self.im[0].shape[1:3]
+        #return self.data.shape[:2]
+
+    def getNumSlices(self):
+        return len(self.tile_coords)
+
+    def getEvents(self):
+        return []
+
+    def release(self):
+        #self.im.close()
+        pass
+
+    def reloadData(self):
+        pass
+    
+def DataSource(filename, taskQueue=None):
+    # cannonical DataSource constructor from filename (needed in order to be able to use this datasource as a task input)
+    return SupertileDataSource.from_filename(filename)

PYME/IO/DataSources/TQDataSource.py

@@ -0,0 +1,41 @@
+#!/usr/bin/python
+
+##################
+# TQDataSource.py
+#
+# Copyright David Baddeley, 2009
+# d.baddeley@auckland.ac.nz
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+##################
+from .BaseDataSource import XYTCDataSource
+
+class DataSource(XYTCDataSource):
+    moduleName = 'TQDataSource'
+    def __init__(self, queueName, taskQueue):
+        self.taskQueue = taskQueue
+        self.queueName = queueName
+
+    def getSlice(self, ind):
+        return self.taskQueue.getQueueData(self.queueName, 'ImageData',ind)
+
+    def getSliceShape(self):
+        return self.taskQueue.getQueueData(self.queueName, 'ImageShape')
+
+    def getNumSlices(self):
+        return self.taskQueue.getQueueData(self.queueName, 'NumSlices')
+
+    def getEvents(self):
+        return self.taskQueue.getQueueData(self.queueName, 'Events')

PYME/IO/DataSources/TiffDataSource.py

@@ -0,0 +1,193 @@
+#!/usr/bin/python
+
+##################
+# TiffDataSource.py
+#
+# Copyright David Baddeley, 2009
+# d.baddeley@auckland.ac.nz
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+##################
+
+from PYME.IO.FileUtils.nameUtils import getFullExistingFilename
+#from PYME.IO.FileUtils import readTiff
+#import Image
+#from PYME.misc import TiffImagePlugin #monkey patch PIL with improved tiff support from Priithon
+
+#import numpy as np
+
+try:
+    import tifffile
+    local_tifffile = False
+except ImportError:
+    local_tifffile = True
+    from PYME.contrib.gohlke import tifffile
+    
+from .BaseDataSource import XYZTCDataSource
+
+import logging
+logger = logging.getLogger(__name__)
+
+class DataSource(XYZTCDataSource):
+    moduleName = 'TiffDataSource'
+    def __init__(self, filename, taskQueue=None, chanNum = 0, series=0):
+        self.filename = getFullExistingFilename(filename)#convert relative path to full path
+        self.chanNum = chanNum
+        self.RGB = False
+        
+        #self.data = readTiff.read3DTiff(self.filename)
+
+        #self.im = Image.open(filename)
+
+        #self.im.seek(0)
+
+        #PIL's endedness support is subtly broken - try to fix it
+        #NB this is untested for floating point tiffs
+        #self.endedness = 'LE'
+        #if self.im.ifd.prefix =='MM':
+        #    self.endedness = 'BE'
+
+        #to find the number of images we have to loop over them all
+        #this is obviously not ideal as PIL loads the image data into memory for each
+        #slice and this is going to represent a huge performance penalty for large stacks
+        #should still let them be opened without having all images in memory at once though
+        #self.numSlices = self.im.tell()
+        
+        #try:
+        #    while True:
+        #        self.numSlices += 1
+        #        self.im.seek(self.numSlices)
+                
+        #except EOFError:
+        #    pass
+
+        print((self.filename))
+        
+        if local_tifffile:
+            logger.info('Using PYMEs built-in, old version of tifffile, better support for ImageJ tiffs can be had with the more recent pip version (`pip install tifffile`)')
+            tf = tifffile.TIFFfile(self.filename)
+        else:
+            tf = tifffile.TiffFile(self.filename)
+        
+        self.tf = tf # keep a reference for debugging
+        
+        print(tf.series[series].shape)
+        self.im = tf.series[series].pages
+        
+        axisOrder = 'XYZTC'
+        size_z = len(self.im)
+        size_c, size_t = 1,1
+        
+        if tf.is_ome or ((not local_tifffile)):
+            #print('Detected OME TIFF')
+            sh = {'Z':1, 'T': 1,'C':1}
+            _axes = tf.series[series].axes
+            if 'I' in _axes:
+                logger.info('Tiff file does not fully specify axes (axes=%s)' % (_axes.replace('I', '?')[::-1]))
+                if 'Z' not in _axes:
+                    logger.info('Assuming unknown axis is Z') # TODO - explain how to change axes later
+                    _axes = _axes.replace('I', 'Z')
+                elif 'C' not in _axes:
+                    logger.info('Assuming unknown axis is C')
+                    _axes = _axes.replace('I', 'C')
+                elif 'T' not in _axes:
+                    logger.info('Assuming unkown axis is T')
+                    _axes = _axes.replace('I', 'T')
+                else:
+                    logger.warning('Unknown axis with all standard axes defined - data might not read correctly')
+                
+            sh.update(dict(zip(_axes, tf.series[0].shape)))
+            logger.debug('sh = %s' % sh)
+            size_c = sh['C']
+            size_z  = sh['Z']
+            size_t = sh['T']
+            
+            axisOrder = _axes[::-1]
+
+            if 'Q' in axisOrder:
+                logger.warning('Q axis detected - this is not supported by PYME')
+                axisOrder = axisOrder.replace('Q', '')
+            
+            axisOrder = axisOrder + ''.join([a for a in ['Z', 'T', 'C'] if not a in axisOrder])
+            
+            logger.debug('raw TIFF axisOrder = %s' %axisOrder)
+            
+            #self.additionalDims = ''.join([a for a in axisOrder[2:] if sh[a] > 1])
+        elif tf.is_rgb:
+            print('WARNING: Detected RGB TIFF - data not likely to be suitable for quantitative analysis')
+            size_c = 3
+            self.RGB = True
+            if len(self.im) > 1:
+                # we can have multi-page RGB TIFF - why?????
+                print('WARNING: Multi-page RGB TIFF detected - where did this come from???')
+                
+            axisOrder = 'XYCZT'
+            size_z = len(self.im)
+            size_t = 1
+            
+        XYZTCDataSource.__init__(self, input_order=axisOrder, size_z=size_z, size_t=size_t, size_c=size_c)
+        
+        sl0 = self.getSlice(0)
+        self._dtype = sl0.dtype
+        self._shape = [sl0.shape[0], sl0.shape[1], size_z, size_t, size_c]
+    
+    def getSlice(self, ind):
+        #self.im.seek(ind)
+        #ima = np.array(im.getdata()).newbyteorder(self.endedness)
+        #return ima.reshape((self.im.size[1], self.im.size[0]))
+        #return self.data[:,:,ind]
+        if self.RGB:
+            # special case for RGB TIFF
+            ind_0 = ind%len(self.im)
+            ind_1 = int(ind/len(self.im))
+            return self.im[ind_0].asarray(squeeze=False)[0, 0, :,:,ind_1].squeeze()
+        
+        if local_tifffile:
+            res =  self.im[ind].asarray(squeeze=False, colormapped=False)
+            res = res[0, self.chanNum, :, :].squeeze()
+        else:
+            res = self.im[ind].asarray()
+        #if res.ndim == 3:
+        #print res.shape
+        #print self.chanNum
+        
+        #print res.shape
+        return res
+    
+    def getSliceShape(self):
+        #return (self.im.size[1], self.im.size[0])
+        if len(self.im[0].shape) == 2:
+            return self.im[0].shape
+        elif self.RGB:
+            return self.im[0].shape[:2]
+        else:
+            return self.im[0].shape[1:3] #FIXME - when is this used?
+        #return self.data.shape[:2]
+
+    def getNumSlices(self):
+        if self.RGB:
+            return len(self.im)*3
+        
+        return len(self.im)
+
+    def getEvents(self):
+        return []
+
+    def release(self):
+        #self.im.close()
+        pass
+
+    def reloadData(self):
+        pass

PYME/IO/DataSources/TileDataSource.py

@@ -0,0 +1,91 @@
+from PYME.IO.FileUtils.nameUtils import getFullExistingFilename
+from PYME.IO import MetaDataHandler
+#from PYME.IO.FileUtils import readTiff
+#from PIL import Image
+import glob
+import os
+import numpy as np
+from .BaseDataSource import XYZTCDataSource
+#from PYME.misc import TiffImagePlugin #monkey patch PIL with improved tiff support from Priithon
+
+from urllib.parse import parse_qs
+#import numpy as np
+
+#from PYME.misc import tifffile
+
+import logging
+logger = logging.getLogger(__name__)
+
+class TileDataSource(XYZTCDataSource):
+    moduleName = 'TileDataSource'
+    def __init__(self, pyramid, level=0):
+        # NOTE: We cheat a bit here to allow this to be constructed from an existing pyramid - the cannonical module.DataSource(filename) instantiation 
+        # is handled in the function below
+        self.level = int(level)
+
+        self.mdh = MetaDataHandler.NestedClassMDHandler()
+        self.mdh.copyEntriesFrom(pyramid.mdh)
+        
+        voxelsize = self.mdh['Pyramid.PixelSize'] * (2 ** self.level)
+        self.mdh['voxelsize.x'], self.mdh['voxelsize.y'] = (voxelsize, voxelsize)
+
+        self._pyr = pyramid
+
+        self._nx = pyramid.n_tiles_x/(2**level)
+        self._ny = pyramid.n_tiles_y/(2**level)        
+        self.tile_size = pyramid.tile_size
+
+        self._levels = None
+
+        XYZTCDataSource.__init__(self)
+    
+
+    @classmethod
+    def from_filename(cls, filename):
+        from PYME.Analysis.tile_pyramid import ImagePyramid
+        p = ImagePyramid.load_existing(filename)
+        
+        return cls(p)
+    
+    @property
+    def levels(self):
+        if self._levels is None:
+            self._levels = [self.__class__(self._pyr, level) for level in range(self._pyr.depth + 1)]
+        
+        return self._levels
+        
+    
+    def getSlice(self, ind):
+        assert(ind == 0)
+        return self._pyr.layers[self.level][:,:].squeeze()
+    
+    def __getitem__(self, keys):
+        logger.debug(f'TileDataSource.__getitem__ called with level: {self.level}, keys: {keys}')
+        return self._pyr.layers[self.level].__getitem__(keys)
+    
+    @property
+    def dtype(self):
+        return self._pyr.layers[self.level].dtype
+    
+
+    def getSliceShape(self):
+        return self._pyr.layers[self.level].shape
+        #return self.im[0].shape[1:3]
+        #return self.data.shape[:2]
+
+    def getNumSlices(self):
+        return 1
+
+    def getEvents(self):
+        return []
+
+    def release(self):
+        #self.im.close()
+        pass
+
+    def reloadData(self):
+        pass
+    
+def DataSource(filename, taskQueue=None):
+    # cannonical DataSource constructor from filename (needed in order to be able to use this datasource as a task input)
+    return TileDataSource.from_filename(filename)

PYME/IO/DataSources/UnsplitDataSource.py

@@ -0,0 +1,92 @@
+#!/usr/bin/python
+##################
+# UnsplitDataSource.py
+#
+# Copyright David Baddeley, 2011
+# d.baddeley@auckland.ac.nz
+# 
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+##################
+from __future__ import print_function
+import numpy as np
+from .BaseDataSource import XYTCDataSource
+
+from PYME.Analysis import splitting
+
+#from PYME.localization import splitting
+
+class DataSource(XYTCDataSource):
+    moduleName = 'UnsplitDataSource'
+    def __init__(self,dataSource, splitting_info : splitting.SplittingInfo, chan=0, shiftfield=None, voxelsize=(70., 70., 200.)):
+        #self.unmixer = unmixer
+        self.dataSource = dataSource
+        self.splitting_info = splitting_info
+
+        self.sliceShape = list(self.dataSource.shape[:-1])
+        
+        self._raw_w, self._raw_h = self.dataSource.shape[:2]
+
+        self.sliceShape[:2] = self.splitting_info.channel_shape
+    
+        self.chan = chan
+
+        self.voxelsize = voxelsize
+        if shiftfield and chan == 1:
+            # FIXME for nChans >= 2 
+            self.SetShiftField(shiftfield)
+
+
+    def SetShiftField(self, shiftField):
+       self.shift_corr = splitting.ShiftCorrector(shiftField)
+
+    def getSlice(self,ind):
+        sl = self.dataSource.getSlice(ind)
+        dsa = sl.squeeze()
+
+        flip = False
+        if self.chan > 0:
+            if self.flip: #FIXME - change the flip parameter to the data source to be consistent with splitting.get_channel
+                flip='up_down'
+
+        c = splitting.get_channel(dsa, self.splitting_info, chan=self.chan)
+
+        if hasattr(self, 'shift_corr'):
+            # do shift correction
+            return self.shift_corr.correct(c, self.voxelsize, origin_nm=self.voxelsize*np.array(self.ROI[:2]))
+
+        return c
+
+        
+
+    def getSliceShape(self):
+        #return (self.im.size[1], self.im.size[0])
+        return tuple(self.sliceShape)
+        #return self.data.shape[:2]
+
+    def getNumSlices(self):
+        return self.dataSource.getNumSlices()
+
+    def getEvents(self):
+        return self.dataSource.getEvents()
+
+    def release(self):
+        return self.dataSource.release()
+        
+
+    def reloadData(self):
+        return self.dataSource.reloadData()
+        
+
+

PYME/IO/DataSources/__init__.py

@@ -0,0 +1,59 @@
+#!/usr/bin/python
+
+###############
+# __init__.py
+#
+# Copyright David Baddeley, 2012
+# d.baddeley@auckland.ac.nz
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+################
+"""Data sources are a modular method for reading data (i.e. input plugins)
+
+Each DataSource should implement at least the following functions:
+
+getSlice(ind)  
+getSliceShape()
+getNumSlices()
+
+For more details see BaseDataSource
+
+"""
+import os
+
+def getDataSourceForFilename(filename):
+    if filename.startswith('QUEUE://'):
+        from . import TQDataSource
+        return TQDataSource.DataSource
+    elif filename.startswith('PYME-CLUSTER://') or filename.startswith('pyme-cluster://'):
+        from . import ClusterPZFDataSource
+        return ClusterPZFDataSource.DataSource
+    elif filename.startswith('http://') or filename.startswith('HTTP://'):
+        from . import HTTPDataSource
+        return HTTPDataSource.DataSource
+    elif filename.endswith('.h5'):
+        from . import HDFDataSource
+        return HDFDataSource.DataSource
+    #elif filename.endswith('.md'): #treat this as being an image series
+    #    self._loadImageSeries(filename)
+    elif os.path.splitext(filename)[1] in ['.tif', '.tif', '.lsm']: #try tiff
+        from . import TiffDataSource
+        return TiffDataSource.DataSource
+    elif filename.endswith('.dcimg'):
+        from . import DcimgDataSource
+        return DcimgDataSource.DataSource
+    else: #try bioformats
+        from . import BioformatsDataSource
+        return BioformatsDataSource.DataSource

PYME/IO/FileUtils/IJLut.py

@@ -0,0 +1,43 @@
+#!/usr/bin/python
+
+##################
+# IJLut.py
+#
+# Copyright David Baddeley, 2009
+# d.baddeley@auckland.ac.nz
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+##################
+# import pylab
+import matplotlib.cm
+import numpy
+import sys
+import os
+
+if __name__ == "__main__":
+
+    if not len(sys.argv) == 2:
+        raise RuntimeError('expected a directory to save the luts to')
+
+    outDir = sys.argv[1]
+
+    cmapnames = matplotlib.cm.cmapnames
+
+    for cmn in cmapnames:
+        c = (255*matplotlib.cm.__dict__[cmn](numpy.arange(256)))[:,:3].astype('uint8')
+
+        f = open(os.path.join(outDir, '%s.lut' % cmn), 'wb')
+        c.T.tofile(f)
+        f.close()