Index: src/sas/sascalc/corfunc/corfunc_calculator.py
===================================================================
--- src/sas/sascalc/corfunc/corfunc_calculator.py	(revision ff11b21937c0657ed4709a35bf3ee586f4e3148c)
+++ src/sas/sascalc/corfunc/corfunc_calculator.py	(revision 412c509a21480e28510b47f414d8a567f38f01a0)
@@ -34,5 +34,13 @@
 
         def __call__(self, x):
-            if self._lastx == [] or x.tolist() != self._lastx.tolist():
+            # If input is a single number, evaluate the function at that number
+            # and return a single number
+            if type(x) == float or type(x) == int:
+                return self._smoothed_function(np.array([x]))[0]
+            # If input is a list, and is different to the last input, evaluate
+            # the function at each point. If the input is the same as last time
+            # the function was called, return the result that was calculated
+            # last time instead of explicity evaluating the function again.
+            elif self._lastx == [] or x.tolist() != self._lastx.tolist():
                 self._lasty = self._smoothed_function(x)
                 self._lastx = x
@@ -121,8 +129,8 @@
         extrapolation = Data1D(qs, iqs)
 
-        return params, extrapolation
-
-    def compute_transform(self, extrapolation, trans_type, background=None,
-        completefn=None, updatefn=None):
+        return params, extrapolation, s2
+
+    def compute_transform(self, extrapolation, trans_type, extrap_fn=None,
+        background=None, completefn=None, updatefn=None):
         """
         Transform an extrapolated scattering curve into a correlation function.
@@ -131,4 +139,5 @@
         :param background: The background value (if not provided, previously
             calculated value will be used)
+        :param extrap_fn: A callable function representing the extraoplated data
         :param completefn: The function to call when the transform calculation
             is complete`
@@ -144,5 +153,6 @@
         if trans_type == 'fourier':
             self._transform_thread = FourierThread(self._data, extrapolation,
-            background, completefn=completefn, updatefn=updatefn)
+            background, extrap_fn=extrap_fn, completefn=completefn,
+            updatefn=updatefn)
         elif trans_type == 'hilbert':
             self._transform_thread = HilbertThread(self._data, extrapolation,
Index: src/sas/sascalc/corfunc/transform_thread.py
===================================================================
--- src/sas/sascalc/corfunc/transform_thread.py	(revision 457f7351de0a1b8d55c0422b73cc572a1cbbfc8f)
+++ src/sas/sascalc/corfunc/transform_thread.py	(revision 412c509a21480e28510b47f414d8a567f38f01a0)
@@ -2,14 +2,16 @@
 from sas.sascalc.dataloader.data_info import Data1D
 from scipy.fftpack import dct
+from scipy.integrate import simps, trapz
 import numpy as np
 from time import sleep
 
 class FourierThread(CalcThread):
-    def __init__(self, raw_data, extrapolated_data, bg, updatefn=None,
-        completefn=None):
+    def __init__(self, raw_data, extrapolated_data, bg, extrap_fn=None,
+        updatefn=None, completefn=None):
         CalcThread.__init__(self, updatefn=updatefn, completefn=completefn)
         self.data = raw_data
         self.background = bg
         self.extrapolation = extrapolated_data
+        self.extrap_fn = extrap_fn
 
     def compute(self):
@@ -19,7 +21,10 @@
         background = self.background
 
+        xs = np.pi*np.arange(len(qs),dtype=np.float32)/(q[1]-q[0])/len(qs)
+
         self.ready(delay=0.0)
-        self.update(msg="Starting Fourier transform.")
+        self.update(msg="Fourier transform in progress.")
         self.ready(delay=0.0)
+
         if self.isquit():
             return
@@ -27,7 +32,16 @@
             gamma1 = dct((iqs-background)*qs**2)
             gamma1 = gamma1 / gamma1.max()
-        except:
+
+            # gamma3(R) = 1/R int_{0}^{R} gamma1(x) dx
+            # simps uses simpson's rule to calculate the integral
+            gamma3 = [trapz(gamma1[:n], xs[:n])/xs[n-1] for n in range(1, len(xs+1))]
+            gamma3 = np.array(gamma3)
+        except Exception as e:
+            import logging
+            logger = logging.getLogger(__name__)
+            logger.error(e)
+
             self.update(msg="Fourier transform failed.")
-            self.complete(transform=None)
+            self.complete(transforms=None)
             return
         if self.isquit():
@@ -35,7 +49,6 @@
         self.update(msg="Fourier transform completed.")
 
-        xs = np.pi*np.arange(len(qs),dtype=np.float32)/(q[1]-q[0])/len(qs)
         transform1 = Data1D(xs, gamma1)
-        transform3 = Data1D()
+        transform3 = Data1D(xs, gamma3)
 
         transforms = (transform1, transform3)
Index: src/sas/sasgui/perspectives/corfunc/corfunc_panel.py
===================================================================
--- src/sas/sasgui/perspectives/corfunc/corfunc_panel.py	(revision 457f7351de0a1b8d55c0422b73cc572a1cbbfc8f)
+++ src/sas/sasgui/perspectives/corfunc/corfunc_panel.py	(revision 412c509a21480e28510b47f414d8a567f38f01a0)
@@ -55,4 +55,7 @@
         self._data = data # The data to be analysed (corrected fr background)
         self._extrapolated_data = None # The extrapolated data set
+        # Callable object of class CorfuncCalculator._Interpolator representing
+        # the extrapolated and interpolated data
+        self._extrapolated_fn = None
         self._transformed_data = None # Fourier trans. of the extrapolated data
         self._calculator = CorfuncCalculator()
@@ -218,5 +221,6 @@
 
         try:
-            params, self._extrapolated_data = self._calculator.compute_extrapolation()
+            params, self._extrapolated_data, self._extrapolated_fn = \
+                self._calculator.compute_extrapolation()
         except Exception as e:
             msg = "Error extrapolating data:\n"
@@ -241,4 +245,5 @@
             self._calculator.compute_transform(self._extrapolated_data,
                 self.transform_type, background=self.background,
+                extrap_fn=self._extrapolated_fn,
                 completefn=self.transform_complete,
                 updatefn=self.transform_update)
@@ -276,4 +281,7 @@
         plot_y = transform1.y[np.where(transform1.x <= 200)]
         self._manager.show_data(Data1D(plot_x, plot_y), TRANSFORM_LABEL1)
+        plot_x = transform3.x[np.where(transform3.x <= 200)]
+        plot_y = transform3.y[np.where(transform3.x <= 200)]
+        self._manager.show_data(Data1D(plot_x, plot_y), TRANSFORM_LABEL3)
         # Only enable extract params button if a fourier trans. has been done
         if self.transform_type == 'fourier':
