python-microscopy 25.11.20__cp313-cp313-win_amd64.whl

PYME/IO/DataSources/FlatFieldDataSource.py

@@ -0,0 +1,77 @@
+#!/usr/bin/python
+
+##################
+# HDFDataSource.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 getFullFilename
+from .BaseDataSource import XYTCDataSource
+#import tables
+from PYME.localization.remFitBuf import CameraInfoManager
+import numpy as np
+
+class DataSource(XYTCDataSource):
+    moduleName = 'FlatFieldDataSource'
+    def __init__(self, parentSource, mdh, flatfield=None, dark = None):
+        #self.h5Filename = getFullFilename(h5Filename)#convert relative path to full path
+        #self.h5File = tables.openFile(self.h5Filename)
+        self.source = parentSource
+        self.mdh = mdh
+        #self.flat = flatfield
+        
+        try:
+            slices = CameraInfoManager._parseROI(mdh)
+        except KeyError:
+            slices = [(slice(None), slice(None)),]
+        #print((x0, x1, y0, y1))
+
+        #self.offset = mdh.getEntry()
+        if flatfield is None:
+            self.flat = 1.
+        else:
+            self.flat = np.concatenate([flatfield[sl].astype('f') for sl in slices], 
+                                       axis=0)
+        
+        if dark is None:
+            self.dark = self.mdh.getEntry('Camera.ADOffset')
+        else:
+            self.dark = np.concatenate([dark[sl].astype('f') for sl in slices], 
+                                       axis=0)
+
+
+    def getSlice(self, ind):
+        #if ind >= self.h5File.root.ImageData.shape[0]:
+        #        self.reloadData() #try reloading the data in case it's grown
+        # print((self.getSliceShape(), self.flat.shape))
+        
+        return (self.source.getSlice(ind) - self.dark)*self.flat
+
+
+    def getSliceShape(self):
+        return self.source.getSliceShape()
+
+    def getNumSlices(self):
+        return self.source.getNumSlices()
+
+    def getEvents(self):
+        return self.source.getEvents()
+
+    def release(self):
+        self.source.release()

PYME/IO/DataSources/HDFDataSource.py

