python-microscopy 25.11.20__cp313-cp313-win_amd64.whl

PYME/misc/VolProj.py

@@ -0,0 +1,144 @@
+#!/usr/bin/python
+##################
+# VolProj.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/>.
+#
+##################
+# import pylab
+import numpy as np
+import matplotlib.cm
+try:
+    from enthought.mayavi import mlab
+except ImportError:
+    from mayavi import mlab
+import os
+import tempfile
+#from PYME.IO.FileUtils.readTiff import read3DTiff
+
+try:
+    import Image
+except ImportError:
+    from PIL import Image
+
+def GrabImage(figure):
+    tfname = os.path.join(tempfile.gettempdir(), 'mvi_out.tif')
+    figure.scene.save_tiff(tfname)
+
+    im = Image.open(tfname)
+
+    ima = np.array(im.getdata()).reshape((im.size[1], im.size[0], 3))
+
+    #im = read3DTiff(tfname).squeeze()
+
+    os.remove(tfname)
+
+    return ima
+
+#COLOURS= [(1., 0., 0.), (0., 1., 0.), ]
+
+
+class Isosurf:
+    def __init__(self,channels, thresholds, pixelsize = (1., 1., 1.)):
+        self.f = mlab.figure()
+
+        self.isos = []
+        self.projs = []
+
+        for im, th, i in zip(channels, thresholds, range(len(channels))):
+            c = mlab.contour3d(im, contours=[th], color = matplotlib.cm.gist_rainbow(float(i)/len(channels))[:3])
+            c.mlab_source.dataset.spacing = pixelsize
+            self.isos.append(c)
+
+            ps = []
+            thf = th*1.5
+
+            pr = im.mean(2)
+            #f = im.max()/pr.max()
+            #pr *= im.max()/pr.max()
+            ps.append(self.drawProjection((255*np.minimum(pr/(1.*thf), 1)).astype('uint8'), 'z', c))
+            pr = im.mean(0)
+            #pr *= im.max()/pr.max()
+            ps.append(self.drawProjection((255*np.minimum(pr/(.6*thf), 1)).astype('uint8'), 'x', c))
+            pr = im.mean(1)
+            #pr *= im.max()/pr.max()
+            ps.append(self.drawProjection((255*np.minimum(pr/(.8*thf), 1)).astype('uint8'), 'y', c))
+
+            self.projs.append(ps)
+
+
+
+
+    def drawProjection(self, im, axis, c):
+        gp = mlab.pipeline.grid_plane(c)
+        gp.actor.property.ambient=1.0
+        gp.actor.property.diffuse=0.0
+        #gp.visible = False
+        gp.grid_plane.axis = axis
+        gp.actor.enable_texture = True
+        gp.actor.texture_source_object = mlab.pipeline.scalar_field(im)
+        gp.actor.tcoord_generator_mode = 'plane'
+        gp.actor.property.representation = 'surface'
+
+        return gp
+
+    def ShowProj(self, chan, show=True):
+        if chan < len(self.projs):
+            for p in self.projs[chan]:
+                p.visible = show
+
+    def ShowIso(self, show=True):
+        for c in self.isos:
+            c.visible = show
+
+    def Grab(self):
+        return GrabImage(self.f)
+
+    def GrabComp(self):
+        for i in range(len(self.projs)):
+            self.ShowProj(i, False)
+
+        surfs = self.Grab()
+        mask = (surfs == 127).prod(2)
+
+        ps = []
+        psmask = mask.copy()
+
+        self.ShowIso(False)
+
+        for i in range(min(len(self.projs), 3)):
+            self.ShowProj(i, True)
+            p_i = self.Grab()
+            psmask *= (p_i ==127).prod(2)
+            ps.append(p_i[:,:,i])
+            self.ShowProj(i, False)
+
+        self.ShowIso(True)
+        for i in range(len(self.projs)):
+            self.ShowProj(i, True)
+
+        im = 0*surfs
+
+        for i in range(3):
+            if i < len(ps):
+                im_i = ps[i]*mask
+            else:
+                im_i = 127*psmask
+            im[:,:,i] = im_i + surfs[:,:,i]*(1-mask)
+
+
+        return im

