PYME-extra 1.0.4.post0__py3-none-any.whl

PYMEcs/misc/guiMsgBoxes.py

@@ -0,0 +1,27 @@
+import wx
+
+# a few simple message box utility functions
+
+def YesNo(parent, question, caption = 'Yes or no?'):
+    dlg = wx.MessageDialog(parent, question, caption, wx.YES_NO | wx.ICON_QUESTION)
+    result = dlg.ShowModal() == wx.ID_YES
+    dlg.Destroy()
+    return result
+
+
+def Info(parent, message, caption = 'Python Microscopy Environment'):
+    dlg = wx.MessageDialog(parent, message, caption, wx.OK | wx.ICON_INFORMATION)
+    dlg.ShowModal()
+    dlg.Destroy()
+
+    
+def Warn(parent, message, caption = 'Warning!'):
+    dlg = wx.MessageDialog(parent, message, caption, wx.OK | wx.ICON_WARNING)
+    dlg.ShowModal()
+    dlg.Destroy()
+
+
+def Error(parent, message, caption = 'Error!'):
+    dlg = wx.MessageDialog(parent, message, caption, wx.OK | wx.ICON_ERROR)
+    dlg.ShowModal()
+    dlg.Destroy()

PYMEcs/misc/mapUtils.py

@@ -0,0 +1,230 @@
+from PYME.localization.remFitBuf import CameraInfoManager
+import PYME.Analysis.gen_sCMOS_maps as gmaps
+from PYME.IO.MetaDataHandler import NestedClassMDHandler
+from PYME.IO.image import ImageStack
+from PYME.DSView import ViewIm3D
+from PYME.IO.FileUtils import nameUtils
+import numpy as np
+
+import logging
+logger = logging.getLogger(__name__)
+
+defaultCalibrationDir = nameUtils.getCalibrationDir('',create=False)
+
+def defaultMapName(source, createPath=False, calibrationDir=defaultCalibrationDir):
+    resname = source.mdh.getOrDefault('Analysis.resultname',None)
+    if resname is None:
+        return None
+
+    if resname == 'mean':
+        if source.mdh.getOrDefault('Analysis.FlatField',False):
+            maptype = 'flatfield'
+        else:
+            maptype = 'dark'
+    else:
+        maptype = 'variance'
+
+    mapname = gmaps.mkDefaultPath(maptype, source.mdh, create=createPath, calibrationDir=calibrationDir)
+    return mapname
+
+# return a list of existing camera directories that have tif files inside (assuming these are camera maps)
+def installedCams(calibrationDir=defaultCalibrationDir):
+    from glob import glob
+    import os
+
+    camdirs = []
+    for (dirpath, dirnames, filenames) in os.walk(calibrationDir):
+        camdirs.extend(dirnames)
+        break
+    fulldirs = [os.path.join(calibrationDir,cdir) for cdir in camdirs]
+    validdirs = [cdir for cdir in fulldirs if glob(os.path.join(cdir, '*.tif'))]
+
+    return validdirs
+
+
+# source passed as PYME ImageStack
+def install_map(source, calibrationDir=defaultCalibrationDir):
+    """Installs a map file to a calibration directory. By default uses the system claibration directory."""
+
+    import os
+    if source.mdh.getOrDefault('Analysis.name', '') != 'mean-variance':
+        msg = 'map %s, Analysis.name is not equal to "mean-variance" - probably not a map' % source.filename
+        return msg
+
+    validROIHeight = source.mdh.getOrDefault('Analysis.valid.ROIHeight',
+                                             source.mdh['Camera.ROIHeight'])
+    validROIWidth = source.mdh.getOrDefault('Analysis.valid.ROIWidth',
+                                             source.mdh['Camera.ROIWidth'])
+    if not (validROIHeight == source.mdh['Camera.ROIHeight']
+            and validROIWidth == source.mdh['Camera.ROIWidth']):
+        msg = 'Partial (ROI based) maps cannot be installed to a calibration directory'
+        return msg
+
+    if source.mdh.getOrDefault('Analysis.isuniform', False):
+        msg = 'Uniform maps cannot be installed to ba calibration directory'
+        return msg
+
+    if source.mdh['Analysis.resultname'] == 'mean':
+        if source.mdh.getOrDefault('Analysis.FlatField',False):
+            maptype = 'flatfield'
+        else:
+            maptype = 'dark'
+    else:
+        maptype = 'variance'
+
+    mapname = gmaps.mkDefaultPath(maptype, source.mdh, create=True, calibrationDir=calibrationDir)
+    if os.path.isfile(mapname):
+        msg = 'map %s exists, not overwriting' % mapname
+        return msg
+    
+    source.Save(filename=mapname)
+    return None
+    
+# attempt to install a map in a calibration dir but check a few things
+# 1) does it have the .tif extension?
+# 2) can it be opened as a tiffstack
+# 3) if all ok so far pass on to install_map which does additional checks; note that
+#    this function does not overwrite existing maps at the destination
+def checkAndInstallMap(mapf, calibrationDir=defaultCalibrationDir):
+    import os
+    inst = 0
+    
+    ext = os.path.splitext(mapf)[-1].lower()
+    if ext != ".tif":
+        msg = 'asked to install %s, not a tif extension' % mapf
+        return (inst, msg)
+    try:
+        source = ImageStack(filename=mapf)
+    except:
+        msg = 'asked to install %s, could not open as PYME ImageStack, not a map?' % mapf
+        return (inst, msg)
+
+    msg = install_map(source, calibrationDir=calibrationDir)
+    if msg is None:
+        msg = 'installed map %s in default location' % mapf
+        msg += "\n\t-> %s" % defaultMapName(source, calibrationDir=calibrationDir)
+        inst = 1
+
+    return (inst, msg)
+
+
+# install maps, potentially several
+# if fromfile is a directory attempt to install all maps below that directory
+# if fromfile is a file, attempt to install that single file
+def installMapsFrom(fromfile, calibrationDir=defaultCalibrationDir):
+    from glob import glob
+    import os
+    
+    msgs = []
+    ntotal = 0
+    if os.path.isdir(fromfile):
+        # this is a directory, walk it
+        msgs.append("Installing maps from directory %s -> %s Folder\n" % (fromfile,calibrationDir))
+        mapfiles = [y for x in os.walk(fromfile) for y in glob(os.path.join(x[0], '*.tif'))]
+        for mapf in mapfiles:
+            ninst, msg = checkAndInstallMap(mapf, calibrationDir=calibrationDir)
+            ntotal += ninst
+            msgs.append(msg)
+    else:
+        ninst, msg = checkAndInstallMap(fromfile, calibrationDir=calibrationDir)
+        ntotal = 1
+        msgs.append(msg)
+    msgs.append("\ninstalled %d maps" % ntotal)
+    return ntotal, "\n".join(msgs)
+
+    
+def getInstalledMapList():
+    from glob import glob
+    import os
+    rootdir = defaultCalibrationDir
+    result = [y for x in os.walk(rootdir) for y in glob(os.path.join(x[0], '*.tif'))]
+
+    return result
+
+
+def check_mapexists(mdh, type = 'dark'):
+    import os
+    if type == 'dark':
+        id = 'Camera.DarkMapID'
+    elif type == 'variance':
+        id = 'Camera.VarianceMapID'
+    elif type == 'flatfield':
+        id = 'Camera.FlatfieldMapID'
+    else:
+        raise RuntimeError('unknown map type %s' % type)
+        
+
+    mPath = mdh.getOrDefault(id,'')
+    defPath = gmaps.mkDefaultPath(type,mdh,create=False)
+    if os.path.exists(mPath):
+        return mPath
+    elif os.path.exists(defPath):
+        mdh[id] = defPath
+        return defPath
+    else:
+        mdh[id] = ''
+        return None
+
+def mk_compositeMap(sourcemap):
+    # make new composite map using sourcemap to populate
+    # check source is a map
+    # composite map has first channel with map data, second channel is mask where map is valid
+    # returns composite map (identified by its metadata)
+    pass
+
+def addMap2composite(map,compMap):
+    # insert map according to valid ROI into composite map
+    # update the valid channel accordingly
+    # possibly perform a number of checks
+    pass
+
+def export_mapFromComposite(compMap):
+    # export a normal map from the composite map
+    # in the exported map we set the valid ROI to the whole chip area
+    # return as image?
+    pass
+
+import os
+
+def _getDefaultMap(ci,mdh,maptype = 'dark', return_loadedmdh = False):
+    # logic: try map in default calibration dir first
+    #        if not present just return default value
+    mapname = gmaps.mkDefaultPath(maptype, mdh, create=False)
+    mdh2 = NestedClassMDHandler(mdh)
+    logger.debug("checking map file %s" % mapname)
+    
+    if maptype == 'dark':
+        id = 'Camera.DarkMapID'
+    elif maptype == 'variance':
+        id = 'Camera.VarianceMapID'
+    elif maptype == 'flatfield':
+        id = 'Camera.FlatfieldMapID'
+    else:
+        raise RuntimeError('unknown map type %s' % type)
+
+    if os.path.isfile(mapname):
+        mdh2[id] = mapname
+    else:
+        mdh2[id] = ''
+        logger.debug("map file %s does not exist" % mapname)
+
+    if maptype == 'dark':
+        theMap = ci.getDarkMap(mdh2)
+    elif maptype == 'variance':
+        theMap = ci.getVarianceMap(mdh2)
+    elif maptype == 'flatfield':
+        theMap = ci.getFlatfieldMap(mdh2)
+
+    if return_loadedmdh:
+        return (theMap,mdh2)
+    else:
+        return theMap
+
+def get_dark_default(ci,mdh):
+    return _getDefaultMap(ci,mdh,maptype = 'dark')
+
+def get_variance_default(ci,mdh):
+    return _getDefaultMap(ci,mdh,maptype = 'variance')
+    
+def get_flatfield_default(ci,mdh):
+    return _getDefaultMap(ci,mdh,maptype = 'flatfield')

