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

PYMEcs/IO/NPC.py

@@ -0,0 +1,117 @@
+from PYMEcs.pyme_warnings import warn
+import pickle
+from pathlib import Path
+import logging
+
+logger = logging.getLogger(__name__)
+
+def load_NPC_set(fname, ts=None, foreshortening=None, version=None):
+    with open(fname,'rb') as fi:
+        npcs=pickle.load(fi)
+    fpath = Path(fname)
+    if ts is not None and ts not in fpath.stem:
+        warn("MINFLUX time stamp not in NPC dataset filename; check correct filename chosen: %s vs %s" %
+             (ts,fpath.stem))
+
+    if foreshortening is not None:
+        try:
+            npc_foreshortening = npcs.foreshortening
+        except AttributeError:
+            npc_foreshortening = 1.0
+
+        if abs(npc_foreshortening-foreshortening) >= 0.01:
+            warn("NPC foreshortening is %.2f while dataset foreshortening is %.2f, check this is compatible" %
+                 (npc_foreshortening,foreshortening))
+        
+
+    if version is not None:
+        pass # here add version checking logic
+
+    return npcs
+
+def save_NPC_set(npcs,fname):
+    with open(fname, "wb") as file:
+            pickle.dump(npcs,file)
+
+def findNPCset(pipeline,return_mod=False,warnings=True):
+    from PYMEcs.recipes.localisations import NPCAnalysisInput
+    # note a "manually" created or loaded NPCset in pipeline.npcs attribute takes precedence over loaded via NPCAnalysisInput module
+    if pipeline is not None and 'npcs' in dir(pipeline) and pipeline.npcs is not None and not return_mod:
+        return pipeline.npcs
+    if pipeline is None:
+        return None
+    dsname = None
+    hideNPC = False
+    # search/check for instance
+    for mod in pipeline.recipe.modules:
+        if isinstance(mod,NPCAnalysisInput):
+            dsname = mod.output
+            hideNPC = mod.NPC_hide
+            module = mod
+            break
+    if hideNPC: # the module is deliberately hiding the NPCset associated with it
+        if warnings:
+            warn("NPCset has been marked as hidden in NPCAnalysisInput output, assuming this is deliberate")
+        return None
+    if dsname is None:
+        if warnings:
+            warn("we rely on npc analysis being present in a datasource generated by the NPCAnalysisInput module. Can't find such a datasource, aborting...")
+        return None
+    logger.debug("found NPCAnalysisInput module")
+    if return_mod:
+        return module
+    npc_set_container = pipeline.dataSources[dsname].mdh.get('Processing.NPCAnalysisInput.npcs_filtered')
+    if not mod.filter_npcs or npc_set_container is None: # if not filtering or no filtered set available try the unfiltered npc set
+        npc_set_container = pipeline.dataSources[dsname].mdh.get('Processing.NPCAnalysisInput.npcs')
+        logger.debug("trying to retrieve unfiltered NPCSet")
+    else:
+        logger.debug("found filtered NPCSet")
+    if npc_set_container is None: # we get here if there is still no npc set available
+        # this warning cannot be masked as this case should not happen unless something is broken (either bug or not used as intended)
+        warn(("found no NPCset container in metadata of datasource '%s' generated by NPCAnalysisInput module.\n\n" % dsname)
+             + "Did you already load a pickled NPC analysis file with the module?\n\naborting..." )
+        return None
+    
+    return npc_set_container.get_npcset()
+
+from packaging.version import Version # this allows us to do simpler comparisons
+def check_npcset_version(npcset,target_version,mode='minimum version'):
+    version = None
+    try:
+        version =  npcset.version()
+    except AttributeError:
+        pass
+    if version is None: # older version, use some heuristics
+        if 'n_bysegments' not in dir (npcset):
+            version = Version('0.1')
+        elif npcset.n_bysegments() is None: # this can also happen with newer version when not yet fitted, but then we should not have loaded this as a saved object
+            version = Version('0.1')
+        else:
+            version = Version('0.9')
+
+    if mode == 'return_version':
+        return version
+    
+    if not isinstance(version,Version):
+        try:
+            version = Version(version)
+        except:
+            warn("cannot convert version expression '%s' to Version object, giving up and returning True, perhaps tell CS" % version)
+            return True
+
+    if not isinstance(target_version,Version):
+        try:
+            target_version = Version(target_version)
+        except:
+            warn("cannot convert version expression '%s' to Version object, giving up and returning True, perhaps tell CS" % target_version)
+            return True
+
+    if mode == 'minimum version':
+        return version >= target_version
+    elif mode == 'exact version':
+        return version == target_version
+    else: # we have checked for mode return_version above, so should be ok by not testing here
+        raise RuntimeError("unknown mode %s requested" % (mode))
+
+    
+    

