python-microscopy 25.6.5__cp39-cp39-win_amd64.whl

PYME/Analysis/points/astigmatism/astigTools.py

@@ -0,0 +1,338 @@
+
+import numpy as np
+from scipy.interpolate import LSQUnivariateSpline, UnivariateSpline
+
+from . import astiglookup
+
+def find_and_add_zRange(astig_library, rough_knot_spacing=50.):
+    """
+    Find range about highest intensity point over which sigmax - sigmay is monotonic.
+    Note that astig_library[psfIndex]['zCenter'] should contain the offset in nm to the brightest z-slice
+
+    Parameters
+    ----------
+    astig_library : List
+        Elements are dictionaries containing PSF fit information
+    rough_knot_spacing : Float
+        Smoothing is applied to (sigmax-sigmay) before finding the region over which it is monotonic. A cubic spline is
+        fit to (sigmax-sigmay) using knots spaced roughly be rough_knot_spacing (units of nanometers, i.e. that of
+        astig_library[ind]['z']). To make deciding the knots convenient, they are spaced an integer number of z-steps,
+        so the actual knot spacing is rounded to this.
+
+    Returns
+    -------
+    astig_library : List
+        The astigmatism calibration list which is taken as an input is modified in place and returned.
+
+    """
+    import scipy.interpolate as terp
+
+    for ii in range(len(astig_library)):
+        # figure out where to place knots. Note that we subsample our z-positions so we satisfy Schoenberg-Whitney
+        # conditions, i.e. that our spline has adequate support
+        z_steps = np.unique(astig_library[ii]['z'])
+        dz_med = np.median(np.diff(z_steps))
+        smoothing_factor = max(int(rough_knot_spacing / dz_med), 2)  # make sure knots are adequately supported
+        knots = z_steps[1:-1:smoothing_factor]
+        # make the spline
+        dsig = terp.LSQUnivariateSpline(astig_library[ii]['z'], astig_library[ii]['dsigma'], knots)
+
+        # mask where the sign is the same as the center
+        zvec = np.linspace(np.min(astig_library[ii]['z']), np.max(astig_library[ii]['z']), 1000)
+        sgn = np.sign(np.diff(dsig(zvec)))
+        halfway = np.absolute(zvec - astig_library[ii]['zCenter']).argmin()  # len(sgn)/2
+        notmask = sgn != sgn[halfway]
+
+        # find region of dsigma which is monotonic after smoothing
+        try:
+            lowerZ = zvec[np.where(notmask[:halfway])[0].max()]
+        except ValueError:
+            lowerZ = zvec[0]
+        try:
+            upperZ = zvec[(halfway + np.where(notmask[halfway:])[0].min() - 1)]
+        except ValueError:
+            upperZ = zvec[-1]
+        astig_library[ii]['zRange'] = [lowerZ, upperZ]
+
+    return astig_library
+
+def lookup_astig_z(fres, astig_calibrations, rough_knot_spacing=75., plot=False):
+    """
+    Generates a look-up table of sorts for z based on sigma x/y fit results and calibration information. If a molecule
+    appears on multiple planes, sigma values from both planes will be used in the look up.
+
+    Parameters
+    ----------
+    fres : dict-like
+        Contains fit results (localizations) to be mapped in z
+    astig_calibrations : list
+        Each element is a dictionary corresponding to a multiview channel, which contains the x and y PSF widths at
+        various z-positions
+    rough_knot_spacing : Float
+        Smoothing is applied to the sigmax/y look-up curves by fitting a cubic spline with knots spaced roughly at
+        intervals of rough_knot_spacing (in nanometers). There is potentially rounding within the step-size of the
+        astigmatism calibration to make knot placing more convenient.
+    plot : bool
+        Flag to toggle plotting
+
+    Returns
+    -------
+    z : ndarray
+        astigmatic Z-position of each localization in fres
+    zerr : ndarray
+        discrepancies between sigma values and the PSF calibration curves
+
+    """
+    # fres = pipeline.selectedDataSource.resultsSource.fitResults
+    # numMolecules = len(fres['x']) # there is no guarantee that fitResults_x0 will be present - change to x
+    numChans = len(astig_calibrations)
+
+    # find overall min and max z values
+    z_min = 0
+    z_max = 0
+    for astig_cal in astig_calibrations: #more idiomatic way of looping through list - also avoids one list access / lookup
+        r_min, r_max = astig_cal['zRange']
+        z_min = min(z_min, r_min)
+        z_max = max(z_max, r_max)
+
+    # generate z vector for interpolation
+    zVal = np.arange(z_min, z_max)
+
+    # generate look up table of sorts
+    sigCalX = []
+    sigCalY = []
+    for i, astig_cal in enumerate(astig_calibrations):
+        zdat = np.array(astig_cal['z'])
+
+        # grab indices of range we trust
+        z_range = astig_cal['zRange']
+        z_valid_mask = (zdat > z_range[0])*(zdat < z_range[1])
+        z_valid = zdat[z_valid_mask]
+
+        # generate splines with knots spaced roughly as rough_knot_spacing [nm]
+        z_steps = np.unique(z_valid)
+        dz_med = np.median(np.diff(z_steps))
+        smoothing_factor = int(rough_knot_spacing / (dz_med))
+        knots = z_steps[1:-1:smoothing_factor]
+
+        sigCalX.append(LSQUnivariateSpline(z_valid,np.array(astig_cal['sigmax'])[z_valid_mask], knots, ext='const')(zVal))
+        sigCalY.append(LSQUnivariateSpline(z_valid,np.array(astig_cal['sigmay'])[z_valid_mask], knots, ext='const')(zVal))
+
+    sigCalX = np.array(sigCalX)
+    sigCalY = np.array(sigCalY)
+
+    # #allocate arrays for the estimated z positions and their errors
+    # z = np.zeros(numMolecules)
+    # zerr = 1e4 * np.ones(numMolecules)
+    #
+    # failures = 0
+    chans = np.arange(numChans)
+
+    #extract our sigmas and their errors
+    #doing this here means we only do the string operations and look-ups once, rather than once per molecule
+    s_xs = np.abs(np.array([fres['sigmax%i' % ci] for ci in chans]))
+    s_ys = np.abs(np.array([fres['sigmay%i' % ci] for ci in chans]))
+    esxs = [fres['error_sigmax%i' % ci] for ci in chans]
+    esys = [fres['error_sigmay%i' % ci] for ci in chans]
+    wXs = np.array([1. / (esx_i*esx_i) for esx_i in esxs])
+    wYs = np.array([1. / (esy_i*esy_i) for esy_i in esys])
+
+    if plot:
+        from matplotlib import pyplot as plt
+
+        plt.figure()
+        plt.subplot(211)
+        for astig_cal, interp_sigx, col in zip(astig_calibrations, sigCalX, ['r', 'g', 'b', 'c']):
+            plt.plot(astig_cal['z'], astig_cal['sigmax'], ':', c=col)
+            plt.plot(zVal, interp_sigx, c=col)
+
+        plt.subplot(212)
+        for astig_cal, interp_sigy, col in zip(astig_calibrations, sigCalY, ['r', 'g', 'b', 'c']):
+            plt.plot(astig_cal['z'], astig_cal['sigmay'], ':', c=col)
+            plt.plot(zVal, interp_sigy, c=col)
+
+    # _lenz_chunked = np.floor(len(zVal)) - 1
+    # sigCalX_chunked = np.ascontiguousarray(sigCalX[:,::100])
+    # sigCalY_chunked = np.ascontiguousarray(sigCalY[:,::100])
+    #
+    # for i in range(numMolecules):
+    #     #TODO - can we avoid this loop?
+    #     wX = wXs[:, i]
+    #     wY = wYs[:, i]
+    #     sx = sxs[:, i]
+    #     sy = sys[:, i]
+    #
+    #     wSum = (wX + wY).sum()
+    #
+    #     #estimate the position in two steps - coarse then fine
+    #
+    #     #coarse step:
+    #     errX = (wX[:,None] * (sx[:, None] - sigCalX_chunked)**2).sum(0)
+    #     errY = (wY[:, None] * (sy[:, None] - sigCalY_chunked)**2).sum(0)
+    #
+    #     err = (errX + errY) / wSum
+    #     loc_coarse = min(max(np.argmin(err), 1), _lenz_chunked)
+    #
+    #     fine_s =  100*(loc_coarse - 1)
+    #     fine_end = 100*(loc_coarse + 1)
+    #
+    #     #print loc_coarse, fine_s, fine_end, sigCalX.shape
+    #
+    #     #fine step
+    #     errX = (wX[:, None] * (sx[:, None] - sigCalX[:,fine_s:fine_end]) ** 2).sum(0)
+    #     errY = (wY[:, None] * (sy[:, None] - sigCalY[:,fine_s:fine_end]) ** 2).sum(0)
+    #
+    #     err = (errX + errY) / wSum
+    #     minLoc = np.argmin(err)
+    #
+    #     z[i] = -zVal[fine_s + minLoc]
+    #     zerr[i] = np.sqrt(err[minLoc])
+
+    zi, ze = astiglookup.astig_lookup(sigCalX.T.astype('f'), sigCalY.T.astype('f'), s_xs.T.astype('f'),
+                                      s_ys.T.astype('f'), wXs.T.astype('f'), wYs.T.astype('f'))
+
+    print('used c lookup')
+
+    z = -zVal[zi]
+    zerr = np.sqrt(ze)
+
+
+    #print('%i localizations did not have sigmas in acceptable range/planes (out of %i)' % (failures, numMolecules))
+
+    return z, zerr
+
+def lookup_astig_z_dsigma(fres, astig_calibrations, rough_knot_spacing=75., plot=False):
+    """
+    Looks up the z position based on the difference between sigmax and sigmay. When compared to lookup_astig_z, 
+    which attempts to match sigmax and sigmay, can work across multiple channels, and will take advantage of biplane
+    information this method will only work for a single channel (or focal plane) and is likely less accurate.
+    It should, however, be somewhat more robust to errors in the calibration measurment and/or sample-induced changes in the PSF.
+
+    Parameters
+    ----------
+    fres : dict-like
+        Contains fit results (localizations) to be mapped in z
+    astig_calibrations : list
+        Each element is a dictionary corresponding to a multiview channel, which contains the x and y PSF widths at
+        various z-positions
+    rough_knot_spacing : Float
+        Smoothing is applied to the sigmax/y look-up curves by fitting a cubic spline with knots spaced roughly at
+        intervals of rough_knot_spacing (in nanometers). There is potentially rounding within the step-size of the
+        astigmatism calibration to make knot placing more convenient.
+    plot : bool
+        Flag to toggle plotting
+
+    Returns
+    -------
+    z : ndarray
+        astigmatic Z-position of each localization in fres
+    zerr : ndarray
+        discrepancies between sigma values and the PSF calibration curves
+
+    """
+    numChans = len(astig_calibrations)
+    assert(numChans == 1) #this method only works for a single channel
+
+    astig_cal = astig_calibrations[0]
+
+    # find min and max z values for the monotonic region
+    z_min, z_max = astig_cal['zRange']
+
+    # generate z vector for interpolation
+    zVal = np.arange(z_min, z_max)
+
+    zdat = np.array(astig_cal['z'])
+
+    # grab indices of range we trust
+    z_range = astig_cal['zRange']
+    z_valid_mask = (zdat > z_range[0])*(zdat < z_range[1])
+    z_valid = zdat[z_valid_mask]
+
+    # generate splines with knots spaced roughly as rough_knot_spacing [nm]
+    z_steps = np.unique(z_valid)
+    dz_med = np.median(np.diff(z_steps))
+    smoothing_factor = int(rough_knot_spacing / (dz_med))
+    knots = z_steps[1:-1:smoothing_factor]
+
+    sigCalX = LSQUnivariateSpline(z_valid,np.array(astig_cal['sigmax'])[z_valid_mask], knots, ext='const')
+    sigCalY = LSQUnivariateSpline(z_valid,np.array(astig_cal['sigmay'])[z_valid_mask], knots, ext='const')
+
+    #extract our sigmas and their errors
+    #doing this here means we only do the string operations and look-ups once, rather than once per molecule
+    s_xs = np.abs(fres['sigmax'])
+    s_ys = np.abs(fres['sigmay'])
+    esxs = fres['error_sigmax'] 
+    esys = fres['error_sigmay'] 
+
+    #create lookup table for dsigma
+    dsig_cal_val = np.array(astig_cal['dsigma'])[z_valid_mask]
+    dsigCal = UnivariateSpline(dsig_cal_val, z_valid, ext='const')
+
+    # calculate dsigma and do lookup
+    dsigma = s_xs - s_ys
+    z = dsigCal(dsigma)
+
+    # calculate error - note this is pretty crude, and looks at how well the estimated z value predicts the x and y sigmas
+
+    pred_sx = sigCalX(z)
+    pred_sy = sigCalY(z)
+
+    
+    zerr = np.sqrt(((s_xs - pred_sx)**2 + (s_ys - pred_sy)**2))
+    
+
+    # if plot:
+    #     from matplotlib import pyplot as plt
+
+    #     plt.figure()
+    #     plt.subplot(211)
+    #     for astig_cal, interp_sigx, col in zip(astig_calibrations, sigCalX, ['r', 'g', 'b', 'c']):
+    #         plt.plot(astig_cal['z'], astig_cal['sigmax'], ':', c=col)
+    #         plt.plot(zVal, interp_sigx, c=col)
+
+    #     plt.subplot(212)
+    #     for astig_cal, interp_sigy, col in zip(astig_calibrations, sigCalY, ['r', 'g', 'b', 'c']):
+    #         plt.plot(astig_cal['z'], astig_cal['sigmay'], ':', c=col)
+    #         plt.plot(zVal, interp_sigy, c=col)
+
+    # _lenz_chunked = np.floor(len(zVal)) - 1
+    # sigCalX_chunked = np.ascontiguousarray(sigCalX[:,::100])
+    # sigCalY_chunked = np.ascontiguousarray(sigCalY[:,::100])
+    #
+    # for i in range(numMolecules):
+    #     #TODO - can we avoid this loop?
+    #     wX = wXs[:, i]
+    #     wY = wYs[:, i]
+    #     sx = sxs[:, i]
+    #     sy = sys[:, i]
+    #
+    #     wSum = (wX + wY).sum()
+    #
+    #     #estimate the position in two steps - coarse then fine
+    #
+    #     #coarse step:
+    #     errX = (wX[:,None] * (sx[:, None] - sigCalX_chunked)**2).sum(0)
+    #     errY = (wY[:, None] * (sy[:, None] - sigCalY_chunked)**2).sum(0)
+    #
+    #     err = (errX + errY) / wSum
+    #     loc_coarse = min(max(np.argmin(err), 1), _lenz_chunked)
+    #
+    #     fine_s =  100*(loc_coarse - 1)
+    #     fine_end = 100*(loc_coarse + 1)
+    #
+    #     #print loc_coarse, fine_s, fine_end, sigCalX.shape
+    #
+    #     #fine step
+    #     errX = (wX[:, None] * (sx[:, None] - sigCalX[:,fine_s:fine_end]) ** 2).sum(0)
+    #     errY = (wY[:, None] * (sy[:, None] - sigCalY[:,fine_s:fine_end]) ** 2).sum(0)
+    #
+    #     err = (errX + errY) / wSum
+    #     minLoc = np.argmin(err)
+    #
+    #     z[i] = -zVal[fine_s + minLoc]
+    #     zerr[i] = np.sqrt(err[minLoc])
+
+
+    #print('%i localizations did not have sigmas in acceptable range/planes (out of %i)' % (failures, numMolecules))
+
+    return z, zerr