PYMEcs/misc/matplotlib.py

@@ -0,0 +1,136 @@
+import matplotlib.pyplot as plt
+import numpy as np
+from numbers import Number
+
+def figuredefaults(fontsize=10,linewidth=1.5):
+    plt.rcParams['axes.linewidth'] = linewidth
+    plt.rcParams['xtick.major.width'] = linewidth
+    plt.rcParams['ytick.major.width'] = linewidth
+    plt.rcParams['font.family']='arial'
+    plt.rcParams['font.size'] = fontsize
+    plt.rcParams['svg.fonttype'] = 'none'
+
+def boxswarmplot(df,width=0.4,annotate_means=False,annotate_medians=False,showmeans=True,
+                 meanprops=None,ax=None,swarmsize=7,swarmalpha=None,format="%.1f",
+                 showpoints=True,strip=False,**kwargs):
+    import seaborn as sns
+    if meanprops is None:
+        meanprops={'marker':'o',
+                    'markerfacecolor':'white', 
+                    'markeredgecolor':'black',
+                    'markersize':'8'}
+    flierprops = dict(marker='.', markerfacecolor='none', markersize=0, linestyle='none')
+    colours = ['#72a4cdff'] * df.shape[1]
+    bp = sns.boxplot(df,boxprops={'facecolor': 'none'},width=width,showmeans=showmeans,meanprops=meanprops,ax=ax,flierprops=flierprops,**kwargs)
+    if showpoints:
+        if strip:
+            sns.stripplot(df,size=swarmsize,palette=colours,ax=ax,alpha=swarmalpha)
+        else:
+            sns.swarmplot(df,size=swarmsize,palette=colours,ax=ax,alpha=swarmalpha)
+    if annotate_medians:
+        meds = df.median().values
+        for i,xtick in enumerate(bp.get_xticks()):
+            bp.text(xtick-0.5*width-0.1,meds[i],format % meds[i], 
+                    horizontalalignment='center',verticalalignment='center',
+                    size='x-small',color='black',weight='semibold')
+    if annotate_means:
+        means = df.mean().values
+        for i,xtick in enumerate(bp.get_xticks()):
+            bp.text(xtick+0.5*width+0.1,means[i],format % means[i], 
+                    horizontalalignment='center',verticalalignment='center',
+                    size='x-small',color='g',weight='semibold')
+    return bp
+
+def violinswarmplot(df,width=0.8,annotate_means=False,annotate_medians=False,
+                    ax=None,swarmsize=7,swarmalpha=None,format="%.1f",strip=False,
+                    annotate_width=0.4,showpoints=True,**kwargs):
+    import seaborn as sns
+    vp = sns.violinplot(df, ax=ax, color="0.95", width=width, **kwargs)
+    colours = ['#72a4cdff'] * df.shape[1]
+    if showpoints:
+        if strip:
+            sns.stripplot(df,size=swarmsize,palette=colours,ax=ax,alpha=swarmalpha, jitter=True, zorder=1)
+        else:
+            sns.swarmplot(df,size=swarmsize,palette=colours,ax=ax,alpha=swarmalpha, zorder=1)
+   
+    if annotate_medians:
+        meds = df.median().values
+        for i,xtick in enumerate(vp.get_xticks()):
+            vp.text(xtick-0.5*annotate_width-0.1,meds[i],format % meds[i], 
+                    horizontalalignment='center',verticalalignment='center',
+                    size='x-small',color='black',weight='semibold')
+    if annotate_means:
+        means = df.mean().values
+        for i,xtick in enumerate(vp.get_xticks()):
+            vp.text(xtick+0.5*annotate_width+0.1,means[i],format % means[i], 
+                    horizontalalignment='center',verticalalignment='center',
+                    size='x-small',color='g',weight='semibold')
+    return vp
+
+
+# deprecated
+def _scattered_boxplot(ax, x, notch=None, sym=None, vert=None, whis=None, positions=None,
+                      widths=None, patch_artist=None, bootstrap=None, usermedians=None, conf_intervals=None,
+                      meanline=None, showmeans=None, showcaps=None, showbox=None,
+                      showfliers="unif", hide_points_within_whiskers=False,
+                      boxprops=None, labels=None, flierprops=None, medianprops=None, meanprops=None,
+                      capprops=None, whiskerprops=None, manage_ticks=True, autorange=False, zorder=None, *, data=None):
+    if showfliers=="classic":
+        classic_fliers=True
+    else:
+        classic_fliers=False
+    bp_dict = ax.boxplot(x, notch=notch, sym=sym, vert=vert, whis=whis, positions=positions, widths=widths,
+                         patch_artist=patch_artist, bootstrap=bootstrap, usermedians=usermedians,
+                         conf_intervals=conf_intervals, meanline=meanline, showmeans=showmeans, showcaps=showcaps, showbox=showbox,
+                         showfliers=classic_fliers,
+                         boxprops=boxprops, labels=labels, flierprops=flierprops, medianprops=medianprops, meanprops=meanprops,
+                         capprops=capprops, whiskerprops=whiskerprops, manage_ticks=manage_ticks, autorange=autorange, zorder=zorder,data=data)
+    N=len(x)
+    datashape_message = ("List of boxplot statistics and `{0}` "
+                             "values must have same the length")
+    # check position
+    if positions is None:
+        positions = list(np.ones_like(x))
+    elif len(positions) != N:
+        raise ValueError(datashape_message.format("positions"))
+
+    positions = np.array(positions)
+    if len(positions) > 0 and not isinstance(positions[0], Number):
+        raise TypeError("positions should be an iterable of numbers")
+
+    # width
+    if widths is None:
+        widths = [np.clip(0.15 * np.ptp(positions), 0.15, 0.5)] * N
+    elif np.isscalar(widths):
+        widths = [widths] * N
+    elif len(widths) != N:
+        raise ValueError(datashape_message.format("widths"))
+
+    if hide_points_within_whiskers:
+        import matplotlib.cbook as cbook
+        from matplotlib import rcParams
+        if whis is None:
+            whis = rcParams['boxplot.whiskers']
+        if bootstrap is None:
+            bootstrap = rcParams['boxplot.bootstrap']
+        bxpstats = cbook.boxplot_stats(x, whis=whis, bootstrap=bootstrap,
+                                       labels=labels, autorange=autorange)
+    for i in range(N):
+        if hide_points_within_whiskers:
+            xi=bxpstats[i]['fliers']
+        else:
+            xi=x[i]
+        if showfliers=="unif":
+            jitter=np.random.uniform(-widths[i]*0.2,widths[i]*0.2,size=np.size(xi))
+        elif showfliers=="normal":
+            jitter=np.random.normal(loc=0.0, scale=widths[i]*0.1,size=np.size(xi))
+        elif showfliers==False or showfliers=="classic":
+            return
+        else:
+            raise NotImplementedError("showfliers='"+str(showfliers)+"' is not implemented. You can choose from 'unif', 'normal', 'classic' and False")
+
+        ax.scatter(positions[i]+jitter,xi,alpha=0.2,marker="o", facecolors='none', edgecolors="k")
+
+    return bp_dict
+
+# setattr(plt.Axes, "scattered_boxplot", scattered_boxplot)