PYMEcs/IO/darkTimes.py

@@ -0,0 +1,19 @@
+import csv
+import numpy as np
+
+def saveDarkTimesCSV(objectIDs,dts,filename):
+    with open( filename, 'w') as outfile:
+        writer = csv.writer( outfile )
+        for id, darktimes in zip(objectIDs,dts):
+            writer.writerow([id]+darktimes.tolist())
+
+def readDarkTimesCSV(filename):
+    with open( filename, 'r') as infile:
+        reader = csv.reader( infile )
+        objectIDs = []
+        dts = []
+        for row in reader:
+            objectIDs.append(int(row[0]))
+            dt = np.array(row[1:],dtype='f')
+            dts.append(dt)
+    return (objectIDs,dts)

PYMEcs/IO/picasso.py

@@ -0,0 +1,219 @@
+import numpy as np
+import pandas as pd
+import yaml
+import math
+import os
+
+def picasso2pyme(locs,mdh):
+    try:
+        nmperpix = mdh['Camera.Pixelsize']
+    except KeyError:
+        nmperpix = mdh['Pixelsize']
+        
+    pyme = {}
+    pyme['x'] = locs['x']*nmperpix
+    pyme['y'] = locs['y']*nmperpix
+    pyme['sig'] = locs['sx']*nmperpix
+    pyme['nPhotons'] = locs['photons']
+    pyme['error_x'] = locs['lpx']*nmperpix
+    pyme['error_y'] = locs['lpy']*nmperpix
+    pyme['t'] = locs['frame']
+    pyme['A'] = locs['photons']/(2*math.pi)/(locs['sx']**2) # this is from the PYME kinmodels formula - check
+    if 'z' in locs.keys():
+        pyme['z'] = locs['z'] # from astigmatoc data z should already be scaled to nm?
+    return pyme
+
+def struc_from_mdh(mdh):
+    if mdh is None or 'Structure.HandleStruct' not in mdh.keys():
+        return None
+    struc = {}
+    nmperpix = float(mdh['Camera.Pixelsize'])
+    npixels = float(mdh['Camera.Image Size'])
+    for key in ('HandleStruct','HandleEx'):
+        struc[key] = np.array([float(i) for i in mdh["Structure.%s" % key].split(',')],dtype='i')
+    offshalfpix = 0.5 # half a pixel offset seems to be required (origin in middle of pixel?)
+    for key in ['HandleX']:
+        struc[key] = np.array([(float(i)-offshalfpix)*nmperpix for i in mdh["Structure.%s" % key].split(',')])
+    # for a reason not quite clear to me yet the Y coordinates need mirroring
+    for key in ['HandleY']:
+        struc[key] = np.array([(npixels-float(i)-offshalfpix)*nmperpix for i in mdh["Structure.%s" % key].split(',')])
+    return struc
+
+def parse_dicts(dicts):
+    import re
+    mdh = None
+    strucmdh = None
+    for d in dicts:
+        if any (re.match('pixelsize',key,re.I) for key in d.keys()):
+            mdh = d
+    for d in dicts:
+        if any (re.match('Structure',key,re.I) for key in d.keys()):
+            strucmdh = d    
+    return (mdh,strucmdh)
+
+def read_picasso_hdf(name):
+    locs = pd.read_hdf(name,'locs')
+    basename, file_extension = os.path.splitext(name)
+    with open(basename+'.yaml') as file:
+        finf = list(yaml.load_all(file, Loader=yaml.FullLoader))
+    mdh, strucmdh = parse_dicts(finf)
+    pymedf = pd.DataFrame(picasso2pyme(locs,mdh))
+    struc = struc_from_mdh(strucmdh)
+    return pymedf, mdh, struc
+
+def pymedf2csv(pymedf,filename):
+    cols = ['A','x','y','t','sig','error_x','error_y','nPhotons']
+    pymedf.to_csv(filename,columns=cols,index=False)
+
+def pymedf2ds(pymedf):
+    from PYME.IO.tabular import DictSource
+    pymedict={}
+    for key in pymedf.keys():
+        pymedict[key] = pymedf[key].values
+    ds = DictSource(pymedict)
+    return ds
+
+import skimage.morphology as morph
+from PYME.IO.image import ImageStack
+#from PYME.IO.MetaDataHandler import NestedClassMDHandler
+
+def picasso_structure_mask(inputim,struc,dilations=2,
+                           dilationselem=np.ones((5,5),dtype='float32')):
+    ox = inputim.mdh['Origin.x']
+    oy = inputim.mdh['Origin.y']
+    vxsz = 1e3*inputim.mdh['voxelsize.x']
+
+    mask0 = np.zeros(inputim.data.shape[0:2],dtype='float32')
+    labels = []
+    nsites = []
+    cxa = []
+    cya = []
+    
+    for label in range(0,int(struc['HandleStruct'].max()+1)):
+        strucn = struc['HandleStruct'] == label
+        newim = np.zeros(inputim.data.shape[0:2],dtype='float32')
+        strucx = ((struc['HandleX'][strucn]) - ox) / vxsz
+        strucy = ((struc['HandleY'][strucn]) - oy) / vxsz
+        cx = struc['HandleX'][strucn].mean()
+        cy = struc['HandleY'][strucn].mean()
+        cxi = np.rint(strucx.mean()).astype('int') # integer centroid x
+        cyi = np.rint(strucy.mean()).astype('int') # integer centroid y
+        labels.append(label+1)
+        nsites.append(strucx.size)
+        cxa.append(cx)
+        cya.append(cy)
+        ind =  (strucx < newim.shape[0])*(strucy < newim.shape[1])*(strucx >= 0)*(strucy >= 0)
+        if np.any(ind):
+            newim[strucx[ind].astype('i'),strucy[ind].astype('i')] = 1.0
+            newim2 = morph.convex_hull_image(newim)
+            for i in range(dilations):
+                newim2 = morph.binary_dilation(newim2,selem=dilationselem)
+            mask0[newim2 > 0.5] = label+1
+
+    sitesdf = pd.DataFrame(list(zip(labels, nsites, cxa, cya)), 
+                           columns =['Label', 'NSites', 'CentroidX', 'CentroidY'])
+    return ImageStack(mask0, mdh=inputim.mdh), sitesdf
+
+# same as the routine above but everything is done in a small ROI that is then inserted into the
+# full size image; this speeds everything up considerably, mostly as hoped
+def picasso_structure_mask_roi(inputim,struc,dilations=2,
+                               dilationselem=np.ones((5,5),dtype='float32'),roisize=20):
+    ox = inputim.mdh['Origin.x']
+    oy = inputim.mdh['Origin.y']
+    vxsz = 1e3*inputim.mdh['voxelsize.x']
+
+    mask0 = np.zeros(inputim.data.shape[0:2],dtype='float32')
+    labels = []
+    nsites = []
+    cxa = []
+    cya = []
+    
+    rszh = roisize
+    xroi = np.arange(0,2*rszh+1,dtype='int')
+    yroi = np.arange(0,2*rszh+1,dtype='int')
+    xroi2 = np.outer(xroi,np.ones(2*rszh+1,dtype='i'))
+    yroi2 = np.outer(np.ones(2*rszh+1,dtype='i'),yroi)
+
+    for label in range(0,int(struc['HandleStruct'].max()+1)):
+        strucn = struc['HandleStruct'] == label
+        strucx = ((struc['HandleX'][strucn]) - ox) / vxsz
+        strucy = ((struc['HandleY'][strucn]) - oy) / vxsz
+        cx = struc['HandleX'][strucn].mean()
+        cy = struc['HandleY'][strucn].mean()
+        cxi = np.rint(strucx.mean()).astype('int') # integer centroid x
+        cyi = np.rint(strucy.mean()).astype('int') # integer centroid y
+        labels.append(label+1)
+        nsites.append(strucx.size)
+        cxa.append(cx)
+        cya.append(cy)
+        # make empty small ROI
+        roinew = np.zeros((2*rszh+1,2*rszh+1),dtype='f')
+        # transform coordinates to the ROI coordinate system
+        # the ROI is centered on the structure centroid (cxi,cyi)
+        roisx = strucx - (cxi-rszh)
+        roisy = strucy - (cyi-rszh)
+        # set pixels corresponding to structure to 1
+        roinew[roisx.astype('i'),roisy.astype('i')] = 1.0
+        # convex hull of structure + dilations
+        roi2 = morph.convex_hull_image(roinew)
+        for i in range(dilations):
+            roi2 = morph.binary_dilation(roi2,selem=dilationselem)
+        # transform ROI coordinates to full image coordiante system 
+        x2 = xroi2 + (cxi-rszh)
+        y2 = yroi2 + (cyi-rszh)
+        # restrict to non-zero pixels
+        mask = roi2 > 0.5
+        x2m = x2[mask]
+        y2m = y2[mask]
+        # check which of these non-zero pixels are within the full image bounds
+        valid = (x2m < mask0.shape[0])*(y2m < mask0.shape[1])*(x2m >= 0)*(y2m >= 0)
+        if np.any(valid):
+            mask0[x2[mask][valid],y2[mask][valid]] = label+1 # set to label of that structure
+
+    sitesdf = pd.DataFrame(list(zip(labels, nsites, cxa, cya)),
+                           columns =['Label', 'NSites', 'CentroidX', 'CentroidY'])
+    return ImageStack(mask0, mdh=inputim.mdh), sitesdf
+
+# import skimage.morphology as morph
+
+# dilations=2
+# dilationselem=np.ones((5,5),dtype='i')
+
+# strucx = np.array([200,210,220,200,210])
+# strucy = np.array([100,100,100,110,110])
+
+# cx = np.round(strucx.mean()).astype('i')
+# cy = np.round(strucy.mean()).astype('i')
+
+# mask0 = np.zeros((256,256),dtype='f')
+
+# rszh = 20
+
+# # initialisation
+# xroi = np.arange(0,2*rszh+1,dtype='int')
+# yroi = np.arange(0,2*rszh+1,dtype='int')
+# xroi2 = np.outer(xroi,np.ones(2*rszh+1,dtype='i'))
+# yroi2 = np.outer(np.ones(2*rszh+1,dtype='i'),yroi)
+
+# # this is done in each loop
+# roinew = np.zeros((2*rszh+1,2*rszh+1),dtype='f')
+
+# roisx = strucx - (cx-rszh)
+# roisy = strucy - (cy-rszh)
+
+# roinew[roisx.astype('i'),roisy.astype('i')] = 1.0
+# roi2 = morph.convex_hull_image(roinew)
+# for i in range(dilations):
+#     roi2 = morph.binary_dilation(roi2,selem=dilationselem)
+
+# x2 = xroi2 + (cx-rszh)
+# y2 = yroi2 + (cy-rszh)
+
+# mask = roi2 > 0.5
+
+# x2m = x2[mask]
+# y2m = y2[mask]
+
+# valid = (x2m < mask0.shape[0])*(y2m < mask0.shape[1])*(x2m >= 0)*(y2m >= 0)
+
+# mask0[x2[mask][valid],y2[mask][valid]] = roi2[xroi2[mask][valid],yroi2[mask][valid]]

