python-microscopy 25.11.20__cp313-cp313-win_amd64.whl

PYME/Analysis/Colocalisation/colocScaleDep.py

@@ -0,0 +1,126 @@
+#!/usr/bin/python
+##################
+# colocScaleDep.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 numpy as np
+from scipy import ndimage
+from . import correlationCoeffs
+# from pylab import 
+from numpy.random import rand
+from . import edtColoc
+from PIL import Image
+
+DIRNAME='/home/david/Desktop/coloc/'
+
+def rendP(imR, imG, x, y, w):
+    imR[(x-w):x, (y-w/2):(y+w/2)] +=1
+    imG[x:(x+w), (y-w/2):(y+w/2)] +=1
+
+def rendS(imR, imG, x, y, w):
+    if rand() > .5:
+        imR[(x-w):x, (y-w/2):(y+w/2)] +=1
+    else:
+        imG[x:(x+w), (y-w/2):(y+w/2)] +=1
+
+
+def corrScale(s, imR, imG):
+    import matplotlib.pyplot as plt
+    #from pylab import *
+    
+    bR = ndimage.gaussian_filter(imR, s)
+    bG = ndimage.gaussian_filter(imG, s)
+    plt.figure(2)
+    plt.clf()
+    plt.imshow(np.concatenate([bR[:,:,None]/bR.max(), bG[:,:,None]/bG.max(), np.zeros(imR.shape)[:,:,None]], 2))
+    plt.savefig(DIRNAME + 'blurred_%dnm.pdf' % (2.35*s))
+    Image.fromarray((np.concatenate([bR[:,:,None]/bR.max(), bG[:,:,None]/bG.max(), np.zeros(imR.shape)[:,:,None]], 2)*255).astype('uint8')).save(DIRNAME + 'blurred_%dnm.tif' % (2.35*s))
+
+    ps = correlationCoeffs.pearson(bR, bG)
+    md1, md2 = correlationCoeffs.thresholdedManders(bR, bG, bR.max()/2, bG.max()/2)
+
+    bn, bm, bins = edtColoc.imageDensityAtDistance(bR, bG > bG.max()/2, bins=np.arange(-200, 200, 5) + .01)
+    plt.figure(3)
+    plt.clf()
+    plt.bar(bins[:-1], bm, 5)
+    plt.ylim(0, .25)
+    plt.xlim(-50, 200)
+    plt.xlabel('Distance from edge of A [nm]')
+    plt.ylabel('Density of B')
+    plt.savefig(DIRNAME + 'dist_dense_%dnm.pdf' % (2.35*s))
+
+    return ps, md1, md2, bm, bins
+
+def genIm(size=500, w=30):
+    imR = np.zeros((size, size))
+    imG = np.zeros((size, size))
+
+    rendP(imR, imG, size/2, size/2, w)
+
+    return imR, imG
+
+def genImR(size=500, w=30):
+    imR = np.zeros((size, size))
+    imG = np.zeros((size, size))
+
+    for i in range(10):
+        rendP(imR, imG, size*rand(), size*rand(), w)
+
+    return imR, imG
+
+def genImR2(size=500, w=30):
+    imR = np.zeros((size, size))
+    imG = np.zeros((size, size))
+
+    for i in range(20):
+        rendS(imR, imG, size*rand(), size*rand(), w)
+
+    return imR, imG
+
+def genPlots():
+    import matplotlib.pyplot as plt
+    #from pylab import *
+    imR, imG = genIm()
+
+    plt.close('all')
+
+    plt.figure()
+    plt.imshow(np.concatenate([imR[:,:,None], imG[:,:,None], np.zeros(imR.shape)[:,:,None]], 2))
+    plt.xlabel('Position [nm]')
+    plt.ylabel('Position [nm]')
+    plt.savefig(DIRNAME + 'object.pdf')
+
+    plt.figure()
+
+    sca = np.arange(0, 100, 5)
+    cfs = [corrScale(s, imR, imG) for s in sca]
+    cfa = np.array([c[:-2] for c in cfs])
+
+    plt.figure()
+    plt.plot(2.35*sca, cfa[:,0], lw=2)
+    plt.ylim(0, 1)
+    plt.xlabel('Resolution (FWHM) [nm]')
+    plt.ylabel('Pearson Correlation Coefficient')
+    plt.savefig(DIRNAME + 'pearsons.pdf')
+
+
+
+
+
+

PYME/Analysis/Colocalisation/correlationCoeffs.py

