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

PYMEcs/Analysis/offlineTracker.py

@@ -0,0 +1,130 @@
+# -*- coding: utf-8 -*-
+
+import numpy as np
+from scipy import ndimage
+
+def genRef(refimage, normalised=True):
+        X, Y = np.mgrid[0.0:refimage.shape[0], 0.0:refimage.shape[1]]
+        X -= refimage.shape[0]/2
+        Y -= refimage.shape[1]/2
+        bdry = 20
+        mask = np.ones_like(refimage[:,:,0],dtype='float64')
+        mask[:bdry, :] = 0
+        mask[-bdry:, :] = 0
+        mask[:, :bdry] = 0
+        mask[:,-bdry:] = 0
+
+        maskg = ndimage.gaussian_filter(mask.astype('float'),5)
+
+        calImages = np.zeros(refimage.shape[:2] + (21,))
+        calFTs = np.zeros(refimage.shape[:2] + (21,), dtype='complex64')
+        #refimage3D = refimage.squeeze()
+
+        for i in range(refimage.shape[2]):
+                if not normalised:
+                        d = refimage[:,:,i]
+                        ref = d/d.mean() - 1
+                else:
+                        ref = refimage[:,:,i]
+                
+                calFTs[:,:,i] = np.fft.ifftn(ref)
+                calImages[:,:,i] = ref*maskg
+
+        dz = np.gradient(calImages)[2].reshape(-1, 21)
+        dzn = np.hstack([1./np.dot(dz[:,i], dz[:,i]) for i in range(21)])
+
+        return calImages, calFTs, dz, dzn, maskg, X, Y
+
+def compare(calImages, calFTs, dz, dzn, posInd, image, mask, X, Y, normalised=False, deltaZ = 0.2):        
+        d = 1.0*image
+
+        if not normalised:
+                dm = d/d.mean() - 1
+        else:
+                dm = d
+                
+        FA = calFTs[:,:,posInd]
+        refA = calImages[:,:,posInd] 
+
+        ddz = dz[:,posInd]
+        dznn = dzn[posInd]
+
+        C = np.fft.ifftshift(np.abs(np.fft.ifftn(np.fft.fftn(dm)*FA)))
+        #C = ifftshift(np.abs(ifftn(fftn(A)*ifftn(B))))
+        Cm = C.max()    
+        
+        Cp = np.maximum(C - 0.5*Cm, 0)
+        Cpsum = Cp.sum()
+        
+        dx = (X*Cp).sum()/Cpsum
+        dy = (Y*Cp).sum()/Cpsum
+
+        ds = ndimage.shift(dm, [-dx, -dy])*mask
+        ds_A = (ds - refA)
+
+        dzz = deltaZ*np.dot(ds_A.ravel(), ddz)*dznn
+
+        return dx, dy, dzz, Cm, dm
+
+
+def genRefxy(refimage, normalised=True):
+        X, Y = np.mgrid[0.0:refimage.shape[0], 0.0:refimage.shape[1]]
+        X -= refimage.shape[0]/2
+        Y -= refimage.shape[1]/2
+        bdry = 20
+        mask = np.ones_like(refimage,dtype='float64')
+        mask[:bdry, :] = 0
+        mask[-bdry:, :] = 0
+        mask[:, :bdry] = 0
+        mask[:,-bdry:] = 0
+
+        maskg = ndimage.gaussian_filter(mask.astype('float'),5)
+
+        calImages = np.zeros(refimage.shape[:2])
+        calFTs = np.zeros(refimage.shape[:2], dtype='complex64')
+
+        if not normalised:
+                d = refimage
+                ref = d/d.mean() - 1
+        else:
+                ref = refimage
+
+        calFT = np.fft.ifftn(ref)
+        calImage = ref*maskg
+
+        return calImage, calFT, maskg, X, Y
+
+def comparexy(calImage, calFT, image, mask, X, Y, normalised=False):        
+        d = 1.0*image
+
+        if not normalised:
+                dm = d/d.mean() - 1
+        else:
+                dm = d
+                
+        FA = calFT
+        refA = calImage
+
+        C = np.fft.ifftshift(np.abs(np.fft.ifftn(np.fft.fftn(dm)*FA)))
+        #C = ifftshift(np.abs(ifftn(fftn(A)*ifftn(B))))
+        Cm = C.max()    
+        
+        Cp = np.maximum(C - 0.5*Cm, 0)
+        Cpsum = Cp.sum()
+        
+        dx = (X*Cp).sum()/Cpsum
+        dy = (Y*Cp).sum()/Cpsum
+
+        return dx, dy, Cm, dm
+
+def trackstack(ims,refim,pixx=20.0,pixy=20.0):
+        # from PYMEcs.Analysis.offlineTracker import genRefxy, comparexy
+        calImage, calFT, maskg, X, Y = genRefxy(refim,normalised=False)
+        history=[]
+        for i in range(ims.shape[2]):
+                dx, dy, Cm, dm = comparexy(calImage, calFT, ims[:,:,i], maskg, X, Y)
+                history.append((dx, dy, Cm))
+    
+        ha = np.array(history)
+        return (pixx*ha[:,0],pixy*ha[:,1],ha[:,2]/ha[:,2].max())
+