PYMEcs/IO/tabular.py

@@ -0,0 +1,11 @@
+from PYMEcs.Analysis.fitDarkTimes import TabularRecArrayWrap
+import pandas as pd
+import numpy as np
+
+# we should probably add this to a module like PYMEcs.IO.tabular
+def tabularFromCSV(csvname):
+    df = pd.DataFrame.from_csv(csvname)
+    rec = df.to_records()
+    tb = TabularRecArrayWrap(rec)
+    return tb
+

PYMEcs/experimental/CalcZfactor.py

@@ -0,0 +1,51 @@
+import PYMEcs.Analysis.stackTracker as st
+from PYMEcs.misc.guiMsgBoxes import Warn
+
+from traits.api import HasTraits, Str, Int, CStr, List, Enum, Float, Bool
+
+class CalcZfConfig(HasTraits):
+    offsetFromCenter = Int(0)
+    planesToUse = Int(11)
+    
+from PYME.DSView.modules._base import Plugin
+class CalcZf(Plugin):
+    def __init__(self, dsviewer):
+        Plugin.__init__(self, dsviewer)
+        self.czfconf = CalcZfConfig()
+        
+        dsviewer.AddMenuItem('Experimental', "Calculate z-factor", self.OnCalcZf)
+        dsviewer.AddMenuItem('Experimental', "z-factor calculation settings", self.OnCalcZfSettings)
+
+    def OnCalcZfSettings(self, event):
+        self.czfconf.configure_traits(kind='modal')
+        
+    def OnCalcZf(self, event):
+        # first a few checks that the data set is suitable
+        # do we need further checks?
+        from math import isclose
+        if not isclose(self.dsviewer.image.voxelsize_nm.z,50.0,abs_tol=1.0):
+            Warn(self.dsviewer,'z voxelsize needs to be 50 nm, is %.1f nm' % self.dsviewer.image.voxelsize_nm.z)
+            return
+
+        use_zszh = self.czfconf.planesToUse // 2
+        offset = self.czfconf.offsetFromCenter
+        need_planes = 2*use_zszh+1 + abs(offset)
+        
+        zsz = self.dsviewer.image.data_xyztc.shape[2]
+        zszh = zsz // 2
+        if 2*zszh+1 != zsz:
+            Warn(self.dsviewer,'z dimension size should be odd number, is %d' % zsz)
+            return
+        if zsz < need_planes:
+            Warn(self.dsviewer,'need at least %d planes, stack has %d planes' % (need_planes,zsz))
+            return
+
+        dataset = self.dsviewer.image.data_xyztc[:,:,zszh+offset-use_zszh:zszh+offset+use_zszh+1,0,0].squeeze()
+        
+        tstack = st.initialise_data(dataset,4,self.dsviewer.image.voxelsize_nm)
+        dxnm,dynm,dznm = st.get_shifts_from_stackobject(tstack)
+
+        st.fit_and_plot_zf(dxnm,dynm,dznm,tstack)
+
+def Plug(dsviewer):
+    return CalcZf(dsviewer)