python-microscopy 25.6.5__cp39-cp39-win_amd64.whl

PYME/recipes/batchProcess.py

@@ -0,0 +1,147 @@
+#!/usr/bin/env pythonw
+# -*- coding: utf-8 -*-
+"""
+Created on Sat May  9 12:23:57 2015
+
+@author: david
+"""
+from PYME.recipes import runRecipe
+from PYME.recipes import Recipe, modules
+import os
+import glob
+from argparse import ArgumentParser
+import traceback
+
+import multiprocessing
+
+NUM_PROCS = multiprocessing.cpu_count()
+
+def runRec(args):
+    #print args
+    try:
+        import matplotlib.pyplot as plt
+    
+        old_backend = plt.get_backend()
+        plt.switch_backend('SVG')
+        
+        r = runRecipe.runRecipe(*args)
+        
+        plt.switch_backend(old_backend)
+        return r
+    except Exception as e:
+        traceback.print_exc()
+        raise
+    
+def bake(recipe, inputGlobs, output_dir, num_procs = NUM_PROCS, start_callback=None, success_callback=None, error_callback=None, metadata_defaults={}):
+    """Run a given recipe over using multiple proceses.
+    
+    Parameters
+    ----------
+      recipe:       The recipe to run
+      inputGlobs:   A dictionary of where the keys are the input names, and each
+                    entry is a list of filenames which provide the data for that
+                    input.
+      output_dir:   The directory to save the output in
+      num_procs:    The number of worker processes to launch (defaults to the number of CPUs)
+      
+    """
+    
+    #check that we've supplied the right number of images for each named input/channel
+    inputLengths = [len(v) for v in inputGlobs.values()]
+    if not (min(inputLengths) == max(inputLengths)):
+        raise RuntimeError('The number of entries in each input category must be equal')
+        
+    taskParams = []
+    outputNames = recipe.outputs
+    
+    for i in range(inputLengths[0]):
+        in_d = {k:v[i] for k, v in inputGlobs.items()}
+
+        # FIXME - change to os.path.splitext(os.path.basename(list(in_d.values())[0]).split('?')[0])[0], otherwise file_stub = ?level=N for supertiles
+        file_stub = os.path.splitext(os.path.basename(list(in_d.values())[0]))[0]
+        
+        fns = os.path.join(output_dir, file_stub)
+        out_d = {k:('%s_%s'% (fns,k)) for k in  outputNames}
+
+        cntxt = {'output_dir' : output_dir, 'file_stub': file_stub}
+
+        taskParams.append((recipe.toYAML(), in_d, out_d, cntxt, dict(metadata_defaults)))
+
+    last_rec = None
+
+    if num_procs == 1:
+        # map(runRec, taskParams)  # map now returns iterator, which means this never runs unless we convert to list
+        #[runRec(task) for task in taskParams]  # skip the map and just make the list we need anyway
+        for task in taskParams:
+            in_d = task[1]
+            if start_callback:
+                start_callback(in_d)
+            try:
+                last_rec = runRec(task)
+                if success_callback:
+                    success_callback(in_d)
+            except:
+                if error_callback:
+                    error_callback(in_d)
+                raise
+        return last_rec        
+    else:
+        pool = multiprocessing.Pool(num_procs)
+    
+        r = pool.map_async(runRec, taskParams, error_callback = lambda e: traceback.print_exception(e, value=e, tb=e.__traceback__))
+        
+        r.wait()
+        pool.close()
+        return None
+
+def bake_recipe(recipe_filename, inputGlobs, output_dir, *args, **kwargs):
+    with open(recipe_filename) as f:
+        s = f.read()
+    
+    recipe = Recipe.fromYAML(s)
+    
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+        
+    bake(recipe, inputGlobs, output_dir, *args, **kwargs)
+    
+
+def main():
+    # set matplotlib backend for offline figure generation #TODO - move this further down (ie. to the figure generation code itself)?
+    import matplotlib
+    matplotlib.use('Cairo', warn=False)
+    
+    #start by finding out what recipe we're using - different recipes can have different options    
+    ap = ArgumentParser()#usage = 'usage: %(prog)s [options] recipe.yaml')
+    ap.add_argument('recipe')
+    ap.add_argument('output_dir')
+    ap.add_argument('-n', '--num-processes', default=NUM_PROCS)
+    args, remainder = ap.parse_known_args()
+    
+    #load the recipe
+    with open(args.recipe) as f:
+        s = f.read()
+        
+    recipe = Recipe.fromYAML(s)
+
+    output_dir = args.output_dir
+    num_procs = args.num_processes
+    
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+    
+    #create a new parser to parse input and output filenames
+    op = ArgumentParser()
+    for ip in recipe.inputs:
+        op.add_argument('--%s' % ip)
+        
+        
+    args = op.parse_args(remainder)
+    
+    inputGlobs = {k: glob.glob(getattr(args, k)) for k in recipe.inputs}
+    
+    bake(recipe, inputGlobs, output_dir, num_procs)
+        
+        
+if __name__ == '__main__':
+    main()