@@ -0,0 +1,160 @@
+#!/usr/bin/python
+
+##################
+# HDFDataSource.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
+import tables
+from .BaseDataSource import XYZTCDataSource
+import numpy as np
+
+try:
+    from PYME.IO import PZFFormat
+except ImportError:
+    pass
+
+import logging
+logger = logging.getLogger(__name__)
+
+class DataSource(XYZTCDataSource):
+    moduleName = 'HDFDataSource'
+    def __init__(self, h5Filename, taskQueue=None):
+        self.h5Filename = getFullExistingFilename(h5Filename)#convert relative path to full path
+        self.h5File = tables.open_file(self.h5Filename)
+        
+        self._pzf_index = None
+        
+        if getattr(self.h5File.root, 'PZFImageIndex', False):
+            self.usePZFFormat = True
+            try:
+                self.framesize = self.h5File.root.PZFImageData.attrs.framesize
+            except AttributeError:
+                self.framesize = PZFFormat.loads(self.h5File.root.PZFImageData[0])[0].squeeze().shape
+        else:
+            self.usePZFFormat = False
+            
+        try:
+            dimorder = self._img_data.attrs.DimOrder
+            if isinstance(dimorder, bytes):
+                dimorder = dimorder.decode()
+                
+            assert (dimorder[:2] == 'XY')
+            
+            size_c = int(self._img_data.attrs.SizeC)
+            size_z = int(self._img_data.attrs.SizeZ)
+            size_t = int(self._img_data.attrs.SizeT)
+            
+        except:
+            try:
+                logger.exception('dim info not found as table attribute, trying metadata')
+                dimorder = self.mdh['DimOrder']
+                if isinstance(dimorder, bytes):
+                    dimorder = dimorder.decode()
+                    
+                assert (dimorder[:2] == 'XY')
+                
+                size_c = int(self.mdh['SizeC'])
+                size_z = int(self.mdh['SizeZ'])
+                size_t = int(self.mdh['SizeT'])
+            except KeyError:
+                logger.exception('Error reading dim info from both table attrs and metadata, assuming xyz (can be safely ignored for old files)')
+                
+                dimorder = 'XYZTC'
+                size_z = self.getNumSlices()
+                size_t = 1
+                size_c = 1
+            
+        XYZTCDataSource.__init__(self, dimorder, size_z=size_z, size_t=size_t, size_c=size_c)
+
+        self._shape = tuple(self.getSliceShape()) + (size_z, size_t, size_c)
+        self._dtype = self.getSlice(0).dtype
+
+    @property
+    def _img_data(self):
+        if self.usePZFFormat:
+            return self.h5File.root.PZFImageData
+        else:
+            return self.h5File.root.ImageData
+
+    @property
+    def mdh(self):
+        # move metadata access here (from image.py) so that metadata can be used for xyztc info
+        if not hasattr(self, '_mdh'):
+            if 'MetaData' in self.h5File.root:
+                from PYME.IO import MetaDataHandler
+                self._mdh = MetaDataHandler.HDFMDHandler(self.h5File)
+            else:
+                self._mdh = None
+
+        return self._mdh
+
+    def getSlice(self, ind):
+        if self.usePZFFormat:
+            if ind >= self.h5File.root.PZFImageData.shape[0]:
+                self.reloadData() #try
+                
+            if not self.pzf_index is None:
+                ind = self.pzf_index['Position'][np.searchsorted(self.pzf_index['FrameNum'], ind)]
+            
+            return PZFFormat.loads(self.h5File.root.PZFImageData[ind])[0].squeeze() 
+        else:       
+            if ind >= self.h5File.root.ImageData.shape[0]:
+                    self.reloadData() #try reloading the data in case it's grown
+            
+            return self.h5File.root.ImageData[ind, :,:]
+
+    
+    @property
+    def pzf_index(self):
+        if self._pzf_index is None:
+            try:
+                pi = getattr(self.h5File.root, 'PZFImageIndex')[:]
+                self._pzf_index = np.sort(pi, order='FrameNum')
+            except AttributeError:
+                pass
+    
+        return self._pzf_index
+
+
+    def getSliceShape(self):
+        if self.usePZFFormat:
+            return self.framesize
+        else:
+            return self.h5File.root.ImageData.shape[1:3]
+
+    def getNumSlices(self):
+        if self.usePZFFormat:
+            return self.h5File.root.PZFImageData.shape[0]
+        else:
+            return self.h5File.root.ImageData.shape[0]
+
+    def getEvents(self):
+        try:
+            return self.h5File.root.Events[:]
+        except AttributeError:
+            return []
+
+    def release(self):
+        self.h5File.close()
+
+    def reloadData(self):
+        self.h5File.close()
+        self.h5File = tables.open_file(self.h5Filename)

PYME/IO/DataSources/HTTPDataSource.py

@@ -0,0 +1,80 @@
+#!/usr/bin/python
+
+##################
+# HDFDataSource.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.ParallelTasks.relativeFiles import getFullFilename
+#import tables
+from .BaseDataSource import XYTCDataSource
+
+#import httplib
+#import urllib
+import requests
+try:
+    # noinspection PyCompatibility
+    import cPickle as pickle
+except:
+    #py3
+    import pickle
+    
+import time
+
+SHAPE_LIFESPAN = 5
+
+
+
+class DataSource(XYTCDataSource):
+    moduleName = 'HTTPDataSource'
+    def __init__(self, url, queue=None):
+        self.url = url
+        self.lastShapeTime = 0
+        
+        self.dshape = self._request('%s/SHAPE' % self.url)
+        self.lastShapeTime = time.time()
+    
+    def _request(self, url):
+        #f = urllib.urlopen(url)
+        r = requests.get(url)
+        data= pickle.loads(r.content)
+        #f.close()
+        return data
+
+    def getSlice(self, ind):
+        sliceURL = '%s/DATA/%d' % (self.url, ind)
+        return self._request(sliceURL).squeeze()
+
+    def getSliceShape(self):
+        return tuple(self.dshape[:2])
+        
+    def getNumSlices(self):
+        t = time.time()
+        if (t-self.lastShapeTime) > SHAPE_LIFESPAN:
+            self.dshape = self._request('%s/SHAPE' % self.url)
+            self.lastShapeTime = t
+            
+        return self.dshape[2]
+
+    def getEvents(self):
+        return self._request('%s/EVENTS'%self.url)
+        
+    def getMetadata(self):
+        return self._request('%s/METADATA'%self.url)
+ 

PYME/IO/DataSources/ImageSeriesDataSource.py

