Transfer function works now with GUI

.gitignore

@@ -7,6 +7,7 @@ __pycache__/
 # IDEs
 
 .idea
+.vscode
 
 # C extensions
 *.so

glassure/gui/controller/glassure.py

@@ -19,6 +19,7 @@
 
 from .configuration import ConfigurationController
 from .soller import SollerController
+from .transfer import TransferFunctionController
 
 
 class GlassureController(object):
@@ -33,6 +34,7 @@ def __init__(self):
 
         self.configuration_controller = ConfigurationController(self.main_widget, self.model)
         self.soller_controller = SollerController(self.main_widget, self.model)
+        self.transfer_controller = TransferFunctionController(self.main_widget, self.model)
 
     def show_window(self):
         """

glassure/gui/controller/soller.py

@@ -1,7 +1,5 @@
 # -*- coding: utf8 -*-
 
-from ..qt import QtGui
-
 from ..widgets.glassure import GlassureWidget
 from ..model.glassure import GlassureModel
 

glassure/gui/controller/transfer.py

@@ -0,0 +1,83 @@
+# -*- coding: utf8 -*-
+import os
+
+from ..qt import QtCore, QtGui
+
+from ..widgets.glassure import GlassureWidget
+from ..model.glassure import GlassureModel
+
+
+class TransferFunctionController(object):
+    def __init__(self, widget, glassure_model):
+        """
+        :param widget:
+        :type widget: GlassureWidget
+        :param glassure_model:
+        :type glassure_model: GlassureModel
+        """
+
+        self.widget = widget
+        self.transfer_widget = widget.transfer_widget
+        self.model = glassure_model
+
+        self.connect_signals()
+
+    def connect_signals(self):
+        self.transfer_widget.activate_cb.stateChanged.connect(self.active_cb_state_changed)
+
+        self.transfer_widget.load_sample_btn.clicked.connect(self.load_sample_pattern)
+        self.transfer_widget.load_sample_bkg_btn.clicked.connect(self.load_sample_bkg_pattern)
+        self.transfer_widget.load_std_btn.clicked.connect(self.load_std_pattern)
+        self.transfer_widget.load_std_bkg_btn.clicked.connect(self.load_std_bkg_pattern)
+
+        self.transfer_widget.sample_bkg_scaling_sb.valueChanged.connect(self.sample_bkg_scaling_changed)
+        self.transfer_widget.std_bkg_scaling_sb.valueChanged.connect(self.std_bkg_scaling_changed)
+        self.transfer_widget.smooth_sb.valueChanged.connect(self.smooth_factor_changed)
+
+    def load_sample_pattern(self):
+        filename = str(QtGui.QFileDialog.getOpenFileName(self.widget,
+                                                         caption="Load Sample Spectrum (in Container)"))
+
+        if filename is not '':
+            self.model.load_transfer_sample_pattern(filename)
+            self.working_directory = os.path.dirname(filename)
+            self.transfer_widget.sample_filename_lbl.setText(os.path.basename(filename))
+
+    def load_sample_bkg_pattern(self):
+        filename = str(QtGui.QFileDialog.getOpenFileName(self.widget,
+                                                         caption="Load Sample Spectrum (in Container)"))
+
+        if filename is not '':
+            self.model.load_transfer_sample_bkg_pattern(filename)
+            self.working_directory = os.path.dirname(filename)
+            self.transfer_widget.sample_bkg_filename_lbl.setText(os.path.basename(filename))
+
+    def load_std_pattern(self):
+        filename = str(QtGui.QFileDialog.getOpenFileName(self.widget,
+                                                         caption="Load Sample Spectrum (in Container)"))
+
+        if filename is not '':
+            self.model.load_transfer_std_pattern(filename)
+            self.working_directory = os.path.dirname(filename)
+            self.transfer_widget.std_filename_lbl.setText(os.path.basename(filename))
+
+    def load_std_bkg_pattern(self):
+        filename = str(QtGui.QFileDialog.getOpenFileName(self.widget,
+                                                         caption="Load Sample Spectrum (in Container)"))
+
+        if filename is not '':
+            self.model.load_transfer_std_bkg_pattern(filename)
+            self.working_directory = os.path.dirname(filename)
+            self.transfer_widget.std_bkg_filename_lbl.setText(os.path.basename(filename))
+
+    def active_cb_state_changed(self):
+        self.model.use_transfer_function = self.transfer_widget.activate_cb.isChecked()
+
+    def sample_bkg_scaling_changed(self, new_value):
+        self.model.transfer_sample_bkg_scaling = float(new_value)
+
+    def std_bkg_scaling_changed(self, new_value):
+        self.model.transfer_std_bkg_scaling = float(new_value)
+
+    def smooth_factor_changed(self, new_value):
+        self.model.transfer_function_smoothing = new_value

glassure/gui/model/configuration.py

@@ -51,21 +51,25 @@ def __init__(self):
         self.use_soller_correction = False
         self.soller_correction = None
         # default parameters for soller slit ID27, ESRF and GSECARS, APS
-        self.soller_parameters = {'sample_thickness': 1.0, #in mm
-                                  'wavelength': 0.31, # in Angstrom
-                                  'inner_radius': 62, # in mm
-                                  'outer_radius': 210, # in mm
-                                  'inner_width': 0.05, # in mm
-                                  'outer_width': 0.2, # in mm
-                                  'inner_length': 8, # in mm
-                                  'outer_length': 6} # in mm
+        self.soller_parameters = {'sample_thickness': 1.0,  # in mm
+                                  'wavelength': 0.31,  # in Angstrom
+                                  'inner_radius': 62,  # in mm
+                                  'outer_radius': 210,  # in mm
+                                  'inner_width': 0.05,  # in mm
+                                  'outer_width': 0.2,  # in mm
+                                  'inner_length': 8,  # in mm
+                                  'outer_length': 6}  # in mm
 
         # transfer function stuff
         self.use_transfer_function = False
         self.transfer_function = None
-        self.transfer_function_smoothing = 1
+        self.transfer_function_smoothing = 1.0
         self.transfer_std_pattern = None
+        self.transfer_std_bkg_pattern = None
+        self.transfer_std_bkg_scaling = 1.0
         self.transfer_sample_pattern = None
+        self.transfer_sample_bkg_pattern = None
+        self.transfer_sample_bkg_scaling = 1
 
         self.name = 'Config {}'.format(GlassureConfiguration.num)
         self.color = calculate_color(GlassureConfiguration.num)

glassure/gui/model/glassure.py

@@ -335,6 +335,27 @@ def transfer_std_pattern(self):
     def transfer_std_pattern(self, new_pattern):
         self.current_configuration.transfer_std_pattern = new_pattern
 
+    @property
+    def transfer_std_bkg_pattern(self):
+        """
+        :rtype Pattern:
+        """
+        return self.current_configuration.transfer_std_bkg_pattern
+
+    @transfer_std_bkg_pattern.setter
+    def transfer_std_bkg_pattern(self, new_pattern):
+        self.current_configuration.transfer_std_bkg_pattern = new_pattern
+        self.update_transfer_function()
+
+    @property
+    def transfer_std_bkg_scaling(self):
+        return self.current_configuration.transfer_std_bkg_scaling
+
+    @transfer_std_bkg_scaling.setter
+    def transfer_std_bkg_scaling(self, new_value):
+        self.current_configuration.transfer_std_bkg_scaling = new_value
+        self.update_transfer_function()
+
     @property
     def transfer_sample_pattern(self):
         """