PYME/recipes/filters.py

@@ -0,0 +1,394 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Feb 20 17:11:05 2015
+
+@author: david
+"""
+from .base import register_module, ModuleBase, Filter
+from .traits import Input, Output, Float, Enum, CStr, Bool, Int
+from scipy import ndimage
+#from PYME.IO.image import ImageStack
+import numpy as np
+
+@register_module('GaussianFilter')    
+class GaussianFilter(Filter):
+    """
+    Performs a Gaussian filter of the input image
+
+    Parameters
+    ----------
+
+    sigmaX : std. deviation of filter kernel along x axis in pixels
+
+    sigmaY : std. deviation of filter kernel along y axis in pixels
+
+    sigmaZ : std. deviation of filter kernel along z  axisin pixels
+
+    Notes
+    -----
+
+    * implemented as a call to `scipy.ndimage.gaussian_filter`
+    * sigmaZ is ignored and a 2D filtering performed if ``processFramesIndividually`` is selected
+    """
+    sigmaY = Float(1.0)
+    sigmaX = Float(1.0)
+    sigmaZ = Float(1.0)
+    sigmaT = Float(0.0)
+    #def __init__(self, **kwargs):
+    #    pass
+    @property
+    def sigmas(self):
+        return [self.sigmaX, self.sigmaY, self.sigmaZ, self.sigmaT]
+    
+    def apply_filter(self, data, voxelsize):
+        return ndimage.gaussian_filter(data, self.sigmas[:len(data.shape)])
+    
+    def completeMetadata(self, im):
+        im.mdh['Processing.GaussianFilter.Sigmas'] = self.sigmas
+
+@register_module('MedianFilter')         
+class MedianFilter(Filter):
+    """
+    Performs a median filter of the input image
+
+    Parameters
+    ----------
+
+    sizeX : size of filter kernel along x axis in pixels
+
+    sizeY : size of filter kernel along y axis in pixels
+
+    sizeZ : size of filter kernel along z  axisin pixels
+
+    Notes
+    -----
+
+    * implemented as a call to `scipy.ndimage.median_filter`
+    * sizeZ is ignored and a 2D filtering performed if ``processFramesIndividually`` is selected
+    """
+    sizeX = Int(3)
+    sizeY = Int(3)
+    sizeZ = Int(3)
+    sizeT = Int(0)
+    #def __init__(self, **kwargs):
+    #    pass
+    @property
+    def sigmas(self):
+        return [self.sizeX, self.sizeY, self.sizeZ, self.sizeT]
+    
+    def apply_filter(self, data, voxelsize):
+        return ndimage.median_filter(data, self.sigmas[:len(data.shape)])
+    
+    def completeMetadata(self, im):
+        im.mdh['Processing.MedianFilter.Sigmas'] = self.sigmas
+
+
+@register_module('MaxFilter')
+class MaxFilter(Filter):
+    """
+    Performs a maximum filter of the input image
+
+    Parameters
+    ----------
+
+    sizeX : size of filter kernel along x axis in pixels
+
+    sizeY : size of filter kernel along y axis in pixels
+
+    sizeZ : size of filter kernel along z axis in pixels
+
+    Notes
+    -----
+    * implemented as a call to `scipy.ndimage.maximum_filter`
+    * sizeZ is ignored and a 2D filtering performed if ``processFramesIndividually`` is selected
+    """
+    sizeX = Int(3)
+    sizeY = Int(3)
+    sizeZ = Int(3)
+    sizeT = Int(0)
+
+    # def __init__(self, **kwargs):
+    #    pass
+    @property
+    def sigmas(self):
+        return [self.sizeX, self.sizeY, self.sizeZ, self.sizeT]
+
+    def apply_filter(self, data, voxelsize):
+        return ndimage.maximum_filter(data, self.sigmas[:len(data.shape)])
+
+    def completeMetadata(self, im):
+        im.mdh['Processing.MaxFilter.Sigmas'] = self.sigmas
+
+@register_module('MinFilter')
+class MinFilter(Filter):
+    """
+    Performs a maximum filter of the input image
+
+    Parameters
+    ----------
+
+    sizeX : size of filter kernel along x axis in pixels
+
+    sizeY : size of filter kernel along y axis in pixels
+
+    sizeZ : size of filter kernel along z axis in pixels
+
+    Notes
+    -----
+    * implemented as a call to `scipy.ndimage.maximum_filter`
+    * sizeZ is ignored and a 2D filtering performed if ``processFramesIndividually`` is selected
+    """
+    sizeX = Int(3)
+    sizeY = Int(3)
+    sizeZ = Int(3)
+    sizeT = Int(0)
+
+    # def __init__(self, **kwargs):
+    #    pass
+    @property
+    def sigmas(self):
+        return [self.sizeX, self.sizeY, self.sizeZ, self.sizeT]
+
+    def apply_filter(self, data, voxelsize):
+        return ndimage.minimum_filter(data, self.sigmas[:len(data.shape)])
+
+    def completeMetadata(self, im):
+        im.mdh['Processing.MinFilter.Sigmas'] = self.sigmas
+        
+@register_module('DespeckleFilter')         
+class DespeckleFilter(Filter):
+    """
+    Attempts to remove speckle from an image.
+
+    The despeckle filter functions by replacing a value of each pixel with the median of the *nPix* pixels within
+    the filter support which are closest in intensity to the value of the pixel itself.
+
+    Parameters
+    ----------
+
+    sizeX : size of filter kernel along x axis in pixels
+
+    sizeY : size of filter kernel along y axis in pixels
+
+    sizeZ : size of filter kernel along z  axis in pixels
+
+    nPix : number of pixels to use for the median
+
+    Notes
+    -----
+
+    * The design intent is an edge-preserving filter for images which have a lot of shot noise (e.g. STED images)
+    * It is highly non-linear, and thus best suited for either treating images for display, or potentially segmentation.
+      It should **NOT** be used if intensities need to be quantified or prior to operations such as deconvolution.
+    * sizeZ is ignored and a 2D filtering performed if ``processFramesIndividually`` is selected
+    """
+    sizeX = Int(3)
+    sizeY = Int(3)
+    sizeZ = Int(3)
+    nPix = Int(3)
+    
+    def _filt(self, data):
+        v = data[int(data.size / 2)]
+        
+        dv = np.abs(data - v)
+        
+        I = np.argsort(dv)
+        return np.median(data[I[:self.nPix]])
+        
+    #def __init__(self, **kwargs):
+    #    pass
+    @property
+    def sigmas(self):
+        return [self.sizeX, self.sizeY, self.sizeZ]
+    
+    def apply_filter(self, data, voxelsize):
+        return ndimage.generic_filter(data, self._filt, self.sigmas[:len(data.shape)])
+    
+    def completeMetadata(self, im):
+        im.mdh['Processing.DespeckleFilter.Sigmas'] = self.sigmas
+
+@register_module('MeanFilter') 
+class MeanFilter(Filter):
+    """
+    Performs a mean / uniform filter of the input image
+
+    Parameters
+    ----------
+
+    sizeX : size of filter kernel along x axis in pixels
+
+    sizeY : size of filter kernel along y axis in pixels
+
+    sizeZ : size of filter kernel along z  axis in pixels
+
+    Notes
+    -----
+
+    * implemented as a call to `scipy.ndimage.mean_filter`
+    * sizeZ is ignored and a 2D filtering performed if ``processFramesIndividually`` is selected
+    """
+    sizeX = Int(3)
+    sizeY = Int(3)
+    sizeZ = Int(3)
+    sizeT = Int(0)
+    #def __init__(self, **kwargs):
+    #    pass
+    @property
+    def sigmas(self):
+        return [self.sizeX, self.sizeY, self.sizeZ, self.sizeT]
+    
+    def apply_filter(self, data, voxelsize):
+        return ndimage.uniform_filter(data, self.sigmas[:len(data.shape)])
+    
+    def completeMetadata(self, im):
+        im.mdh['Processing.MeanFilter.Sigmas'] = self.sigmas
+
+@register_module('Zoom')         
+class Zoom(Filter):
+    """
+    Zoom / resize an image using ``ndimage.zoom``
+
+    Parameters
+    ----------
+
+    zoom : factor by which to zoom the image
+
+    Notes
+    -----
+    * zoom is isotropic in 3D if ``processFramesIndividually`` is ``False``
+    * zoom only zooms in x and y if ``processFramesIndividually`` is ``True``
+
+    """
+    dimensionality = Enum('XY', 'XYZ', desc='Which image dimensions should the filter be applied to?')
+    
+    zoom = Float(1.0)
+
+    _block_safe = False # TODO - make a block safe version of this!
+    
+    def apply_filter(self, data, voxelsize):
+        return ndimage.zoom(data, self.zoom)
+    
+    def completeMetadata(self, im):
+        #im.mdh['Processing.Zoom'] = self.zoom
+        im.mdh['voxelsize.x'] = im.mdh['voxelsize.x']/self.zoom
+        im.mdh['voxelsize.y'] = im.mdh['voxelsize.y']/self.zoom
+        
+        if not self.dimensionality == 'XY':
+            im.mdh['voxelsize.z'] = im.mdh['voxelsize.z']/self.zoom
+
+@register_module('Subsample')         
+class Subsample(Filter):
+    """
+    Crude subsampling (as opposed to zoom, which does interpolation)
+
+    Parameters
+    ----------
+
+    step : interger step to take along each axis
+
+    Notes
+    -----
+    * zoom is isotropic in 3D if ``processFramesIndividually`` is ``False``
+    * zoom only zooms in x and y if ``processFramesIndividually`` is ``True``
+
+    """
+    dimensionality = Enum('XY', 'XYZ', desc='Which image dimensions should the filter be applied to?')
+    
+    step = Int(2)
+
+    _block_safe = False
+    
+    def apply_filter(self, data, voxelsize):
+        if data.ndim == 2:
+            return data[::self.step, ::self.step]
+        else:
+            return data[::self.step, ::self.step, ::self.step,]
+    
+    def completeMetadata(self, im):
+        #im.mdh['Processing.SubsampleStep'] = self.step
+        im.mdh['voxelsize.x'] = im.mdh['voxelsize.x']*self.step
+        im.mdh['voxelsize.y'] = im.mdh['voxelsize.y']*self.step
+        
+        if not self.dimensionality == 'XY':
+            im.mdh['voxelsize.z'] = im.mdh['voxelsize.z']*self.step
+
+
+@register_module('MaskEdges')
+class MaskEdges(Filter):
+    """
+    Sets the edge pixels of an image to zero.
+
+    Used to prevent objects near the edge of an image from being detected if they might not be processed properly in
+    subsequent object measurement or fitting routines.
+
+    Parameters
+    ----------
+
+    widthPxels : the distance from the edge to mask with 0s
+    """
+    dimensionality = Enum('XY', desc='Which image dimensions should the filter be applied to?')
+    
+    widthPixels = Int(10)
+
+    def apply_filter(self, data, voxelsize):
+        dm = data.copy()
+        dm[:self.widthPixels, :] = 0
+        dm[-self.widthPixels:, :] = 0
+        dm[:, :self.widthPixels] = 0
+        dm[:, -self.widthPixels:] = 0
+        return dm
+            
+@register_module('DoGFilter')         
+class DoGFilter(Filter):
+    """Difference of Gaussians
+
+    Blurs the image with 2 different sized Gaussians and subtracts them. Commonly used to detect points or blobs. The
+    smaller Gaussian should be set to match the desired blob size and acts as a noise reduction filter, wheras the
+    larger Gaussian (which is subtracted) can be thought of as a form of local background estimation.
+
+    Parameters
+    ----------
+
+    sigmaX, sigmaY, sigmaZ : std. deviation of the smaller Gaussian.
+
+    sigmaX2, sigmaY2, sigmaZ2 : std. deviations of the larger Gaussian
+
+    Notes
+    -----
+
+    * implemented as 2 calls to `scipy.ndimage.gaussian_filter`
+    * sigmaZ and sigmaZ2 are ignored and a 2D filtering performed if ``processFramesIndividually`` is selected
+
+    """
+    dimensionality = Enum('XY', 'XYZ', desc='Which image dimensions should the filter be applied to?')
+    
+    sigmaY = Float(1.0)
+    sigmaX = Float(1.0)
+    sigmaZ = Float(1.0)
+    
+    sigma2Y = Float(1.0)
+    sigma2X = Float(1.0)
+    sigma2Z = Float(1.0)
+
+    #def __init__(self, **kwargs):
+    #    pass
+    @property
+    def sigmas(self):
+        return [self.sigmaX, self.sigmaY, self.sigmaZ]
+        
+    @property
+    def sigma2s(self):
+        return [self.sigma2X, self.sigma2Y, self.sigma2Z]
+    
+    def apply_filter(self, data, voxelsize):
+        return ndimage.gaussian_filter(data, self.sigmas[:len(data.shape)]) - ndimage.gaussian_filter(data, self.sigma2s[:len(data.shape)])
+    
+    def completeMetadata(self, im):
+        im.mdh['Processing.GaussianFilter.Sigmas'] = self.sigmas
+
+
+
+ 
+#d = {}
+#d.update(locals())
+#moduleList = [c for c in d if _issubclass(c, ModuleBase) and not c == ModuleBase]       

PYME/recipes/fudges.py

@@ -0,0 +1,41 @@
+"""
+This module contains fudges and workarounds - e.g. to deal with poorly formatted input data. They should be regarded as
+temporary hacks until the problems in the upstream data that necessitated them can be fixed.
+
+TLDR - If you need to use modules from this file you're doing it wrong.
+
+"""
+
+from .base import register_module, ModuleBase, Filter
+from .traits import Input, Output, Float, Enum, CStr, Bool, Int, List
+
+import numpy as np
+from PYME.IO import tabular
+
+@register_module('EstimateFrameZFromStepMetadata')
+class EstimateFrameZFromStepMetadata(ModuleBase):
+    """
+    Estimate the z position of a frame from the stepping information in the metadata. Only really useful for HT data
+    streamed from Labview with broken events & even then treat with caution.
+    
+    """
+    inputImage = Input('input')
+    outputName = Output('z_positions')
+    
+    def execute(self, namespace):
+        from PYME.experimental import labview_spooling_hacks
+        from PYME.Analysis import piecewiseMapping
+        
+        im = namespace[self.inputImage]
+        
+        position, frames = labview_spooling_hacks.spoof_focus_from_metadata(im.mdh)
+        
+        frame_nums = np.arange(im.data.shape[2])
+
+        zm = piecewiseMapping.piecewiseMap(0, frames, position, im.mdh['Camera.CycleTime'], xIsSecs=False)
+        
+        z = zm[frame_nums]
+        
+        namespace[self.outputName] = tabular.ColumnSource(z=z)
+        
+        

PYME/recipes/graphing.py

@@ -0,0 +1,108 @@
+import matplotlib.pyplot as plt
+
+
+class plotting_context(object):
+    def __init__(self, backend='SVG'):
+        self._backend = backend
+        
+    def __enter__(self):
+        plt.ioff()
+        self._old_backend = plt.get_backend()
+        plt.switch_backend(self._backend)
+    
+    def __exit__(self, *args):
+        plt.switch_backend(self._old_backend)
+        plt.ion()
+
+class Plot(object):
+    """
+    This is a class that defines a plot method that can be called to generate a matplotlib figure.
+    
+    The Plot class (or any subclass thereof) can be returned by recipe module with the actual plotting deferred until
+    the plot() method is called. This facilitates the use of different matplotlib backends (as appropriate) depending
+    on the context in which the recipe is running.
+    
+    The Plot class should either be subclassed with plot() over-ridden, or instantiated with a callable (e.g. a lambda
+    function). This is conceptually similar to how the python Thread class behaves.
+    
+    The plot function defines a number of translators, for use in report templates or output modules
+    
+    """
+    
+    def __init__(self, plot_callable=None):
+        """
+        When the plot method has not been overridden, a callable function should be provided
+         
+        Parameters
+        ----------
+        plot_callable : a callable to generate the plots. Must return a matplotlib figure object
+        """
+        self._plot_callable = plot_callable
+        
+    def plot(self):
+        """
+        Do the plot in whatever context we have activated. Can be over-ridden in derived classes
+        
+        
+        Returns
+        -------
+        
+        a matplotlib figure instance
+
+        """
+        if self._plot_callable is None:
+            raise RuntimeError('plot_callable not defined - either initialize the class with a callable, or over-ride plot method')
+        else:
+            return self._plot_callable()
+            
+    def as_html(self):
+        """
+        
+        Returns
+        -------
+        
+        The plot as an html string using mpld3
+
+        """
+        import mpld3
+        import warnings
+        if warnings.filters[0] == ('always', None, DeprecationWarning, None, 0):
+            #mpld3 has messed with warnings - undo
+            warnings.filters.pop(0)
+        
+        with plotting_context('SVG') as p:
+            f = self.plot()
+
+            ret = mpld3.fig_to_html(f, template_type='simple')
+            plt.close(f)
+
+            return ret
+    
+    def _savefig(self, fig, filename, format='png'):
+        if filename is not None:
+            fig.savefig(filename)
+        else:
+            from io import BytesIO
+            b = BytesIO()
+            fig.savefig(b)
+            return b
+    
+    def as_png(self, filename=None):
+        with plotting_context('agg') as p:
+            f = self.plot()
+        
+            return self._savefig(f, filename, 'png')
+    
+    def as_pdf(self, filename=None):
+        with plotting_context('pdf') as p:
+            f = self.plot()
+            
+            return self._savefig(f, filename, 'pdf')
+    
+    def as_svg(self, filename=None):
+        with plotting_context('svg') as p:
+            f = self.plot()
+        
+            return self._savefig(f, filename, 'svg')
+
+