PYME/misc/__init__.py

@@ -0,0 +1,25 @@
+#!/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/>.
+#
+################
+"""
+A dumping place for utility functions I don't know where else to put.
+"""

PYME/misc/aligned_array.py

@@ -0,0 +1,10 @@
+"""
+Allow creation of aligned numpy arrays. A wrapper around fftw3f.create_aligned_array on python2,
+around pyfftw.empty_aligned on python 3.
+
+"""
+
+try:
+    from fftw3f import create_aligned_array
+except ImportError:
+    from pyfftw import empty_aligned as create_aligned_array

PYME/misc/aniso.py

@@ -0,0 +1,29 @@
+#from http://mri.brechmos.org/2010/01/19/anisotropic-diffusion-image-filtering-in-mri/
+#from pylab import *
+import numpy as np
+
+def aniso(v, kappa=-1, N=1):
+
+        if kappa == -1:
+                kappa = np.prctile(v, 40)
+
+        vf = v.copy()
+
+        for ii in range(N):
+                dE = -vf + np.roll(vf,-1,0)
+                dW = vf - np.roll(vf,1,0)
+
+                dN = -vf + np.roll(vf,-1,1)
+                dS = vf - np.roll(vf,1,1)
+
+                if len(v.shape) > 2:
+                        dU = -vf + np.roll(vf,-1,2)
+                        dD = vf - np.roll(vf,1,2)
+
+                vf = vf + \
+                        3./28. * ((np.exp(- (abs(dE) / kappa)**2 ) * dE) - (np.exp(- (abs(dW) / kappa)**2 ) * dW)) + \
+                        3./28. * ((np.exp(- (abs(dN) / kappa)**2 ) * dN) - (np.exp(- (abs(dS) / kappa)**2 ) * dS))
+                if len(v.shape) > 2:
+                        vf += 1./28. * ((np.exp(- (abs(dU) / kappa)**2 ) * dU) - (np.exp(- (abs(dD) / kappa)**2 ) * dD))
+
+        return vf

PYME/misc/big_sur_fix.py

@@ -0,0 +1,20 @@
+# from bht at https://stackoverflow.com/questions/63475461/unable-to-import-opengl-gl-in-python-on-macos
+try:
+    import OpenGL as ogl
+    try:
+        import OpenGL.GL   # this fails in <=2020 versions of Python on OS X 11.x
+    except ImportError:
+        print('Drat, patching for Big Sur')
+        from ctypes import util
+        orig_util_find_library = util.find_library
+        def new_util_find_library( name ):
+            res = orig_util_find_library( name )
+            if res: return res
+            if name == 'c':
+                # work-around for ifaddr
+                # exploits the fact that ctypes.CDLL(None) opens the System library
+                return None
+            return '/System/Library/Frameworks/'+name+'.framework/'+name
+        util.find_library = new_util_find_library
+except ImportError:
+    pass

PYME/misc/check_for_updates.py