PYMEcs/misc/rectsFromSVG.py

@@ -0,0 +1,182 @@
+# code for coordinate algebra, specifically rotations given by the `rotation` transform
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+def vlen(v):
+    return np.sqrt(v[0]**2+v[1]**2)
+
+def rmat_ang(angle):
+    theta = np.radians(-angle)
+    # note: tests suggest that for the svg angle we use the *negative* angle for this matrix
+    c, s = np.cos(theta), np.sin(theta)
+    R = np.array(((c, -s), (s, c)))
+    return R
+
+def vec(x,y):
+    return np.array((x,y))
+
+def transform_rot(x,y,angle):
+    return vec(x,y).dot(rmat_ang(angle))
+
+# the code below parses out the rectangles from an SVG
+# all other elements are ignored
+# for the identified rectangles the code obtains the revelant parameters by retrieveal
+# and string conversion to float
+
+import re
+
+# NOTE: the argument 'svg' is assumed to be a parsed svg file
+# obtained with something like
+#
+# import xml.etree.ElementTree as ET
+# svg = ET.parse('RyR-pattern-simulation-Ashagri14-Fig1.svg')
+def find_svgrects(svg):
+    root = svg.getroot()
+    group = root.find('{http://www.w3.org/2000/svg}g')
+    rects = group.findall('{http://www.w3.org/2000/svg}rect')
+    return rects
+
+def parse_rect(rect):
+    # ['style', 'id', 'width', 'height', 'x', 'y', 'transform']
+    prect = {}
+    for key in ['width', 'height', 'x', 'y']:
+        prect[key] = float(rect.get(key))
+    for key in ['style', 'id']:
+        prect[key] = rect.get(key)
+    if rect.get('transform') is not None:
+        m = re.search('^rotate\(([-+]*[\d.]+)\)',rect.get('transform'))
+        if m:
+            prect['rot_angle'] = float(m.group(1))
+    return prect
+    
+def parse_rects(rects):
+    return [parse_rect(rect) for rect in rects]
+
+# code to display parsed rectangles via matplotlib
+# we need this to check that things work as anticipated
+
+from matplotlib.collections import PatchCollection
+from matplotlib.patches import Rectangle
+
+def transformed_rect(prect):
+    angle = prect.get('rot_angle',0)
+    r_origin = list(transform_rot(prect['x'],prect['y'],angle))
+    return Rectangle(r_origin, prect['width'], prect['height'], angle=angle)   
+
+def make_matplotrects(prects):
+    mprects = [transformed_rect(prect) for prect in prects]
+    return mprects
+
+def plot_rects(ax,matplotrects,alpha=1.0):
+    # Create patch collection with specified colour/alpha
+    pc = PatchCollection(matplotrects, facecolor='r', alpha=alpha,
+                         edgecolor='black',linewidth=1.0)
+
+    # Add collection to axes
+    ax.add_collection(pc,autolim=True)
+    
+    # try to fix axes limits
+    # this does not seem to work as unticipated
+    # fine to ignore for now (because it does nothing)...
+    ax._unstale_viewLim()
+    datalim = pc.get_datalim(ax.transData)
+    print(datalim.get_points())
+    points = datalim.get_points()
+    if not np.isinf(datalim.minpos).all():
+        # By definition, if minpos (minimum positive value) is set
+        # (i.e., non-inf), then min(points) <= minpos <= max(points),
+        # and minpos would be superfluous. However, we add minpos to
+        # the call so that self.dataLim will update its own minpos.
+        # This ensures that log scales see the correct minimum.
+        points = np.concatenate([points, [datalim.minpos]])
+    ax.update_datalim(points)
+    return points
+
+# function to scale everything to be accurate in nm
+# below we assume that rectangles should be 27 nm x 27 nm
+def scale(prect,factor):
+    srect = prect.copy()
+    for key in ['width', 'height', 'x', 'y']:
+        srect[key] = prect[key]*factor
+    return srect
+
+# code to get label points from scaled prect
+def points_from_sprect(sprect,mode='default'):
+    angle = sprect.get('rot_angle',0)
+    origin = transform_rot(sprect['x'],sprect['y'],angle)
+    if mode == 'default':
+        corner_points = np.array([[3.5,3.5], [23.5,3.5], [23.5, 23.5], [3.5, 23.5]]) # anti-clock wise
+    elif mode == 'RyR-T1366':
+        corner_points = np.array([[6,5], [21.6,6.6], [20.2,22.5], [4.8,20.5]])
+    elif mode == 'RyR-T2023':
+        corner_points = np.array([[4.6,12.0], [15.5,4.8], [22.5,15.2], [11.9,22.5]])
+    elif mode == 'RyR-D4365':
+        corner_points = np.array([[2,13.2],[13.9,2.2],[25.3,14.0],[13.3,25.2]])
+
+    else:
+        raise RuntimeError('unknow RyR corner mode %s requested' % (mode))
+    # first rotate corner points
+    R = rmat_ang(sprect.get('rot_angle',0))
+    cpsr = corner_points[:,None,:].dot(R).squeeze()
+    # now shift corner points to the origin of this rect
+    scpsr = cpsr + origin[None,:]
+    return scpsr
+
+# functions to pick points and rotate point sets for generating clusters etc
+
+from numpy.random import default_rng
+rng = default_rng()
+
+def random_pick(size,p):
+    return rng.random(size) < p
+
+def rotpts(pts,angle):
+    rotpts = []
+    for ptnum in range(pts.shape[0]):
+        rx,ry = transform_rot(pts[ptnum,0],pts[ptnum,1],angle)
+        rotpts.append([rx,ry])
+    return np.array(rotpts)
+
+def ctrorigin(pts):
+    mxy = pts.mean(axis=0)
+    return pts - mxy[None,:]
+
+def shftpts(pts,x,y):
+    return pts + np.array([x,y])[None,:]
+
+def pickpts(pts,prob):
+    picked = random_pick(pts.shape[0],prob)
+
+    return pts[picked,:]
+
+def mergeClusterlist(clist):
+    clusters = clist[0].copy()
+    for c in clist[1:]:
+        clusters = np.append(clusters,c,axis = 0)
+    return clusters
+
+import pandas as pd
+def pts2df(pts):
+    pymedct =  {'x' : pts[:,0], 'y' : pts[:,1], 'z' : np.zeros((pts.shape[0])), 't' : np.ones((pts.shape[0]))}
+    pymedf = pd.DataFrame.from_dict(pymedct)
+    return pymedf
+
+def pymedf_add_err(pymedf,locerr=2.0): # error in nm
+    errdf = pymedf.copy()
+    nrows = errdf.shape[0]
+    errdf['x'] += locerr*np.random.normal(size=nrows)
+    errdf['y'] += locerr*np.random.normal(size=nrows)
+    errdf['z'] += locerr*np.random.normal(size=nrows)
+    errdf['error_x'] = locerr*np.ones((nrows))
+    errdf['error_y'] = locerr*np.ones((nrows))
+    errdf['error_z'] = locerr*np.ones((nrows))
+
+    return errdf
+
+def datasourcePick2df(ds,prob):
+    picked = random_pick(ds['x'].size,prob)
+    pymedct = {}
+    for key in ['x','y','z','error_x','error_y','error_z','t']:
+        pymedct[key] = ds[key][picked]
+    return pd.DataFrame.from_dict(pymedct)