@@ -346,6 +367,27 @@ def transfer_sample_pattern(self):
     def transfer_sample_pattern(self, new_pattern):
         self.current_configuration.transfer_sample_pattern = new_pattern
 
+    @property
+    def transfer_sample_bkg_pattern(self):
+        """
+        :rtype Pattern:
+        """
+        return self.current_configuration.transfer_sample_bkg_pattern
+
+    @transfer_sample_bkg_pattern.setter
+    def transfer_sample_bkg_pattern(self, new_pattern):
+        self.current_configuration.transfer_sample_bkg_pattern = new_pattern
+        self.update_transfer_function()
+
+    @property
+    def transfer_sample_bkg_scaling(self):
+        return self.current_configuration.transfer_sample_bkg_scaling
+
+    @transfer_sample_bkg_scaling.setter
+    def transfer_sample_bkg_scaling(self, new_value):
+        self.current_configuration.transfer_sample_bkg_scaling = new_value
+        self.update_transfer_function()
+
     def set_smooth(self, value):
         self.original_pattern.set_smoothing(value)
         self.current_configuration.background_pattern.set_smoothing(value)
@@ -566,25 +608,33 @@ def update_transfer_function(self):
             return
         q_min = np.max([self.transfer_std_pattern.x[0], self.transfer_sample_pattern.x[0]])
         q_max = np.min([self.transfer_std_pattern.x[-1], self.transfer_sample_pattern.x[-1]])
