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

PYMEcs/Analysis/Paraflux.py

@@ -0,0 +1,218 @@
+import matplotlib.pyplot as plt
+import numpy as np
+import logging
+logger = logging.getLogger(__file__)
+import pandas as pd
+import os
+
+from PYMEcs.pyme_warnings import warn
+
+# note that currently everything is hard coded for the standard 3D sequence
+# TODO: should really check the metadata we have for (recent) zarr and check the CCRLimit array etc
+#       and figure things out from that!!
+
+
+# --- start Alex B contributed functions to (possibly save) and plot ITR stats (Paraflux like) ---
+def paraflux_mk_df_fm(mfxdata):
+    # Convert structured array (original mfx data) to DataFrame (containing all data from MFX experiment)
+    df_mfx = pd.DataFrame()
+    for name in mfxdata.dtype.names:
+        col = mfxdata[name]
+        if col.ndim == 1:
+            df_mfx[name] = col
+        else:
+            n_dim = col.shape[1]
+            expanded = pd.DataFrame(col.tolist(), index=df_mfx.index if not df_mfx.empty else None)
+            if name in ['loc', 'lnc']:
+                labels = ["x", "y", "z"]
+                expanded.columns = [f"{name}_{labels[i]}" for i in range(n_dim)]
+            elif name == 'dcr':
+                expanded.columns = [f"{name}_{i+1}" for i in range(n_dim)]
+            else:
+                expanded.columns = [f"{name}_{i}" for i in range(n_dim)]
+            df_mfx = pd.concat([df_mfx, expanded], axis=1)
+
+    # Create failure_map (used to interpret failure reasons in analyze_failures)
+    failure_map = {
+        1: "Valid final", 2: "Valid not final",
+        4: "Derived iteration", 5: "Reserved",
+        6: "CFR failure", 8: "No signal",
+        9: "DAC out of range", 11: "Background measurement"
+    }
+
+    return (df_mfx, failure_map)
+
+# ==================================================
+# --- Analysis functions ( Paraflux-like) ---
+# ==================================================
+
+# Create a df with list of vld tids per iteration + additional basic stats
+def build_valid_df(df_mfx):
+    if not isinstance(df_mfx, pd.DataFrame): # Convert to DataFrame if input is structured array
+        df = pd.DataFrame(df_mfx)
+    else:
+        df = df_mfx.copy()
+    df_valid = df[df['vld']] # Select only valid localizations
+    vld_itr = df_valid.groupby('itr')['tid'].apply(lambda x: list(set(x))).reset_index() # Get list of unique tids per iteration
+    vld_itr['Axis'] = np.where(vld_itr['itr'] % 2 == 0, 'x,y', 'z') # Add a col with axis of each iteration 
+    vld_itr['vld loc count'] = vld_itr['tid'].apply(len) # Count valid locs per iteration
+    vld_itr['failed loc count'] = vld_itr['vld loc count'].shift(1, fill_value=vld_itr['vld loc count'].iloc[0]) - vld_itr['vld loc count'] # Calculate failed loc count per iteration
+    vld_itr.loc[0, 'failed loc count'] = 0 # Set failed loc count of first iteration to 0 (instead of NaN)
+    vld_itr['failed loc cum sum'] = vld_itr['failed loc count'].cumsum() # Cumulative sum of failed locs
+    return vld_itr
+
+# Compute percentages of passed and failed localizations (from build_valid_df)
+def compute_percentages(vld_itr):
+    initial_count = vld_itr['vld loc count'].iloc[0] # Percentage calculations are based on initial count of valid locs
+    vld_itr['passed itr %'] = (vld_itr['vld loc count'] * 100 / initial_count).round(1)
+    vld_itr['failed % per itr'] = (vld_itr['failed loc count'] * 100 / initial_count).round(1)
+    pair_sums = {} # This is done to mimic results from Paraflux
+    for i in range(1, len(vld_itr), 2):
+        pair_sums[i] = vld_itr.loc[i-1:i, 'failed % per itr'].sum().round(1)
+    vld_itr['failed % per itr pairs'] = vld_itr.index.map(pair_sums)
+    vld_itr['failed cum sum %'] = vld_itr['failed % per itr'].cumsum().round(1)
+    return vld_itr
+
+# Analyze failures between consecutive iterations and categorize them based on failure_map (found on wiki from Abberior)
+def analyze_failures(vld_itr, df_mfx, failure_map):
+    def analyze_failures_single_steps(vld_itr, df, itr_from, itr_to, failure_map):
+        tids_from = set(vld_itr.loc[vld_itr['itr'] == itr_from, 'tid'].iloc[0]) # Select valid tids of the previous iteration
+        tids_to   = set(vld_itr.loc[vld_itr['itr'] == itr_to, 'tid'].iloc[0]) # Select valid tids of the current iteration
+        failed_tids = tids_from - tids_to # Determine tids that failed in the current iteration
+        failed_df = df[df['tid'].isin(failed_tids) & (df['itr'] == itr_to)] # Create a df with only failed tids in the current iteration
+        counts = failed_df['sta'].value_counts().rename_axis("sta").reset_index(name="count") # Count failure reasons
+        counts["reason"] = counts["sta"].map(failure_map).fillna("Other") # Map failure reasons using failure_map
+        counts.insert(0, "itr", itr_to) # Add iteration column
+        return counts
+
+    pairs = [(i, i+1) for i in range(vld_itr['itr'].max())] # Create pairs of consecutive iterations
+    # Analyze failures for each pair and concatenate results
+    failure_results = pd.concat(
+        [analyze_failures_single_steps(vld_itr, df_mfx, i_from, i_to, failure_map) for i_from, i_to in pairs],
+        ignore_index=True
+    ) 
+    # Pivot the results to have failure reasons as columns
+    failure_pivot = failure_results.pivot_table( 
+        index="itr", columns="reason", values="count", fill_value=0
+    ).reset_index() 
+    return vld_itr.merge(failure_pivot, on="itr", how="left")
+
+# Compute percentages for failure reasons
+def add_failure_metrics(vld_itr, initial_count):
+    cfr_map = {5: 4, 7: 6} #map ITR where CFR failures occurs
+    vld_itr['CFR failure %'] = np.nan # Initialize column with NaNs
+    # Calculate CFR failure percentages based on cfr_map
+    for target_itr, source_itr in cfr_map.items():
+        if not vld_itr.loc[vld_itr['itr'] == source_itr, 'CFR failure'].empty: # Check if CFR failure data exists for the source iteration
+            val = vld_itr.loc[vld_itr['itr'] == source_itr, 'CFR failure'].values[0] # Get the CFR failure count
+            vld_itr.loc[vld_itr['itr'] == target_itr, 'CFR failure %'] = (val / initial_count * 100).round(1) # Calculate percentage and assign to target iteration
+    # Calculate No signal percentage for each iteration       
+    vld_itr['No signal %'] = (vld_itr['No signal'] * 100 / initial_count).round(1)
+    # Define groups of iterations for No signal percentage calculation
+    no_signal_groups = {1: [0, 1],3: [2, 3], 5: [4, 5], 7: [6, 7], 9: [8, 9]}
+    # Calculate No signal percentage for each group and map to iterations
+    no_signal_pct = {
+        target_itr: (vld_itr.loc[vld_itr['itr'].isin(group), 'No signal'].sum() / initial_count * 100).round(1)
+        for target_itr, group in no_signal_groups.items()
+    }
+    vld_itr['No signal % per itr pairs'] = vld_itr['itr'].map(no_signal_pct)
+    return vld_itr
+
+# Plot like in Paraflux
+def paraflux_itr_plot(vld_paraflux):
+    # Mapping rules
+    label_map = {
+        "passed": "Passed",
+        "CFR": "CFR-filtered",
+        "No signal": "Dark",
+        "DAC": "Out of range",
+        "Other": "Other",
+    }
+
+    # Function to get pretty label based on the label map (substring matching from vld_paraflux col names)
+    def pretty_label(colname):
+        """Map colname to user-friendly label based on substring rules."""
+        for key, label in label_map.items():
+            if key.lower() in colname.lower():
+                return label
+        return colname  # fallback: keep original name
+
+    # Keep only odd iterations (Paraflux style, i.e., 1, 3, 5, 7, 9)
+    vld_paraflux = vld_paraflux[vld_paraflux['itr'] % 2 == 1]
+
+    # Set figure size
+    plt.figure(figsize=(8, 6))
+
+    # Base positions
+    r1 = np.arange(len(vld_paraflux)) # Define the positions for each bar
+    names = vld_paraflux['itr'] # Names of group
+    barWidth = 0.85 # Bar width
+
+    # Colors (extendable if more cols are added)
+    colors = ["#0072B2", "#009E73", "#D55E00", "#E69F00", "#CC79A7"]
+
+    # Define the bottom position for stacking
+    bottompos = np.zeros(len(vld_paraflux))
+
+    # Plot each column as a stacked bar
+    for i, col in enumerate(vld_paraflux.columns[1:]): # Enumerate over all columns except 'itr'
+        vals = vld_paraflux[col].fillna(0) # Get the values for the current column, filling NaNs with 0
+        labels = pretty_label(col) # Get the pretty label for the legend
+
+        plt.bar(
+            r1, vals, bottom=bottompos,
+            color=colors[i % len(colors)],
+            edgecolor="white", width=barWidth, label=labels
+        ) # Create the bar
+
+        # Add labels inside each bar
+        for j, v in enumerate(vals):
+            if v > 0:
+                plt.text(r1[j], bottompos[j] + v / 2, f"{v:.1f}%", # Only add text if value > 0
+                        ha="center", va="center",
+                        color="black",
+                        fontsize=9)
+
+        bottompos += vals.values
+
+    # X/Y labels
+    plt.xticks(r1, names)
+    plt.xlabel("Iteration")
+    plt.ylabel("Events (%)")
+    plt.axhline(y=100, color="gray", linestyle="--", linewidth=1)
+
+    plt.legend(loc="upper right", fontsize=9)
+    plt.tight_layout()
+    plt.show()
+
+# Main function to compute stats of failed and valid localizations and save results
+def compute_vld_stats(df_mfx, failure_map, store_path=None, ts=None):
+    # Run the analysis steps
+    vld_itr = build_valid_df(df_mfx)
+    vld_itr = compute_percentages(vld_itr)
+    vld_itr = analyze_failures(vld_itr, df_mfx, failure_map)
+    initial_count = vld_itr['vld loc count'].iloc[0]
+    vld_itr = add_failure_metrics(vld_itr, initial_count)
+    vld_paraflux = paraflux_itr_plot(vld_itr[['itr', 'passed itr %', 'CFR failure %', 'No signal % per itr pairs']])
+
+    if store_path is not None:
+        if ts is None:
+            warn("No timestamp found in metadata, saving as default.")
+            timestamp = "no_ts"
+
+        vld_itr = vld_itr.drop(columns='tid', errors='ignore')
+        default_dir = str(store_path.parent)
+        full_path = os.path.join(default_dir, f"{timestamp}_iteration_stats_full.csv")
+        paraflux_path = os.path.join(default_dir, f"{timestamp}_iteration_stats_Paraflux_only.csv")
+
+        vld_itr.to_csv(full_path, index=False)
+        keep_cols = ["itr", 'passed itr %', 'CFR failure %', 'No signal % per itr pairs']
+        vld_paraflux = vld_itr[keep_cols]
+        vld_paraflux.to_csv(paraflux_path, index=False)
+
+        logger.debug(f"✔ Saved full results to: {full_path}")
+        logger.debug(f"✔ Saved cleaned results to: {paraflux_path}")
+
+    return vld_itr
+
+### --- End of Alex B contributed functions ---