@@ -0,0 +1,123 @@
+#!/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
+
+#import numpy as np
+
+#from PYME.misc import tifffile
+try:
+    import tifffile
+except ImportError:
+    from PYME.contrib.gohlke import tifffile
+
+class DataSource(XYTCDataSource):
+    moduleName = 'ImageSeriesDataSource'
+    def __init__(self, filename='', metadata=None, taskQueue=None):
+        if filename is not '':
+            self.filename = getFullExistingFilename(filename)#convert relative path to full path
+            #use metadata for glob
+            md = MetaDataHandler.SimpleMDHandler(self.filename)
+        else:
+            md = metadata
+            self.filename = ''
+
+        pattern = md.getEntry('SeriesPattern')
+
+        self.files = glob.glob(os.path.join(os.path.split(self.filename)[0], pattern))
+
+        self.files.sort()
+
+        f0 = self.files[0]
+        if f0.endswith('.tif'):
+            self.im0 = tifffile.imread(f0).squeeze()
+            self._slice_shape = self.im0.shape[:2]
+        else:
+            self.im0 = Image.open(self.files[0])
+            self._slice_shape = self.im0.size[1], self.im0.size[0]
+
+            #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.im0.ifd.prefix =='MM':
+                self.endedness = 'BE'
+                
+            print((self.im0.ifd.prefix))
+            print((self.endedness))
+
+        #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
+
+        #self.im = tifffile.TIFFfile(self.filename)
+
+
+    def getSlice(self, ind):
+        #self.im.seek(ind)
+        fn = self.files[ind]
+        if fn.endswith('.tif'):
+            return tifffile.imread(fn).squeeze()
+        else:
+            im = Image.open(fn)
+            ima = np.array(im.getdata())#.newbyteorder(self.endedness)
+            return ima.reshape(self._slice_shape)
+        #return self.data[:,:,ind]
+        #return self.im[ind].asarray()
+
+    def getSliceShape(self):
+        return self._slice_shape
+        #return self.im[0].shape[1:3]
+        #return self.data.shape[:2]
+
+    def getNumSlices(self):
+        return len(self.files)
+
+    def getEvents(self):
+        return []
+
+    def release(self):
+        #self.im.close()
+        pass
+
+    def reloadData(self):
+        pass

PYME/IO/DataSources/MultiviewDataSource.py

@@ -0,0 +1,99 @@
+#!/usr/bin/python
+
+##################
+# HDFDataSource.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/>.
+#
+##################
+""" A DataSource which crops multiple separated (but equal sized) ROIs out of a larger frame and then 
+    recombines them. 
+
+    Useful for situations such as multi-view imaging where there is blank space between 
+    the views - e.g. the Bewersdorf lab biplane setup.
+
+    Views are concatenated along the x-axis
+"""
+
+from PYME.IO.FileUtils.nameUtils import getFullExistingFilename
+from .BaseDataSource import XYTCDataSource
+import numpy as np
+
+# default cropping info - should correspond to the Bewersdorf lab setup
+# IMPORTANT: this should be sourced from metadata, the code here serves only as an example
+
+CROP_INFO_YU = {
+    'Multiview.NumROIs' : 4,
+    'Multiview.ROISize' : (256, 256),
+    'Multiview.ROI0Origin' : (132, 0),
+    'Multiview.ROI1Origin' : (637, 0),
+    'Multiview.ROI2Origin' : (1087, 0),
+    'Multiview.ROI3Origin' : (1672, 0),
+}
+
+
+class DataSource(XYTCDataSource):
+    moduleName = 'MultiviewDataSource'
+    def __init__(self, dataSource, croppingInfo):
+        """
+        Create a new Multiview data source in which multiple ROIs are cropped from an original image and concatenated. Used principally for cutting 
+        horizontally spaced ROIs out of a vertical band of the sCMOS chip, where there is dark space between the images and we want to avoid saving
+        and transmitting this dark data.
+        
+        Parameters
+        ==========
+        dataSource : PYME.IO.DataSources.X data source object
+            The DataSource to crop from
+        croppingInfo : "dictionary like" object
+            Information about how to crop the image. Can either be a dictionary, or something which behaves like a dictionary (e.g. a MetaDataHandler).
+            The cropping info should define the keys defined in CROP_INFO_YU above.
+        
+        """
+        self.ds = dataSource
+        self.croppingInfo = croppingInfo
+
+        self.numROIs = croppingInfo['Multiview.NumROIs']
+        self.roiSizeX, self.roiSizeY = croppingInfo['Multiview.ROISize']
+
+        #set vertical ROI size to the minimum of the specified vertical ROI size and the
+        #vertical size of the raw data. This allows us to re-use roi settings even if 
+        #we have set a smaller vertical ROI on the camera
+        self.roiSizeY = min(self.roiSizeY, self.ds.getSliceShape()[1])
+
+        self.viewOrigins = [croppingInfo['Multiview.ROI%dOrigin' % i] for i in range(self.numROIs)]
+        
+    def getSlice(self, ind):            
+        f = self.ds.getSlice(ind)
+
+        #extract ROIs and concatenate
+        rois = [f[ox:(ox + self.roiSizeX), oy:(oy + self.roiSizeY)] for ox, oy in self.viewOrigins]
+        return np.concatenate(rois, axis = 0)
+
+    def getSliceShape(self):
+        return (self.roiSizeX*self.numROIs, self.roiSizeY)
+
+    def getNumSlices(self):
+        return self.ds.getNumSlices()
+
+    def getEvents(self):
+        return self.ds.getEvents()
+
+    def release(self):
+        self.ds.release()
+
+    def reloadData(self):
+        self.ds.reloadData()