+
+        if self.transfer_std_bkg_pattern is None:
+            std_pattern = self.transfer_std_pattern
+        else:
+            std_pattern = self.transfer_std_pattern - self.transfer_std_bkg_scaling * self.transfer_std_bkg_pattern
+
+        if self.transfer_sample_bkg_pattern is None:
+            sample_pattern = self.transfer_sample_pattern
+        else:
+            sample_pattern = self.transfer_sample_pattern - self.transfer_sample_bkg_scaling * \
+                                                            self.transfer_sample_bkg_pattern
+
         self.current_configuration.transfer_function = calculate_transfer_function(
-            self.transfer_std_pattern.limit(q_min, q_max),
-            self.transfer_sample_pattern.limit(q_min, q_max),
+            std_pattern.limit(q_min, q_max),
+            sample_pattern.limit(q_min, q_max),
             smooth_factor=self.transfer_function_smoothing
         )
         self.calculate_transforms()
 
     def load_transfer_std_pattern(self, filename):
         self.transfer_std_pattern = Pattern.from_file(filename)
-        self.update_transfer_function()
 
     def load_transfer_std_bkg_pattern(self, filename):
-        self.transfer_std_pattern.bkg_spectrum = Pattern.from_file(filename)
-        self.update_transfer_function()
+        self.transfer_std_bkg_pattern = Pattern.from_file(filename)
 
     def load_transfer_sample_pattern(self, filename):
         self.transfer_sample_pattern = Pattern.from_file(filename)
-        self.update_transfer_function()
 
     def load_transfer_sample_bkg_pattern(self, filename):
-        self.transfer_sample_pattern.bkg_spectrum = Pattern.from_file(filename)
-        self.update_transfer_function()
+        self.transfer_sample_bkg_pattern = Pattern.from_file(filename)

glassure/gui/widgets/glassure.py

@@ -98,6 +98,9 @@ def create_widget_shortcuts(self):
         self.soller_widget = self.right_control_widget.soller_widget
         self.soller_active_cb = self.right_control_widget.soller_widget.activate_cb
 
+        self.transfer_widget = self.right_control_widget.transfer_widget
+        self.transfer_active_cb = self.right_control_widget.transfer_widget.activate_cb
+
     def create_function_shortcuts(self):
         self.set_composition = self.left_control_widget.composition_widget.set_composition
         self.get_composition = self.left_control_widget.composition_widget.get_composition

glassure/tests/gui_tests/test_model.py

@@ -228,7 +228,7 @@ def test_use_transfer_function(self):
         self.model.use_transfer_function = True
         test_y = self.model.original_pattern.limit(0, 14).y * self.model.transfer_function(
             self.model.original_pattern.limit(0, 14).x)
-        self.assertAlmostEqual(np.std(self.model.transfer_std_pattern.limit(0, 14).y / test_y), 0, delta=0.02)
+        self.assertAlmostEqual(np.std(self.model.transfer_std_pattern.limit(0, 14).y / test_y), 0, delta=0.2)
 
         sq_pattern_with_transfer = self.model.sq_pattern