PYMEcs/Analysis/Simpler.py

@@ -0,0 +1,81 @@
+import numpy as np
+from scipy.stats import iqr
+
+import sys
+if sys.version_info > (3,):
+    xrange = range
+
+# halfmode is apparently a robust measure of the mode:
+# 1.Bickel, D. R. & Frühwirth, R. On a fast, robust estimator of the mode: Comparisons to other robust estimators with applications. Computational Statistics & Data Analysis 50, 3500–3530 (2006).
+
+def halfmode(inputData, axis=None, dtype=None):
+    """
+    Robust estimator of the mode of a data set using the half-sample mode.
+    
+    .. versionadded: 1.0.3
+    """
+    
+    if axis is not None:
+        fnc = lambda x: mode(x, dtype=dtype)
+        dataMode = np.apply_along_axis(fnc, axis, inputData)
+    else:
+        # Create the function that we can use for the half-sample mode
+        def _hsm(data):
+            if data.size == 1:
+                return data[0]
+            elif data.size == 2:
+                return data.mean()
+            elif data.size == 3:
+                i1 = data[1] - data[0]
+                i2 = data[2] - data[1]
+                if i1 < i2:
+                    return data[:2].mean()
+                elif i2 > i1:
+                    return data[1:].mean()
+                else:
+                    return data[1]
+            else:
+                wMin = data[-1] - data[0]
+                N = int(data.size / 2) + data.size % 2 
+                for i in xrange(0, int(N)):
+                    w = data[i+N-1] - data[i] 
+                    if w < wMin:
+                        wMin = w
+                        j = i
+                return _hsm(data[j:j+N])
+                
+        data = inputData.ravel()
+        if type(data).__name__ == "MaskedArray":
+            data = data.compressed()
+        if dtype is not None:
+            data = data.astype(dtype)
+            
+        # The data need to be sorted for this to work
+        data = np.sort(data)
+        
+        # Find the mode
+        dataMode = _hsm(data)
+        
+    return dataMode
+
+
+def clusterModes(x,y,eid,prop):
+    clusterMode = np.zeros_like(x)
+    clusterErr = np.zeros_like(x)
+    clusterCentroid_x = np.zeros_like(x)
+    clusterCentroid_y = np.zeros_like(x)
+    
+    uids = np.unique(eid)
+    for j,i in enumerate(uids):
+        if not i == 0: # cluster id 0 means not a cluster
+            ind = eid == i
+            xi = x[ind]
+            yi = y[ind]
+            pi = prop[ind]
+
+            clusterMode[ind] = halfmode(pi)
+            clusterErr[ind] = iqr(pi)
+            clusterCentroid_x[ind] = np.sum(xi*pi)/pi.sum()
+            clusterCentroid_y[ind] = np.sum(yi*pi)/pi.sum()
+
+    return clusterMode, clusterErr, clusterCentroid_x, clusterCentroid_y