@@ -0,0 +1,198 @@
+#!/usr/bin/python
+
+##################
+# correlationCoeffs.py
+#
+# Copyright David Baddeley, 2010
+# 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 numpy as np
+
+def pearson(X, Y, roi_mask=None):
+    if not roi_mask is None:
+        #print X.shape, roi_mask.shape
+        X = X[roi_mask]
+        Y = Y[roi_mask]
+        
+    X = X - X.mean()
+    Y = Y-Y.mean()
+    return (X*Y).sum()/np.sqrt((X*X).sum()*(Y*Y).sum())
+
+def overlap(X, Y, roi_mask=None):
+    if not roi_mask is None:
+        X = X[roi_mask]
+        Y = Y[roi_mask]
+    
+    return (X*Y).sum()/np.sqrt((X*X).sum()*(Y*Y).sum())
+
+
+def thresholdedManders(A, B, tA, tB, roi_mask=None):
+    """Manders, as practically used with threshold determined masks"""
+    A = A.astype('f')
+    B = B.astype('f')
+    if not roi_mask is None:
+        A = A[roi_mask]
+        B = B[roi_mask]
+        
+        #print A.shape, B.shape, tA, tB, A.sum(), (B>tB).sum()
+
+    MA = ((B > tB)*A).sum()/A.sum()
+    MB = ((A > tA)*B).sum()/B.sum()
+
+    return MA, MB
+
+
+def maskManders(A, B, mA, mB, roi_mask=None):
+    """Manders, as practically used with threshold determined masks
+    
+    like thresholdedManders, but we pass already thresholded masks in to start with
+    """
+    A = A.astype('f')
+    B = B.astype('f')
+    if not roi_mask is None:
+        A = A[roi_mask]
+        B = B[roi_mask]
+        mA = mA[roi_mask]
+        mB = mB[roi_mask]
+        
+        
+        #print A.shape, B.shape, tA, tB, A.sum(), (B>tB).sum()
+    
+    MA = (mB * A).sum() / A.sum()
+    MB = (mA * B).sum() / B.sum()
+    
+    return MA, MB
+
+def maskFractions(A, B, tA, tB):
+    FA = (A > tA).mean()
+    FB = (B > tB).mean()
+
+    return FA, FB
+
+def mutual_information(X, Y, roi_mask=None, nbins=256, bits=False):
+    if not roi_mask is None:
+        X = X[roi_mask]
+        Y = Y[roi_mask]
+
+    h = np.histogram2d(X.ravel(), Y.ravel(), bins=nbins)[0]
+    
+    pxy = h/float(h.sum())
+    
+    px = pxy.sum(axis=1)
+    py = pxy.sum(axis=0)
+    
+    px_py = px[:,None]*py[None,:]
+    
+    # pxy == 0 doesn't contribute to the sum, avoid problems with log by masking these out
+    m = pxy > 0
+    
+    if bits:
+        # return as 'bits' of entropy (i.e. calculate log base 2)
+        return np.sum(pxy[m] * np.log2(pxy[m] / px_py[m]))
+    else:
+        return np.sum(pxy[m]*np.log(pxy[m]/px_py[m]))
+    
+    
+def fourier_ring_correlation(imA, imB, voxelsize=[1.0, 1.0], window=False):
+    import matplotlib.pyplot as plt
+    from PYME.Analysis import binAvg
+    
+    imA = imA.squeeze()
+    imB = imB.squeeze()
+    
+    X, Y = np.mgrid[0:float(imA.shape[0]), 0:float(imA.shape[1])]
+    X = X / X.shape[0]
+    Y = Y / X.shape[1]
+    X = (X - .5)
+    Y = Y - .5
+    R = np.sqrt(X ** 2 + Y ** 2)
+    
+    if window:
+        W =np.hanning(X.shape[0])[:,None]*np.hanning(X.shape[1])[None,:]
+        imA = imA*W
+        imB = imB*W
+    
+    H1 = np.fft.fftn(imA)
+    H2 = np.fft.fftn(imB)
+    
+    #rB = np.linspace(0,R.max())
+    rB = np.linspace(0, 0.5, 100)
+    
+    bn, bm, bs = binAvg.binAvg(R, np.fft.fftshift(H1 * H2.conjugate()).real, rB)
+    
+    bn1, bm1, bs1 = binAvg.binAvg(R, np.fft.fftshift((H1 * H1.conjugate()).real), rB)
+    bn2, bm2, bs2 = binAvg.binAvg(R, np.fft.fftshift((H2 * H2.conjugate()).real), rB)
+    
+    plt.figure()
+
+    fig = plt.gcf()
+    try:
+        fig.canvas.set_window_title('Fourier Ring Correlation')
+    except AttributeError:
+        # more recent version seem to have pushed this method into a manager sub-object
+        # see also: https://matplotlib.org/stable/api/prev_api_changes/api_changes_3.4.0.html#backend-deprecations
+        fig.canvas.manager.set_window_title('Fourier Ring Correlation')
+
+    ax = plt.gca()
+    
+    #FRC
+    FRC = bm / np.sqrt(bm1 * bm2)
+    ax.plot(rB[:-1], FRC)
+    
+    #noise envelope???????????
+    ax.plot(rB[:-1], 2. / np.sqrt(bn / 2), ':')
+    
+    dfrc = np.diff(FRC)
+    #print FRC
+    monotone = np.where(dfrc > 0)[0][0] + 1
+    
+    #print FRC[:monotone], FRC[:(monotone+1)]
+    
+    intercept_m = np.interp(1.0 - 1 / 7.0, 1 - FRC[:monotone], rB[:monotone])
+    
+    print('Intercept_m= %3.2f (%3.2f nm)' % (intercept_m, voxelsize[0] / intercept_m))
+    
+    from scipy import ndimage
+    f_s = np.sign(FRC - 1. / 7.)
+    
+    fss = ndimage.gaussian_filter(f_s, 10, mode='nearest')
+    
+    intercept = np.interp(0.0, - fss, rB[:-1])
+    
+    print('Intercept= %3.2f (%3.2f nm)' % (intercept, voxelsize[0] / intercept))
+    
+    xt = np.array([10., 15, 20, 30, 40, 50, 70, 90, 120, 150, 200, 300, 500])
+    rt = voxelsize[0] / xt
+    
+    plt.xticks(rt[::-1], ['%d' % xi for xi in xt[::-1]], rotation='vertical')
+    
+    ax.plot([0, rt[0]], np.ones(2) / 7.0)
+    
+    plt.grid()
+    plt.xlabel('Resolution [nm]')
+    
+    plt.ylabel('FRC')
+    plt.ylim(0, 1.1)
+    
+    plt.plot([intercept, intercept], [0, 1], '--')
+    
+    plt.figtext(0.5, 0.5, 'FRC intercept at %3.1f nm' % (voxelsize[0] / intercept))
+    
+    plt.figure()
+    plt.plot(rB[:-1], f_s)
+    plt.plot(rB[:-1], fss)
+    plt.show()