PYMEcs/Analysis/stackTracker.py

@@ -0,0 +1,180 @@
+import numpy as np
+from scipy import ndimage
+from numpy.fft import fftn, ifftn, fftshift, ifftshift
+import matplotlib.pyplot as plt
+
+# we use this code as a simple and preliminary way to calculate the z-factor
+# this should eventually be reworked as a nicer codebase and also replace/subsume the
+# offline tracker code base
+
+# note that this may or may not work!
+def zdiff(data):
+    zdf = np.zeros_like(data,dtype='f')
+    zdf[:,:,0:-1] = data[:,:,1:]-1.0*data[:,:,0:-1]
+    zdf[:,:,-1] = zdf[:,:,-2]
+    return zdf
+
+# subsample stack from dz0 spacing to dzs sampling, dzs should be even multiple of dz0
+# note: we assume the center image is the target position
+def substack(stack, subsamplefactor, newszhalf=None):
+        ssfac = int(subsamplefactor)
+        zsz = stack.shape[2]
+        zszh = zsz // 2
+        if 2*zszh+1 != zsz:
+                raise RuntimeError("z dimension must be odd")
+        if newszhalf is not None:
+                if newszhalf > zszh:
+                        raise RuntimeError("new stack size must be smaller or equal old stack size")
+                nstack = stack[:,:,zszh-newszhalf:zszh+newszhalf+1]
+                zszh = newszhalf
+        else:
+                nstack = stack
+
+        halfperiods = zszh // ssfac
+        refims = nstack[:,:,zszh-halfperiods*ssfac:zszh+halfperiods*ssfac+1:ssfac]
+
+        return (nstack, refims)
+      
+
+# this one should initialise FFTs etc for a suitable substack and return all the relevant
+# items in a dict (may make class in a future version)
+# return everything as a stackobject, initially just a dict with the required entries
+def initialise_data(stack, subsamplefactor, vsznm, newszhalf=None):
+        nstack, refimages_raw = substack(stack, subsamplefactor, newszhalf=newszhalf)
+        refimages, calImages, calFTs, gradI, gradIsqr_inv, mask, X, Y = genRefData(refimages_raw)
+
+        trackobject = {
+                'stack': nstack,
+                'refimages_raw': refimages_raw,
+                'refimages': refimages,
+                'calImages': calImages,
+                'calFTs': calFTs,
+                'gradI': gradI,
+                'gradIsqr_inv': gradIsqr_inv,
+                'mask': mask,
+                'X': X,
+                'Y': Y,
+                'voxelsize_nm': vsznm,
+                'subsamplefactor': int(subsamplefactor)}
+
+        return trackobject
+
+
+# this one takes an initialised stackobject and returns the relevant shifts by taking
+# the center of the substack as the relevant level to refer to
+def get_shifts_from_stackobject(trackobject):
+        to = trackobject
+        resx = []
+        resy = []
+        resz = []
+
+        refim_zszh = to['refimages'].shape[2] // 2
+        for i in range(to['stack'].shape[2]):
+                image = to['stack'][:,:,i]
+                driftx, drifty, driftz, cm, dm = compare(to['refimages'],
+                                                         to['calImages'],
+                                                         to['calFTs'],
+                                                         to['gradI'],
+                                                         to['gradIsqr_inv'],
+                                                         refim_zszh, image,
+                                                         to['mask'],
+                                                         to['X'],
+                                                         to['Y'],
+                                                         deltaZ=to['subsamplefactor']*to['voxelsize_nm'].z)
+                resx.append(driftx)
+                resy.append(drifty)
+                resz.append(driftz)
+
+
+        dznm = np.array(resz)
+        dxnm = to['voxelsize_nm'].x*np.array(resx)
+        dynm = to['voxelsize_nm'].y*np.array(resy)
+
+        return (dxnm,dynm,dznm)
+
+def fit_and_plot_zf(dxnm,dynm,dznm,trackobject):
+
+        to = trackobject
+        zszh = dznm.shape[0] // 2
+        dzexp = dznm[zszh-4:zszh+5]
+        dztheo = (np.arange(dznm.shape[0])-zszh)*to['voxelsize_nm'].z
+
+        x = dztheo[zszh-3:zszh+4]
+        y = dznm[zszh-3:zszh+4]
+        m, b = np.polyfit(x,y,1)
+
+        plt.figure()
+        plt.plot(dztheo[zszh-4:zszh+5],dznm[zszh-4:zszh+5],'-o')
+        plt.plot(dztheo[zszh-4:zszh+5],m*dztheo[zszh-4:zszh+5],'--')
+
+        zfactor = 1.0 / m
+        font = {'family': 'serif',
+        'color':  'darkred',
+        'weight': 'normal',
+        'size': 14,
+        }
+        plt.text(-150, 50, 'Z-factor = %.2f' % zfactor, fontdict=font)
+
+
+
+def genRefData(refimages_raw, bdry=10, useSimplediff=False):
+        X, Y = np.mgrid[0.0:refimages_raw.shape[0], 0.0:refimages_raw.shape[1]]
+        X -= np.ceil(refimages_raw.shape[0]*0.5)
+        Y -= np.ceil(refimages_raw.shape[1]*0.5)
+
+        mask = np.ones_like(refimages_raw[:,:,0])
+        mask[:bdry, :] = 0
+        mask[-bdry:, :] = 0
+        mask[:, :bdry] = 0
+        mask[:,-bdry:] = 0
+
+        refimages = np.zeros_like(refimages_raw,dtype='f')
+        calImages = np.zeros_like(refimages_raw,dtype='f')
+        calFTs = np.zeros_like(refimages_raw, dtype='complex64')       
+
+        for i in range(refimages_raw.shape[2]):
+            d = refimages_raw[:,:,i] # should we work with offset corrected images or irrelevant?
+            ref = d/d.mean() - 1
+
+            refimages[:,:,i] = ref
+                
+            calFTs[:,:,i] = ifftn(ref)
+            calImages[:,:,i] = ref*mask
+
+        if useSimplediff:
+                gradI = zdiff(calImages).reshape(-1, calImages.shape[2])
+        else:
+                gradI = np.gradient(calImages)[2].reshape(-1, calImages.shape[2])
+        gradIsqr_inv = np.hstack([1./np.dot(gradI[:,i], gradI[:,i]) for i in range(calImages.shape[2])])
+
+        return refimages, calImages, calFTs, gradI, gradIsqr_inv, mask, X, Y
+
+
+def compare(refImages, calImages, calFTs, gradI, gradIsqr_inv, posInd, image, mask, X, Y, deltaZ = 0.2):        
+    d = 1.0*image
+    dm = d/d.mean() - 1
+
+    FA = calFTs[:,:,posInd]
+    refA = calImages[:,:,posInd]
+
+    gradIA = gradI[:,posInd]
+    gradIsqr_invA = gradIsqr_inv[posInd]
+
+    C = ifftshift(np.abs(ifftn(fftn(dm)*FA)))
+        
+    Cm = C.max()    
+        
+    Cp = np.maximum(C - 0.5*Cm, 0)
+    Cpsum = Cp.sum()
+        
+    dx = (X*Cp).sum()/Cpsum
+    dy = (Y*Cp).sum()/Cpsum
+        
+    ds = ndimage.shift(dm, [-dx, -dy])*mask
+        
+    ds_A = (ds - refA)
+        
+    #calculate z offset between actual position and calibration position
+    dz = deltaZ*np.dot(ds_A.ravel(), gradIA)*gradIsqr_invA
+
+    return dx, dy, dz, Cm, dm