PYMEcs/Analysis/Sofi.py

@@ -0,0 +1,140 @@
+# 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/>.
+#
+##################
+
+# this code lifted from PYMEnf and made compatible with py3 (change to sys.maxsize)
+
+import sys
+import numpy as np
+import scipy as sp
+import scipy.ndimage as ndimage
+
+# note this code assumes still the older data model and uses methods like `getSliceShape`
+# whereas the newer access modes (e.g. data_xyztc) do not have these
+
+def calcCorrelates(data, nOrders=5, startAt=50, filtHalfWidth=25, stopAt=sys.maxsize):
+    '''Calculate the autocorrelations up to nOrders for SOFI inmaging'''
+    d3c = np.zeros(list(data.getSliceShape()) + [1, nOrders])
+    d_m = np.zeros(data.getSliceShape())
+    d_mm = np.zeros(list(data.getSliceShape()) + [1])
+
+    nm = 1./(2*filtHalfWidth)
+    stopAt = min(stopAt, data.shape[2]-filtHalfWidth)
+
+    for i in range(startAt-filtHalfWidth,startAt+filtHalfWidth):
+        d_m += nm*data.getSlice(i)
+
+    for i in range(startAt+1, stopAt):
+        #print data[:,:,i-filtHalfWidth - 1].shape
+        d_m = d_m - data.getSlice(i-filtHalfWidth - 1)*nm + data.getSlice(i+filtHalfWidth-1)*nm
+        d_ = data.getSlice(i)
+        d_mm[:,:,0] += d_
+        d_ = d_ - d_m
+        d_2 = np.ones(d_.shape)
+        for j in range(d3c.shape[3]):
+            d_2 *= d_
+            if  (j % 2):
+                #print d3c.shape, d_2.shape, d_m.shape
+                d3c[:,:,0,j] += d_2
+            else:
+                d3c[:,:,0,j] += np.abs(d_2)
+
+    return d3c/(stopAt - startAt), d_mm/(stopAt - startAt)
+
+def calcCorrelatesI(data, nOrders=5, zoom=4, startAt=50, filtHalfWidth=25, stopAt=sys.maxsize):
+    '''Calculate the autocorrelations up to nOrders for SOFI inmaging'''
+    slShape = list(np.array(data.getSliceShape())*zoom)
+    d3c = np.zeros(slShape + [1, nOrders])
+    d_m = np.zeros(slShape)
+    d_mm = np.zeros(slShape + [1])
+
+    nm = 1./(2*filtHalfWidth)
+    stopAt = min(stopAt, data.shape[2]-filtHalfWidth)
+
+    for i in range(startAt-filtHalfWidth,startAt+filtHalfWidth):
+        d_m += nm*ndimage.zoom(data.getSlice(i), zoom)
+
+    for i in range(startAt+1, stopAt):
+        #print data[:,:,i-filtHalfWidth - 1].shape
+        d_m = d_m - ndimage.zoom(data.getSlice(i-filtHalfWidth - 1), zoom)*nm + ndimage.zoom(data.getSlice(i+filtHalfWidth-1), zoom)*nm
+        d_ = ndimage.zoom(data.getSlice(i), zoom)
+        d_mm[:,:,0] += d_
+        d_ = d_ - d_m
+        d_2 = np.ones(d_.shape)
+        for j in range(d3c.shape[3]):
+            d_2 *= d_
+            if  (j % 2):
+                #print d3c.shape, d_2.shape, d_m.shape
+                d3c[:,:,0,j] += d_2
+            else:
+                d3c[:,:,0,j] += np.abs(d_2)
+
+    return d3c/(stopAt - startAt), d_mm/(stopAt - startAt)
+
+def calcCumulants(corr):
+    cum = corr.copy()
+
+    for n in range(3,cum.shape[3]):
+        for i in range(1, n-1):
+            #print n+1, i+1, sp.comb(n, (i+1)), ((n+1)-(i+1), i+1), (n-i - 1, i)
+            cum[:,:,:,n] -= sp.comb(n, (i+1))*cum[:,:,:,(n-i -1)]*corr[:,:,:,i]
+
+    return cum
+
+
+def calcCorrelatesZ(data, zm, nOrders=5, startAt=50, filtHalfWidth=25, stopAt=sys.maxsize):
+    '''Calculate the autocorrelations up to nOrders for SOFI inmaging'''
+
+    zvals = np.array(list(set(zm.yvals)))
+    zvals.sort()
+    nZ = zvals.shape[0]
+
+    d3c = np.zeros(list(data.getSliceShape()) + [nZ, nOrders])
+    d_m = np.zeros(list(data.getSliceShape()))
+    d_mm = np.zeros(list(data.getSliceShape()) + [nZ])
+
+    nm = 1./(2*filtHalfWidth)
+    stopAt = min(stopAt, data.shape[2]-filtHalfWidth)
+
+    for i in range(startAt-filtHalfWidth,startAt+filtHalfWidth):
+        d_m += nm*data.getSlice(i)
+
+    for i in range(startAt+1, stopAt):
+        #print zvals, zm(i)
+        #print np.where((zvals - zm(i))**2 < .02)[0]
+        z = int(np.where((zvals - zm(i))**2 < .02)[0])
+        #print z, d3c.shape
+
+        #print data[:,:,i-filtHalfWidth - 1].shape
+        d_m = d_m - data.getSlice(i-filtHalfWidth - 1)*nm + data.getSlice(i+filtHalfWidth-1)*nm
+        d_ = data.getSlice(i)
+        d_mm[:,:,z] += d_
+        d_ = d_ - d_m
+        d_2 = np.ones(d_.shape)
+
+        
+
+        for j in range(d3c.shape[3]):
+            d_2 *= d_
+            if  (j % 2):
+                #print d3c.shape, d_2.shape, d_m.shape, z, j
+                #print d3c[:,:,z,j].shape
+
+                d3c[:,:,z,j] += d_2[:,:]
+            else:
+                d3c[:,:,z,j] += np.abs(d_2)
+
+    return d3c/(stopAt - startAt), d_mm/(stopAt - startAt)