@@ -0,0 +1,139 @@
+from PYME import version
+from PYME import config
+import os
+import json
+import logging
+import subprocess
+import datetime
+logger = logging.getLogger(__name__)
+import shelve
+
+update_info_fn = os.path.join(config.user_config_dir, 'update.shv')
+
+update_messages = {
+    'git' : '''You have a development install, to update, execute the following in the repository root folder:
+    
+    git pull origin master
+    python setup.py build_ext -i
+    
+NB: because this is a developent install, this will update to the bleeding edge (i.e. past the last official release)''',
+    
+    'pypi' : '''You have a pip install, to update, close all PYME programs and execute the following in the python
+prompt for your PYME virtual environment.
+    
+    pip install python-microscopy -U''',
+    
+    'conda' : '''You have a conda install, to update, close all PYME programs and execute the following in the python
+prompt for your PYME environment.
+    
+    conda update -C david_baddeley -S python-microscopy'''
+}
+
+# notes: - the explicit channel specification may not strictly be required, but is the most robust option
+#        - the -S option does a fast solve and doesn't aggressively update packages (i.e. only updates dependencies if
+#          explicitly forced to by a pin). This will hopefully a) make it faster and b) stop us breaking too may conda environments.
+
+
+update_available = None
+update_ver = None
+
+def guess_install_type():
+    # check for git
+    pyme_parent_dir = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
+    print(pyme_parent_dir)
+    
+    if os.path.exists(os.path.join(pyme_parent_dir, '.git')):
+        logger.info('Detected a .git folder, assuming a development install')
+        return 'git'
+    
+    # check for conda package
+    try:
+        pkg_info = json.loads(subprocess.check_output(['conda', 'list', '--json', 'python-microscopy']))
+    except FileNotFoundError:
+        logger.exception('Could not find `conda`\nPYME is not installed in a conda environment')
+        return 'unknown'
+    
+    chan = pkg_info[0]['channel']
+    
+    if chan == 'pypi':
+        logger.info('Detected a pip install')
+        return 'pip'
+    elif chan == 'david_baddeley':
+        logger.info('Detected a conda install')
+        return 'conda'
+    
+
+def check_for_updates(gui=True, force=False):
+    global update_available, update_ver
+    import requests
+    import packaging.version
+    
+    with shelve.open(update_info_fn) as s:
+        next_update_time = s.get('last_update_check', datetime.datetime.fromtimestamp(0)) + datetime.timedelta(days=1)
+        t = datetime.datetime.now()
+    
+        if not(force or (config.get('check_for_updates', True) and t > next_update_time)):
+            # respect config setting and bail
+            # called with force=True when called from the menu (i.e. explicitly rather than automatically)
+            return
+
+        s['last_update_check'] = t
+    
+    logger.info('Checking for updates ...')
+    try:
+        version_info = requests.get('http://www.python-microscopy.org/current_version.json').json()
+        
+        update_ver = version_info['version']
+        
+        if packaging.version.parse(update_ver) > packaging.version.parse(version.version):
+            update_msg = 'A new version of PYME is available\nYou have version %s, the current version is %s' % (version.version, update_ver)
+            logger.info(update_msg)
+            
+            install_type = guess_install_type()
+            logger.info(update_messages[install_type])
+            
+            update_available = True
+            
+            if gui:
+                gui_prompt_update()
+                
+        else:
+            update_available = False
+        
+    except:
+        logger.exception('Error getting info on updates')
+    
+    
+def gui_prompt_update():
+    import wx
+    
+    # make sure there is an update available
+    assert update_available
+    
+    install_type = guess_install_type()
+    update_msg = 'A new version of PYME is available\nYou have version %s, the current version is %s' % (version.version, update_ver)
+    msg = update_msg + '\n\n' + update_messages[install_type]
+    wx.MessageBox(msg, 'A PYME update is available')
+    
+    with shelve.open(update_info_fn) as s:
+        s['last_update_offered'] =  update_ver
+    
+    
+def gui_prompt_once():
+    if update_available is None:
+        #make doubly sure we've checked
+        check_for_updates(False)
+        
+        
+    if update_available:
+        with shelve.open(update_info_fn) as s:
+            last_offered = s.get('last_update_offered', None)
+            
+        if (last_offered != update_ver):
+            gui_prompt_update()
+        
+        
+check_for_updates(False)
+        
+        
+

PYME/misc/colormaps.py