PYME/Analysis/points/astigmatism/setup.py

@@ -0,0 +1,54 @@
+#!/usr/bin/python
+
+##################
+# setup.py
+#
+# Copyright David Baddeley, 2009
+# 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/>.
+#
+##################
+
+#!/usr/bin/env python
+import sys
+if sys.platform == 'darwin':#MacOS
+    linkArgs = ['-headerpad_max_install_names']
+else:
+    linkArgs = ['-static-libgcc']
+
+def configuration(parent_package = '', top_path = None):
+    from numpy.distutils.misc_util import Configuration, get_numpy_include_dirs
+    config = Configuration('astigmatism', parent_package, top_path)
+
+    config.add_extension('astiglookup',
+        sources=['astiglookup.c'],
+        include_dirs = [get_numpy_include_dirs()],
+	extra_compile_args = ['-O3', '-fno-exceptions', ],#,'-march=native', '-mtune=native'],
+        extra_link_args=linkArgs)
+
+    return config
+
+if __name__ == '__main__':
+    from numpy.distutils.core import setup
+    setup(description = 'c coded lookup function for astigmatic z mapping',
+    	author = 'David Baddeley',
+       	author_email = 'd.baddeley@auckland.ac.nz',
+       	url = '',
+       	long_description = """
+Provides a c-funtion for the fast & memory efficeint computation of a histogram of pairwise distances
+""",
+          license = "Proprietary",
+          **configuration(top_path='').todict()
+          )