PYMEcs/Analysis/timeSeries.py

@@ -0,0 +1,63 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+import logging
+logger = logging.getLogger(__name__)
+
+def interlaceTraces(traces):
+    return np.vstack(traces).transpose().flatten()
+
+# given a series of detected events as input
+# construct a single channel trace for plotting
+# this works by constructing a time point series and
+# a pulse series (0 and 1 values) that goes up and down
+# as dictated by the event series passed in
+#
+# algorithmicly it detects where series of events in consecutive
+# groups begin and end and injects plotting points at those
+# places
+#
+# the returned two arrays can be directly passed to a plot command
+# to produce a "single channel"-like trace
+def generateSeries(t):
+
+    if t.shape[0] <= 1:
+        return ([t[0],t[0],t[0]+1,t[0]+1],[0,1,1,0])
+    
+    dts = t[1:]-t[0:-1]-1
+    dtg = dts[dts>0]
+    nts = dtg.shape[0]
+
+    idx, = np.where(dts>0)
+    one = np.ones_like(idx)
+    z = np.zeros_like(idx)
+
+    tSer = interlaceTraces((t[idx],t[idx],t[idx+1],t[idx+1]))
+    pulseSer = interlaceTraces((one,z,z,one))
+
+    tSerAll = np.hstack(([t[0],t[0]],tSer,[t[-1],t[-1]]))
+    pulseAll = np.hstack(([0,1],pulseSer,[1,0]))
+
+    return (tSerAll, pulseAll)
+
+# this one uses the functionality of generateSeries
+# for all 'clumps' identified by the same clumpIndex
+#
+# it therefore requires that the 'Track single molecule trajectories"
+# has been run; it must be run on the original 'Localisations' data source,
+# *not* the coalesced data source
+#
+# by default it starts a new figure
+# the plot line colour changes between clumps
+# in an effectively random fashion
+def plotClumpSeries(t,ci,newFig = True):
+    cin = np.unique(ci)
+    if newFig:
+        plt.figure()
+
+    for c in cin:
+        tci = t[ci == c]
+        tp, p = generateSeries(tci)
+        plt.plot(tp, p)
+
+    plt.ylim(-0.5,1.5)