PYME/Analysis/Colocalisation/distColoc.py

@@ -0,0 +1,110 @@
+#!/usr/bin/python
+
+##################
+# distColoc.py
+#
+# Copyright David Baddeley, 2010
+# d.baddeley@auckland.ac.nz
+#
+# This file may NOT be distributed without express permision from David Baddeley
+#
+##################
+
+from PYME.Analysis.points import DistHist
+import numpy as np
+
+
+#def calcCollHist(colourFilter, colour):
+
+def rebin(a, fact):
+    b = a[::fact]
+    for i in range(1, fact):
+        b += a[i::fact]
+    return b
+
+def calcDistCorr(cfilter, colourA, colourB, nbins=100, binsize=10):
+    '''Do pointwise / ripley based colocalisation between colourA and colourB'''
+    
+    import matplotlib.pyplot as plt
+    #save current state of colour filter
+    old_col = cfilter.currentColour
+
+    #grab the x and y vals in each channel
+    cfilter.setColour(colourA)
+    xA = cfilter['x']
+    yA = cfilter['y']
+
+    cfilter.setColour(colourB)
+    xB = cfilter['x']
+    yB = cfilter['y']
+
+    #generate randomly distributed x & y values with the same density as colourB
+    xR = (xB.max() - xB.min())*np.random.rand(len(xB)) + xB.min()
+    yR = (yB.max() - yB.min())*np.random.rand(len(xB)) + yB.min()
+
+    hAA = DistHist.distanceHistogram(xA, yA, xA, yA, nbins, binsize)
+    hAB = DistHist.distanceHistogram(xA, yA, xB, yB, nbins, binsize)
+    hBB = DistHist.distanceHistogram(xB, yB, xB, yB, nbins, binsize)
+    hBA = DistHist.distanceHistogram(xB, yB, xA, yA, nbins, binsize)
+
+    hAR = DistHist.distanceHistogram(xA, yA, xR, yR, nbins, binsize)
+    hBR = DistHist.distanceHistogram(xB, yB, xR, yR, nbins, binsize)
+    
+    d = binsize*np.arange(nbins)
+
+    plt.figure()
+    #subplot(211)
+    plt.plot(d, hAA/hAA.sum()-hAR/hAR.sum(), label='%s' % (colourA,), lw=2)
+    plt.plot(d, hAB/hAB.sum()-hBR/hBR.sum(), label='%s' % (colourB,), lw=2)
+    plt.plot(d, hAA/hAA.sum()-hAB/hAB.sum(), '--',label='%s - %s' % (colourA, colourB), lw=2)
+
+    plt.grid()
+    plt.legend()
+    plt.xlabel('Radius [nm] from %s' % colourA)
+    plt.ylabel('Excess Labelling')
+
+    plt.figure()
+    #subplot(211)
+    plt.plot(d, hBB/hBB.sum()-hBR/hBR.sum(), label='%s' % (colourB,), lw=2)
+    plt.plot(d, hBA/hBA.sum()-hAR/hAR.sum(), label='%s' % (colourA,), lw=2)
+    plt.plot(d, hBB/hBB.sum()-hBA/hBA.sum(), '--',label='%s - %s' % (colourB, colourA), lw=2)
+
+    plt.grid()
+    plt.legend()
+    plt.xlabel('Radius [nm] from %s' % colourB)
+    plt.ylabel('Excess Labelling')
+
+    #subplot(212)
+    plt.figure()
+
+    corr = 1 - np.abs(hAB/hAB.sum()-hAA/hAA.sum()).sum()/np.abs(hAA/hAA.sum()-hAR/hAR.sum()).sum()
+
+    print('Correlation Factor: %3.2f' % corr)
+
+    ccorr = 1 - np.cumsum(np.abs(hAB/hAB.sum()-hAA/hAA.sum()))/np.cumsum(np.abs(hAA/hAA.sum()-hAR/hAR.sum()))
+    plt.plot(d,ccorr)
+    plt.ylim(-1,1)
+    plt.grid()
+    plt.ylabel('Correlation Factor')
+    plt.xlabel('Radius [nm] from %s' % colourA)
+
+    plt.figure()
+
+    corr = 1 - np.abs(hBA/hBA.sum()-hBB/hBB.sum()).sum()/np.abs(hBB/hBB.sum()-hBR/hBR.sum()).sum()
+
+    print('Correlation Factor: %3.2f' % corr)
+
+    ccorr = 1 - np.cumsum(np.abs(hBA/hBA.sum()-hBB/hBB.sum()))/np.cumsum(np.abs(hBB/hBB.sum()-hBR/hBR.sum()))
+    plt.plot(d,ccorr)
+    plt.ylim(-1,1)
+    plt.grid()
+    plt.ylabel('Correlation Factor')
+    plt.xlabel('Radius [nm] from %s' % colourB)
+
+    #title('%s vs %s  - Correlation Factor = %3.2f' % (colourB, colourA, corr))
+
+
+
+    #restore state of colour filter
+    cfilter.setColour(old_col)
+