PYMEcs/Analysis/decSofi.py

@@ -0,0 +1,211 @@
+from PYME.Deconv.dec import *
+
+
+class dec_sofi(dec):
+    def psf_calc(self, psf, data_size, orders, weights):
+        from PYME.pad import pad
+        pw = (numpy.array(data_size[:3]) - psf.shape)/2.
+        pw1 = numpy.floor(pw)
+        pw2 = numpy.ceil(pw)
+
+        g = psf#/psf.sum();
+
+        if pw1[0] < 0:
+            if pw2[0] < 0:
+                g = g[-pw1[0]:pw2[0]]
+            else:
+                g = g[-pw1[0]:]
+
+            pw1[0] = 0
+            pw2[0] = 0
+
+        if pw1[1] < 0:
+            if pw2[1] < 0:
+                g = g[-pw1[1]:pw2[1]]
+            else:
+                g = g[-pw1[1]:]
+
+            pw1[1] = 0
+            pw2[1] = 0
+
+        if pw1[2] < 0:
+            if pw2[2] < 0:
+                g = g[-pw1[2]:pw2[2]]
+            else:
+                g = g[-pw1[2]:]
+
+            pw1[2] = 0
+            pw2[2] = 0
+
+
+        g = pad.with_constant(g, ((pw2[0], pw1[0]), (pw2[1], pw1[1]),(pw2[2], pw1[2])), (0,))
+
+        self.height = data_size[0]
+        self.width  = data_size[1]
+        self.depth  = data_size[2]
+
+        self.shape = data_size[:2]
+
+        self.nOrders = data_size[3]
+        self.orders = orders
+        self.weights = weights
+#
+#        (x,y,z) = mgrid[-floor(self.height/2.0):(ceil(self.height/2.0)), -floor(self.width/2.0):(ceil(self.width/2.0)), -floor(self.depth/2.0):(ceil(self.depth/2.0))]
+#
+#        gs = shape(g);
+#
+#        g = g[int(floor((gs[0] - self.height)/2)):int(self.height + floor((gs[0] - self.height)/2)), int(floor((gs[1] - self.width)/2)):int(self.width + floor((gs[1] - self.width)/2)), int(floor((gs[2] - self.depth)/2)):int(self.depth + floor((gs[2] - self.depth)/2))]
+#
+#        #g = abs(ifftshift(ifftn(abs(fftn(g)))));
+#        g = (g/sum(sum(sum(g))));
+
+        self.g = g.astype('float32');
+
+        #%g = circshift(g, [0, -1]);
+        self.H = []
+        self.Ht = []
+        for i in range(self.nOrders):
+            gp = self.g**(self.orders[i])
+            gp = gp/sum(gp)
+            print gp.dtype
+            self.H.append(((fftn((gp)))))
+            self.Ht.append((gp.size*(ifftn((gp)))))
+
+    def startGuess(self, data):
+        guess = zeros(data.shape[:3])
+
+        for i in range(self.nOrders):
+            guess += data[:,:,:,i]**(1./self.orders[i])
+        
+        return guess/self.nOrders
+
+    def subsearch(self, f0, res, fdef, Afunc, Lfunc, lam, S):
+        nsrch = size(S,1)
+        pref = Lfunc(f0-fdef)
+        w0 = dot(pref, pref)
+        c0 = dot(res,res)
+
+        AS = zeros((size(res), nsrch), 'f')
+        LS = zeros((size(pref), nsrch), 'f')
+
+        for k in range(nsrch):
+            AS[:,k] = cast['f'](Afunc(f0 + S[:,k]) - Afunc(f0))
+            LS[:,k] = cast['f'](Lfunc(S[:,k]))
+
+        Hc = dot(transpose(AS), AS)
+        Hw = dot(transpose(LS), LS)
+        Gc = dot(transpose(AS), res)
+        Gw = dot(transpose(-LS), pref)
+
+        c = solve(Hc + pow(lam, 2)*Hw, Gc + pow(lam, 2)*Gw)
+
+        cpred = c0 + dot(dot(transpose(c), Hc), c) - dot(transpose(c), Gc)
+        wpred = w0 + dot(dot(transpose(c), Hw), c) - dot(transpose(c), Gw)
+
+        fnew = f0 + dot(S, c)
+
+        return (fnew, cpred, wpred)
+
+    def deconv(self, data, lamb, num_iters=10, alpha = None):#, Afunc=self.Afunc, Ahfunc=self.Ahfunc, Lfunc=self.Lfunc, Lhfunc=self.Lhfunc):
+        self.dataShape = data.shape
+
+        #lamb = 2e-2
+        if (not alpha == None):
+            self.alpha = alpha
+            self.e1 = fftshift(exp(1j*self.alpha))
+            self.e2 = fftshift(exp(2j*self.alpha))
+
+        self.f = self.startGuess(data)
+
+        self.f = self.f.ravel()
+        data = data.ravel()
+
+        fdef = zeros(self.f.shape, 'f')
+
+        S = zeros((size(self.f), 3), 'f')
+
+        #print type(S)
+        #print shape(S)
+
+        #type(Afunc)
+
+        nsrch = 2
+
+        for loopcount in range(num_iters):
+            pref = self.Lfunc(self.f - fdef);
+            self.res = data - self.Afunc(self.f);
+
+            #print type(Afunc(res))
+            #print shape(Afunc(res))
+
+            #print pref.typecode()
+
+            S[:,0] = cast['f'](self.Ahfunc(self.res))
+            S[:,1] = cast['f'](-self.Lhfunc(pref))
+
+            #print S
+
+            test = 1 - abs(dot(S[:,0], S[:,1])/(norm(S[:,0])*norm(S[:,1])))
+
+            print 'Test Statistic %f\n' % (test,)
+            self.tests.append(test)
+            self.ress.append(norm(self.res))
+            self.prefs.append(norm(pref))
+
+            (fnew, cpred, spred) = self.subsearch(self.f, self.res, fdef, self.Afunc, self.Lfunc, lamb, S[:, 0:nsrch])
+
+            fnew = cast['f'](fnew*(fnew > 0))
+
+            S[:,2] = cast['f'](fnew - self.f)
+            nsrch = 3
+
+            self.f = fnew
+
+        return real(self.f)
+
+    def Lfunc(self, f):
+        fs = reshape(f, (self.height, self.width, self.depth))
+        a = -6*fs
+
+        a[:,:,0:-1] += fs[:,:,1:]
+        a[:,:,1:] += fs[:,:,0:-1]
+
+        a[:,0:-1,:] += fs[:,1:,:]
+        a[:,1:,:] += fs[:,0:-1,:]
+
+        a[0:-1,:,:] += fs[1:,:,:]
+        a[1:,:,:] += fs[0:-1,:,:]
+
+        return ravel(cast['f'](a))
+
+    Lhfunc=Lfunc
+
+    def Afunc(self, f):
+        fs = reshape(f, (self.height, self.width, self.depth))
+        #print fs.shape
+
+        ds = []
+
+        for i in range(self.nOrders):
+            F = (fftn((fs**(self.orders[i]))))
+            d = ifftshift(ifftn(F*self.H[i])).real
+            ds.append(d[:,:,:,None])
+
+        #print ravel(array(ds)).shape
+        return ravel(concatenate(ds, 3))
+
+    def Ahfunc(self, f):
+        #print f.shape
+        fs = reshape(f, (self.height, self.width, self.depth, self.nOrders))
+
+        ds = []
+
+        for i in range(self.nOrders):
+            F = fftn(fs[:,:,:,i])
+            d = ifftshift(ifftn(F*self.Ht[i])).real
+            #d = sign(d)*abs(d)**(1./self.orders[i])
+            d = d/abs(d).max()
+            #print d.shape
+            ds.append(d*self.weights[i])
+
+        return ravel(sum(ds, axis=0))