PYMEcs/Analysis/trackFiducials.py

@@ -0,0 +1,186 @@
+from __future__ import print_function    # (at top of module)
+
+import numpy as np
+from scipy import ndimage
+from collections import OrderedDict
+import warnings
+
+import logging
+logger = logging.getLogger(__name__)
+
+# this is just a slightly cleaned up version of the core code of
+# Kenny's fiducial tracker from PYMEnf
+
+# currently only does x and y dims
+
+# in this version we enforce that the returned fiducial track
+# starts out of zero
+
+def foffset(t,ft,navg=50):
+    tu,idx = np.unique(t.astype('int'), return_index=True)
+    fu = ft[idx]
+    offs = fu[0:min(navg,fu.shape[0])].mean()
+    return offs
+
+def makeFilter(filtFunc):
+    '''wrapper function for different filters'''
+    def ffcn(t, data, scale):
+        out = {}
+        for k, v in data.items():
+            r_v = v[~np.isnan(v)]
+            r_t = t[~np.isnan(v)]
+            out[k] = filtFunc(np.interp(t, r_t, r_v), scale)
+        return out
+    return ffcn
+
+FILTER_FUNCS = {
+    'Gaussian' : makeFilter(ndimage.gaussian_filter),
+    'Uniform' : makeFilter(ndimage.uniform_filter),
+    # must be int(size), otherwise gets float type error!!!!!
+    'Median' : makeFilter(lambda input, size: ndimage.median_filter(input,int(size)))
+    } 
+
+def extractTrajectoriesClump(ds, clumpRadiusVar = 'error_x', clumpRadiusMultiplier=5.0, 
+                                  timeWindow=25, clumpMinSize=50, align=True):
+                                      
+    import PYME.Analysis.points.DeClump.deClump as deClump
+    #track beads through frames
+    if clumpRadiusVar == '1.0':
+        delta_x = 0*ds['x'] + clumpRadiusMultiplier
+    else:
+        delta_x = clumpRadiusMultiplier*ds[clumpRadiusVar]
+        
+    t = ds['t'].astype('i')
+    x = ds['x'].astype('f4')
+    y = ds['y'].astype('f4')
+    z = ds['z'].astype('f4')
+    delta_x = delta_x.astype('f4')
+    
+    I = np.argsort(t)
+
+    clumpIndex = np.zeros(len(x), dtype='i')
+    isFiducial = np.zeros(len(x), dtype='i')
+    clumpIndex[I] = deClump.findClumpsN(t[I], x[I], y[I], delta_x[I], timeWindow)
+    
+    tMax = t.max()
+    
+    clumpIndices = list(set(clumpIndex))
+
+    x_f = []
+    y_f = []
+    z_f = []
+    clump_sizes = []
+    
+    t_f = np.arange(0, tMax + 1, dtype='i')
+    
+    #loop over all our clumps and extract trajectories
+    for ci in clumpIndices:
+        if ci > 0:
+            clump_mask = (clumpIndex == ci)
+            x_i = x[clump_mask]
+            clump_size = len(x_i)
+            
+            if clump_size > clumpMinSize:
+                y_i = y[clump_mask]
+                z_i = z[clump_mask]
+                t_i = t[clump_mask].astype('i')
+                isFiducial[clump_mask] = 1 # mark the event mask that this is a fiducial
+                
+                x_i_f = np.NaN*np.ones_like(t_f)
+                if align:
+                    x_i_f[t_i]= x_i - x_i.mean()
+                else:
+                    x_i_f[t_i]= x_i
+                    
+                y_i_f = np.NaN*np.ones_like(t_f)
+                if align:
+                    y_i_f[t_i]= y_i - y_i.mean()
+                else:
+                    y_i_f[t_i]= y_i
+                    
+                z_i_f = np.NaN*np.ones_like(t_f)
+                if align:
+                    z_i_f[t_i]= z_i - z_i.mean()
+                else:
+                    z_i_f[t_i]= z_i
+                
+                #clumps.append((x_i_f, y_i_f))
+                x_f.append(x_i_f)
+                y_f.append(y_i_f)
+                z_f.append(z_i_f)
+                clump_sizes.append(len(x_i))
+    
+    #re-order to start with the largest clump
+    clumpOrder = np.argsort(clump_sizes)[::-1]
+    x_f = np.array(x_f)[clumpOrder,:]
+    y_f = np.array(y_f)[clumpOrder,:]
+    z_f = np.array(z_f)[clumpOrder,:]
+
+    return (t_f, x_f, y_f, z_f, isFiducial)
+
+def AverageTrack(ds, tracks, filter='Gaussian', filterScale=10.0, align=True):
+
+    t_f, x_f, y_f, z_f = tracks
+    t = ds['t'].astype('i')
+    
+    # this function does not appear to be used anywhere
+    # def _mf(p, meas):
+    #     '''calculate the offset between trajectories'''
+    #     m_adj = meas + np.hstack([[0], p])[:,None]
+        
+    #     return np.nansum(np.nanvar(m_adj, axis=0))
+        
+    def _align(meas, tol=.1):
+        n_iters = 0
+        
+        dm_old = 5e12
+        dm = 4e12
+        
+        mm = np.nanmean(meas, 0)
+        
+        while ((dm_old - dm) > tol) and (n_iters < 50):  
+            dm_old = dm
+            mm = np.nanmean(meas, 0)        
+            d = np.nanmean(meas - mm, 1)
+            dm = sum(d**2)
+            meas = meas - d[:,None]
+            n_iters +=1
+            print(n_iters, dm)
+
+        # nanmean can generate warnings with all nan values
+        # we catch them in this block only
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore", message='Mean of empty slice')
+            mm = np.nanmean(meas, 0)
+        
+        print('Finished:', n_iters, dm)
+        return mm
+
+    def _simpleav(meas):
+        # as above
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore", message='Mean of empty slice')
+            mm = np.nanmean(meas, 0)
+        return mm
+        
+    if align:
+        x_corr = _align(x_f)
+        y_corr = _align(y_f)
+        z_corr = _align(z_f)
+    else:
+        x_corr = _simpleav(x_f)
+        y_corr = _simpleav(y_f)
+        z_corr = _simpleav(z_f)
+        
+    filtered_corr_woffs = FILTER_FUNCS[filter](t_f, {'x' : x_corr, 'y':y_corr, 'z':z_corr}, filterScale)
+    
+    dims = filtered_corr_woffs.keys()
+    filtered_corr = {}
+    for dim in dims:
+        filtered_corr[dim] = filtered_corr_woffs[dim] - foffset(t_f,filtered_corr_woffs[dim])
+
+    fcorr_columns = {}
+    for dim in dims:
+        fcorr_columns[dim] = np.interp(t, t_f, filtered_corr[dim]) 
+    
+    return fcorr_columns