PYME/IO/DataSources/OBFDataSource.py

@@ -0,0 +1,67 @@
+
+from PYME.IO.FileUtils.nameUtils import getFullExistingFilename
+from PYME.IO.DataSources.BaseDataSource import XYTCDataSource
+from PYME.IO.FileUtils import obf_support
+import logging
+
+logger = logging.getLogger(__name__)
+
+class DataSource(XYTCDataSource):
+    moduleName = 'OBFDataSource'
+    def __init__(self, obf, stack_number=None):
+        if isinstance(obf, str):
+            self.filename = getFullExistingFilename(obf)#convert relative path to full path
+            self.obf = obf_support.File(self.filename)
+            logger.debug('file: {}'.format(self.filename))
+        else:
+            self.obf = obf
+        
+        logger.debug('format version: {}'.format(self.obf.format_version))
+        logger.debug('description: "{}"'.format(self.obf.description))
+        logger.debug('contains {} stacks'.format(len(self.obf.stacks)))
+
+        if stack_number is None:
+            stack_number = 0
+            if len(self.obf.stacks) > 1:
+                logger.error('More than one stack present, add ?stack=X to filename to select one:')
+                for index, stack in enumerate(self.obf.stacks):
+                    logger.debug('\nstack {}'.format(index))
+                    logger.debug(' format version: {}'.format(stack.format_version))
+                    logger.debug(' name: "{}"'.format(stack.name))
+                    logger.debug(' description: "{}"'.format(stack.description))
+                raise RuntimeError(logger.error('More than one stack present, add ?stack=X to filename to select one'))
+        
+        self.stack_number = stack_number
+        stack = self.obf.stacks[self.stack_number]
+
+        logger.debug(' format version: {}'.format(stack.format_version))
+        logger.debug(' name: "{}"'.format(stack.name))
+        logger.debug(' description: "{}"'.format(stack.description))
+        logger.debug(' shape: {}'.format(stack.shape))
+        logger.debug(' dimensionality: {}'.format(stack.dimensionality))
+        logger.debug(' lengths: {}'.format(stack.lengths))
+        logger.debug(' pixel sizes: {}'.format(stack.pixel_sizes))
+        logger.debug(' offsets: {}'.format(stack.offsets))
+        logger.debug(' data type: {}'.format(stack.data_type.__name__))
+
+        self.stack = stack
+        
+    def getSlice(self, ind):
+        return self.stack.data[:,:,ind].squeeze()
+
+    def getSliceShape(self):
+        return self.stack.data.shape[:2]
+
+    def getNumSlices(self):
+        return self.stack.data.shape[2]
+
+    def getEvents(self):
+        return []
+
+    def release(self):
+        self.obf.close()
+
+    def reloadData(self):
+        self.close()
+        self.obf = obf_support.File(self.filename)
+        self.stack = self.obf.stacks[self.stack_number]

PYME/IO/DataSources/RandomDataSource.py

@@ -0,0 +1,23 @@
+from .BaseDataSource import XYTCDataSource
+import numpy as np
+
+class DataSource(XYTCDataSource):
+    moduleName = 'RandomDataSource'
+
+    def __init__(self, pix_r, pix_c, length=100):
+        self.pix_r = pix_r
+        self.pix_c = pix_c
+        self.length = length
+        self.data = np.random.randint(1, np.iinfo(np.int16).max, (self.pix_r, self.pix_c, self.length), np.int16)
+
+    def getSlice(self, ind):
+        return self.data[:, :, ind]
+
+    def getSliceShape(self):
+        return (self.pix_r, self.pix_c)
+
+    def getNumSlices(self):
+        return self.length
+
+    def getEvents(self):
+        return []