PYME/Analysis/points/cluster_morphology.py

@@ -0,0 +1,199 @@
+#!/usr/bin/python
+##################
+# objectMeasurements.py
+#
+# Copyright David Baddeley, Andrew Barentine 2017
+# 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 get_labels_from_image(label_image, points, minimum_localizations=1):
+    """
+    Function to extract labels from a segmented image (2D or 3D) at given locations.
+    
+    TODO - Move this somewhere more sensible and drop minimum_localizations in favour of post-filtering.
+
+    Parameters
+    ----------
+    label_image: PYME.IO.image.ImageStack instance
+        an image containing object labels
+    points: tabular-like (PYME.IO.tabular, np.recarray, pandas DataFrame) containing 'x', 'y' & 'z' columns
+        locations at which to extract labels
+
+    Returns
+    -------
+    ids: Label number from image, mapped to each localization within that label
+    numPerObject: Number of localizations within the label that a given localization belongs to
+
+    """
+    from PYME.Analysis.points.coordinate_tools import pixel_index_of_points_in_image
+
+    pixX, pixY, pixZ = pixel_index_of_points_in_image(label_image, points)
+
+    label_data = label_image.data
+
+    if label_data.shape[2] == 1:
+        # disregard z for 2D images
+        pixZ = np.zeros_like(pixX)
+
+    ind = (pixX < label_data.shape[0]) * (pixY < label_data.shape[1]) * (pixX >= 0) * (pixY >= 0) * (pixZ >= 0) * (
+        pixZ < label_data.shape[2])
+
+    ids = np.zeros_like(pixX)
+
+    # assume there is only one channel
+    ids[ind] = np.atleast_3d(label_data[:, :, :, 0].squeeze())[pixX[ind], pixY[ind], pixZ[ind]].astype('i')
+
+    # check if we keep all labels
+    if minimum_localizations > 1:  # skip if we don't need this
+        labels, counts = np.unique(ids, return_counts=True)
+        labels, counts = labels[1:], counts[1:]  # ignore unlabeled points, or zero-label
+        for label, count in zip(labels, counts):
+            if count < minimum_localizations:
+                ids[ids == label] = 0
+
+    numPerObject, b = np.histogram(ids, np.arange(ids.max() + 1.5) + .5)
+
+    return ids, numPerObject
+
+measurement_dtype = [('count', '<i4'),
+                     ('x', '<f4'), ('y', '<f4'), ('z', '<f4'),
+                     ('gyrationRadius', '<f4'),
+                     ('median_abs_deviation', '<f4'),
+                     ('axis0', '<3f4'), ('axis1', '<3f4'), ('axis2', '<3f4'),
+                     ('sigma0', '<f4'), ('sigma1', '<f4'), ('sigma2', '<f4'),
+                     ('sigma_x', '<f4'), ('sigma_y', '<f4'), ('sigma_z', '<f4'),
+                     ('anisotropy', '<f4'),
+                     ('theta', '<f4'), ('phi', '<f4')]
+
+def measure_3d(x, y, z, output=None):
+    """
+    Calculates various metrics for a single cluster, whose 3D coordinates are input. 'output', an optional input
+    argument, allows one to use a single structured array to contain measures for multiple clusters. See
+    PYME.recipes.localisations.MeasureClusters3D
+
+    Parameters
+    ----------
+    x : ndarray
+        x-positions, typically in nanometers
+    y : ndarray
+        y-positions, typically in nanometers
+    z : ndarray
+        z-positions, typically in nanometers
+    output : dict-like
+        If present, output will have measurements written into it, otherwise a structured array will be created and
+        returned
+
+    Returns
+    -------
+    output : dict-like, structured ndarray
+        dict-like object, typically a structured ndarray containing the following measurements:
+        count : int
+            Number of localizations (points) in the cluster
+        x : float
+            x center of mass
+        y : float
+            y center of mass
+        z : float
+            z center of mass
+        gyrationRadius : float
+            root mean square displacement to center of cluster, a measure of compaction or spatial extent see also
+            supplemental text of DOI: 10.1038/nature16496
+        median_abs_deviation : float
+            median absolute deviation, i.e. median of the radius from the 
+            median (x, y, z) position of the cluster
+        axis0 : ndarray, shape (3,)
+            principle axis which accounts for the largest variance of the cluster, i.e. corresponds to the largest
+            eigenvalue
+        axis1 : ndarray, shape (3,)
+            next principle axis
+        axis2 : ndarray, shape (3,)
+            principle axis corresponding to the smallest eigenvalue
+        sigma0 : float
+            standard deviation along axis0
+        sigma1 : float
+            standard deviation along axis1
+        sigma2 : float
+            standard deviation along axis2
+        anisotropy : float
+            metric of anisotropy based on the spread along principle axes. Standard deviations of alpha * [1, 0, 0],
+            where alpha is a scalar, will result in an 'anisotropy' value of 1, i.e. maximally anisotropic. Completely
+            isotropic clusters will have equal standard deviations, i.e. alpha * [1, 1, 1], which corresponds to an
+            'anisotropy' value of 0. Intermediate cases result in values between 0 and 1.
+        theta : float
+            Azimuthal angle, in radians, along which the principle axis (axis0) points
+        phi : float
+            Zenith angle, in radians, along which the principle axis (axis0) points
+
+    """
+    if output is None:
+        output = np.zeros(1, measurement_dtype)
+    
+    #count
+    N = len(x)
+    output['count'] = N
+    if N < 3:
+        import warnings
+        warnings.warn('measure_3D can only be used on clusters of size 3 or larger', UserWarning)
+        return
+    
+    #centroid
+    xc, yc, zc = x.mean(), y.mean(), z.mean()
+    
+    output['x'] = xc
+    output['y'] = yc
+    output['z'] = zc
+    
+    #find mean-subtracted points
+    x_c, y_c, z_c = x - xc, y - yc, z - zc
+    xx_c = x_c * x_c
+    yy_c = y_c * y_c
+    zz_c = z_c * z_c
+    # calculate standard deviations along cartesian coords, including bessel's correction
+    output['sigma_x'] = np.sqrt(xx_c.sum() / (N - 1))
+    output['sigma_y'] = np.sqrt(yy_c.sum() / (N - 1))
+    output['sigma_z'] = np.sqrt(zz_c.sum() / (N - 1))
+    
+    #radius of gyration and median absolute deviation
+    output['gyrationRadius'] = np.sqrt(np.mean(xx_c + yy_c + zz_c))
+    output['median_abs_deviation'] = np.median(np.sqrt(
+        (x - np.median(x)) ** 2 + (y - np.median(y)) ** 2 + (z - np.median(z)) ** 2
+    ))
+
+    #principle axes
+    u, s, v = np.linalg.svd(np.vstack([x_c, y_c, z_c]).T)
+
+    standard_deviations = s / np.sqrt(N - 1)  # with bessel's correction
+    for i in range(3):
+        output['axis%d' % i] = v[i]
+        # std. deviation along axes
+        output['sigma%d' % i] = standard_deviations[i]
+
+    # similar to Basser, P. J., et al. doi.org/10.1006/jmrb.1996.0086
+    # note that singular values are square roots of the eigenvalues. Use the sample standard deviation rather than pop.
+    output['anisotropy'] = np.sqrt(np.var(standard_deviations**2, ddof=1)) / (np.sqrt(3) * np.mean(standard_deviations**2))
+    
+    pa = v[0]
+    #angle of principle axis
+    output['theta'] = np.arctan(pa[0]/pa[1])
+    output['phi'] = np.arcsin(pa[2])
+    
+    #TODO - compactness based on pairwise distances?
+    
+    return output
+