@@ -0,0 +1,199 @@
+#!/usr/bin/python
+
+###############
+# extraCMaps.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/>.
+#
+################
+import matplotlib.colors as colors
+from matplotlib import cm as mp_cm
+from collections import OrderedDict
+
+#import matplotlib as mpl
+# import pylab
+import numpy as np
+
+class CMapDict(OrderedDict):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.solid_cmaps = []
+
+    def __getattr__(self, key):
+        try:
+            return self[key]
+        except KeyError:
+            raise AttributeError('No attribute %s' % key)
+
+    def register_cmap(self, name, solid=False):
+        """A decorator"""
+
+        def _reg_cmap(func):
+            func.name = name
+            self[name] = func
+
+            if solid:
+                self.solid_cmaps.append(name)
+
+            return func
+    
+        return _reg_cmap
+
+    @property
+    def cmapnames(self):
+        return self.keys()
+
+    @property
+    def graded_cmaps(self):
+        return [k for k in self.keys() if not k in self.solid_cmaps]
+
+    
+
+try:
+    # try version 3.5 way first ....
+    from matplotlib import colormaps
+    _cmd = dict(colormaps)
+except ImportError:
+    # older matplotlib - note this generates a deprecation warning on 3.4.2 as it does not appear to have matplotlib.colormaps
+    # but still does not want you to access the colourmap dictionary (cmap_d) directly.
+    if 'cmap_d' in dir(mp_cm):
+        _cmd = mp_cm.cmap_d
+    elif 'cmapnames' in dir(mp_cm):
+        _cmd = {k: mp_cm.__dict__[k] for k in mp_cm.cmapnames}
+    else:
+        _cmd = {k: mp_cm.__dict__[k] for k in mp_cm._cmapnames}
+
+cm = CMapDict(_cmd)
+
+_r = {'red':((0.,0.,0.), (1.,1.,1.)), 'green':((0.,0,0), (1.,0.,0.)), 'blue':((0.,0.,0.), (1.,0.,0.))}
+_g = {'green':((0.,0.,0.), (1.,1.,1.)), 'red':((0.,0,0), (1.,0.,0.)), 'blue':((0.,0.,0.), (1.,0.,0.))}
+_b = {'blue':((0.,0.,0.), (1.,1.,1.)), 'green':((0.,0,0), (1.,0.,0.)), 'red':((0.,0.,0.), (1.,0.,0.))}
+
+_c = {'blue':((0.,0.,0.), (1.,1.,1.)), 'green':((0.,0,0), (1.,1.,1.)), 'red':((0.,0.,0.), (1.,0.,0.))}
+_m = {'blue':((0.,0.,0.), (1.,1.,1.)), 'red':((0.,0,0), (1.,1.,1.)), 'green':((0.,0.,0.), (1.,0.,0.))}
+_y = {'red':((0.,0.,0.), (1.,1.,1.)), 'green':((0.,0,0), (1.,1.,1.)), 'blue':((0.,0.,0.), (1.,0.,0.))}
+
+_hsv_part = {'red':   ((0., 1., 1.),(0.25, 1.000000, 1.000000),
+                       (0.5, 0, 0),
+                       (1, 0.000000, 0.000000)),
+             'green': ((0., 0., 0.),(0.25, 1, 1),
+                       (.75, 1.000000, 1.000000),
+                       (1.0, 0.2, 0.2)),
+             'blue':  ((0., 0., 0.),(0.5, 0.000000, 0.000000),
+                       (0.75, 1, 1),
+                       (1.0, 1, 1))}
+
+ndat = {'r':_r, 'g':_g, 'b':_b, 'c':_c, 'm':_m, 'y':_y, 'hsp': _hsv_part}
+
+# Newer versions of matplotlib use _LUTSIZE
+try:
+    lutsize = mp_cm.LUTSIZE
+except AttributeError:
+    lutsize = mp_cm._LUTSIZE
+
+cm.update({cmapname: colors.LinearSegmentedColormap(cmapname, ndat[cmapname], lutsize) for cmapname in ndat.keys()})
+
+#solid colour colormaps for VisGUI multichannel and isosurface display
+@cm.register_cmap('SolidRed', solid=True)
+def Red(data):
+    z = np.ones_like(data)
+    return np.stack([z, 0*z, 0*z, z], -1)
+
+@cm.register_cmap('SolidGreen', solid=True)
+def Green(data):
+    z = np.ones_like(data)
+    return np.stack([0*z, z, 0*z, z], -1)
+
+@cm.register_cmap('SolidBlue', solid=True)
+def Blue(data):
+    z = np.ones_like(data)
+    return np.stack([0*z, 0*z, z, z], -1)
+
+@cm.register_cmap('SolidCyan', solid=True)
+def Cyan(data):
+    z = np.ones_like(data)
+    return np.stack([0*z, z, z, z], -1)
+
+@cm.register_cmap('SolidMagenta', solid=True)
+def Magenta(data):
+    z = np.ones_like(data)
+    return np.stack([z, 0*z, z, z], -1)
+
+@cm.register_cmap('SolidYellow', solid=True)
+def Yellow(data):
+    z = np.ones_like(data)
+    return np.stack([z, z, 0*z, z], -1)
+
+@cm.register_cmap('SolidWhite', solid=True)
+def White(data):
+    z = np.ones_like(data)
+    return np.stack([z, z, z, z], -1)
+
+@cm.register_cmap('labeled')
+def labeled(data):
+    return (data > 0).reshape(list(data.shape) +  [1])*cm.gist_rainbow(data % 1)
+
+# @cm.register_cmap('flow_gray')
+# def flow_gray(data):
+#     v = ((data > 0)*(data < 1)).reshape(list(data.shape) +  [1])*cm.gray(data)
+#     v += (data == 0).reshape(list(data.shape) + [1]) * np.array([0, 1., 0, 0]).reshape(list(np.ones(data.ndim) + [3]))
+#     v += (data == 1).reshape(list(data.shape) + [1]) * np.array([1., 0, 1., 0]).reshape(list(np.ones(data.ndim) + [3]))
+#     return v
+
+# @cm.register_cmap('fast_grey')
+# def fast_grey(data):
+#     return data[:,:,None]*np.ones((1,1,4))
+
+def grey_overflow(underflowcol = 'magenta', overflowcol = 'lime', percentage=5, greystart=0.1):
+    if percentage < 1:
+        percentage = 1
+    if percentage > 15:
+        percentage = 15
+
+    ucolrgb = colors.hex2color(colors.cnames[underflowcol])
+    ocolrgb = colors.hex2color(colors.cnames[overflowcol])
+    p = 0.01 * percentage
+
+    def r(rgb):
+        return rgb[0]
+
+    def g(rgb):
+        return rgb[1]
+
+    def b(rgb):
+        return rgb[2]
+    
+    grey_data = {'red':   [(0, r(ucolrgb), r(ucolrgb)),
+                          (p, r(ucolrgb), greystart),
+                          (1.0-p, 1.0, r(ocolrgb)),
+                          (1.0, r(ocolrgb), r(ocolrgb))],
+                'green': [(0, g(ucolrgb), g(ucolrgb)),
+                          (p, g(ucolrgb), greystart),
+                          (1.0-p, 1.0, g(ocolrgb)),
+                          (1.0, g(ocolrgb), g(ocolrgb))],
+                'blue':  [(0, b(ucolrgb), b(ucolrgb)),
+                          (p, b(ucolrgb), greystart),
+                          (1.0-p, 1.0, b(ocolrgb)),
+                          (1.0, b(ocolrgb), b(ocolrgb))]}
+
+    cm_grey2 = colors.LinearSegmentedColormap('grey_overflow', grey_data)
+    return cm_grey2
+
+cm['grey_overflow'] = grey_overflow(percentage=2.5,greystart=0.125)
+
+#cm.cmapnames.sort()