PYME/Analysis/Colocalisation/edtColoc.py

@@ -0,0 +1,191 @@
+#!/usr/bin/python
+
+##################
+# edtColoc.py
+#
+# Copyright David Baddeley, 2010
+# 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 scipy import ndimage
+import numpy
+import numpy as np
+from PYME.Analysis import binAvg
+
+def imageDensityAtDistance(A, mask, voxelsize = None, bins=100, roi_mask=None):
+    """Calculates the distribution of a label at varying distances from a mask.
+    Negative distances are on the inside of the mask.
+
+    Parameters
+    -----------
+        
+    A - intensity image
+    mask - binary mask
+    voxelsize - size of the pixels/voxels - should be either a constant, or an iterable
+                with a length equal to the number of dimensions in the data
+    bins - either a number of bins, or an array of bin edges
+
+
+    Returns
+    --------
+        
+    bn - number of pixels in distance bin
+    bm - mean intensity in distance bin
+    bins - the bin edges
+    """
+    
+    if voxelsize is None:
+        voxelsize = numpy.ones(len(A.shape))
+
+    dt = -ndimage.distance_transform_edt(mask, sampling=voxelsize)
+
+    dt = dt + ndimage.distance_transform_edt(1- ndimage.binary_dilation(mask), sampling=voxelsize)
+
+    if numpy.isscalar(bins):
+        bins = numpy.linspace(dt.min(), dt.max(), bins+1)
+        
+    #print bins
+    if not roi_mask is None:
+        bn, bm, bs = binAvg.binAvg(dt[roi_mask], A[roi_mask], bins)
+    else:
+        bn, bm, bs = binAvg.binAvg(dt, A, bins)
+
+    return bn, bm, bins
+
+def image_enrichment_and_fraction_at_distance(A, mask, voxelsize = None, bins=100, roi_mask=None):
+    """
+    returns the relative enrichment of label of a label at a given distance from a mask, along with the total signal
+    enclosed within that distance.
+    
+    -ve distances correspond to points in the interior of the mask.
+    """
+    
+    bnA, bmA, binsA = imageDensityAtDistance(A, mask, voxelsize, bins, roi_mask=roi_mask)
+
+    enrichment = bmA / bmA[bnA > 1].mean()
+
+    total = bmA * bnA
+    enclosed_signal = np.cumsum(total / total.sum())
+    
+    enclosed_area = np.cumsum(bnA.astype('f')/bnA.sum())
+    
+    return binsA, enrichment, enclosed_signal, enclosed_area
+
+
+def plot_image_dist_coloc_figure(bins, enrichment_BA, enrichment_AA, enclosed_BA, enclosed_AA, enclosed_area, pearson=None, MA=None,
+                                 MB=None, nameA='A', nameB = 'B'):
+    import matplotlib.pyplot as plt
+    import scipy.interpolate
+    
+    #find the distance at which 50% of the labelling is included
+    d_50 = float(scipy.interpolate.interp1d(enclosed_BA, bins[1:])(.5))
+    
+    f = plt.figure()
+    if not pearson is None:
+        plt.figtext(.1, .95, 'Pearson: %2.2f   M1: %2.2f M2: %2.2f' % (pearson, MA, MB))
+    
+    plt.subplot(211)
+    plt.plot(bins[1:], enrichment_BA, lw=2, drawstyle='steps')
+    if not enrichment_AA is None:
+        plt.plot(bins[1:], enrichment_AA, 'k--', drawstyle='steps')#, binsA[1] - binsA[0])
+        
+    plt.xlabel('Distance from edge of %s [nm]' % nameA)
+    plt.ylabel('Relative enrichment')# % nameB)
+    
+    
+    
+    plt.plot([bins[0], bins[-1]], [1, 1], 'k:')
+    plt.grid()
+    plt.xlim([bins[0], bins[-1]])
+
+    plt.legend([nameB, nameA + ' (control)', 'uniform'], fontsize='medium', frameon=False)
+    
+    plt.subplot(212)
+    plt.plot(bins[1:], enclosed_BA, lw=2)
+    if not enclosed_AA is None:
+        plt.plot(bins[1:], enclosed_AA, 'k--')
+
+    plt.plot(bins[1:], enclosed_area, 'k:')
+    
+    plt.plot([bins[0], d_50], [.5, .5], 'r:')
+    plt.plot([d_50, d_50], [0, .5], 'r:')
+    
+    plt.text(d_50 + 150, .45, '50%% of %s is within %d nm' % (nameB, d_50))
+    
+    plt.xlabel('Distance from edge of %s [nm]' % nameA)
+    plt.ylabel('Fraction of %s enclosed' % nameB)
+    plt.grid()
+    plt.xlim([bins[0], bins[-1]])
+    
+    return f
+
+
+def pointDensityAtDistance(points, mask, voxelsize, maskOffset, bins=100):
+    """Calculates the distribution of a label at varying distances from a mask.
+    Negative distances are on the inside of the mask.
+
+    Parameters
+    ----------
+    points : np.ndarray
+        array containing point coordinates
+    mask : np.ndarray 
+        binary mask
+    voxelsize : iterable 
+        size of the pixels/voxels in mask - should be an iterable
+        with a length equal to the number of dimensions in the data
+    maskOffset : iterable
+        iterable with lengh equal to number of dims giving coordinates (in point space)
+        or the 0th pixel in the mask
+    bins : int or ndarray, default=100 
+        either a number of bins, or an array of bin edges
+
+
+    Returns
+    -------
+    bn : ndarray 
+        integrated intensity in distance bin
+    bm : ndarray 
+        mean intensity in distance bin
+    bins : ndarray
+        the bin edges
+
+    """
+
+    voxelsize = numpy.array(voxelsize)
+
+    dt = -ndimage.distance_transform_edt(mask, sampling=voxelsize)
+
+    dt = dt + ndimage.distance_transform_edt(ndimage.binary_dilation(1-mask), sampling=voxelsize)
+
+    pixelCoords = numpy.round((points - maskOffset[None, :])/[voxelsize[None, :]]).astype('i')
+
+    dists = dt[pixelCoords]
+
+
+    if numpy.isscalar(bins):
+        bins = numpy.linspace(dt.min(), dt.max(), bins+1)
+
+    n_events, b = numpy.histogram(dists, bins)
+    n_pixels, b = numpy.histogram(dt.flat, bins)
+
+    ev_density = n_events/n_pixels
+    ev_density[n_pixels ==0] = 0
+
+    return n_events, ev_density, bins
+
+
+