PYMEcs/Analysis/zerocross.py

@@ -0,0 +1,91 @@
+# this code is borrowed from PyAstronomy
+# I include their license below under which this code was made available
+
+# Copyright (c) 2011, PyA group
+
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this
+# software and associated documentation files (the "Software"), to deal in the Software
+# without restriction, including without limitation the rights to use, copy, modify, merge,
+# publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
+# to whom the Software is furnished to do so, subject to the following conditions:
+
+# The above copyright notice and this permission notice shall be included in all copies
+# or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+# INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+# PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
+# FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+# OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+from __future__ import division
+import numpy as np
+# from PyAstronomy.pyaC import pyaErrors as PE
+
+def zerocross1d(x, y, getIndices=False):
+  """
+    Find the zero crossing points in 1d data.
+    
+    Find the zero crossing events in a discrete data set.
+    Linear interpolation is used to determine the actual
+    locations of the zero crossing between two data points
+    showing a change in sign. Data point which are zero
+    are counted in as zero crossings if a sign change occurs
+    across them. Note that the first and last data point will
+    not be considered whether or not they are zero. 
+    
+    Parameters
+    ----------
+    x, y : arrays
+        Ordinate and abscissa data values.
+    getIndices : boolean, optional
+        If True, also the indicies of the points preceding
+        the zero crossing event will be returned. Default is
+        False.
+    
+    Returns
+    -------
+    xvals : array
+        The locations of the zero crossing events determined
+        by linear interpolation on the data.
+    indices : array, optional
+        The indices of the points preceding the zero crossing
+        events. Only returned if `getIndices` is set True.
+  """
+  
+  # Check sorting of x-values
+  if np.any((x[1:] - x[0:-1]) <= 0.0):
+    raise( RuntimeError("zerocross1d: The x-values must be sorted in ascending order! " +
+                        "Sort the data prior to calling zerocross1d."))
+  
+  # Indices of points *before* zero-crossing
+  indi = np.where(y[1:]*y[0:-1] < 0.0)[0]
+  
+  # Find the zero crossing by linear interpolation
+  dx = x[indi+1] - x[indi]
+  dy = y[indi+1] - y[indi]
+  zc = -y[indi] * (dx/dy) + x[indi]
+  
+  # What about the points, which are actually zero
+  zi = np.where(y == 0.0)[0]
+  # Do nothing about the first and last point should they
+  # be zero
+  zi = zi[np.where((zi > 0) & (zi < x.size-1))]
+  # Select those point, where zero is crossed (sign change
+  # across the point)
+  zi = zi[np.where(y[zi-1]*y[zi+1] < 0.0)]
+  
+  # Concatenate indices
+  zzindi = np.concatenate((indi, zi)) 
+  # Concatenate zc and locations corresponding to zi
+  zz = np.concatenate((zc, x[zi]))
+  
+  # Sort by x-value
+  sind = np.argsort(zz)
+  zz, zzindi = zz[sind], zzindi[sind]
+  
+  if not getIndices:
+    return zz
+  else:
+    return zz, zzindi