Exemplo n.º 1
0
    def setUp(self):
        # creating Data objects
        self.img_data = ImgModel()
        self.img_data.load("Data/CbnCorrectionOptimization/Mg2SiO4_091.tif")
        self.calibration_data = CalibrationModel(self.img_data)
        self.calibration_data.load("Data/CbnCorrectionOptimization/LaB6_40keV side.poni")
        self.mask_data = MaskModel()
        self.mask_data.load_mask("Data/CbnCorrectionOptimization/Mg2SiO4_91_combined.mask")

        # creating the ObliqueAngleDetectorAbsorptionCorrection
        _, fit2d_parameter = self.calibration_data.get_calibration_parameter()
        detector_tilt = fit2d_parameter['tilt']
        detector_tilt_rotation = fit2d_parameter['tiltPlanRotation']

        self.tth_array = self.calibration_data.spectrum_geometry.twoThetaArray((2048, 2048))
        self.azi_array = self.calibration_data.spectrum_geometry.chiArray((2048, 2048))

        self.oiadac_correction = ObliqueAngleDetectorAbsorptionCorrection(
                self.tth_array, self.azi_array,
                detector_thickness=40,
                absorption_length=465.5,
                tilt=detector_tilt,
                rotation=detector_tilt_rotation,
        )
        self.img_data.add_img_correction(self.oiadac_correction, "oiadac")
Exemplo n.º 2
0
    def setUp(self):
        self.working_dir = {}

        self.img_model = ImgModel()
        self.mask_model = MaskModel()
        self.mask_widget = MaskWidget()
        self.mask_controller = MaskController(self.working_dir,
                                              self.mask_widget, self.img_model,
                                              self.mask_model)
class MaskControllerTest(unittest.TestCase):
    def setUp(self):
        self.app = QtGui.QApplication(sys.argv)
        self.working_dir = {}

        self.img_model = ImgModel()
        self.mask_model = MaskModel()
        self.mask_widget = MaskWidget()
        self.mask_controller = MaskController(self.working_dir, self.mask_widget, self.img_model, self.mask_model)

    def tearDown(self):
        del self.img_model
        del self.mask_model
        self.mask_widget.close()
        del self.mask_widget
        del self.mask_controller
        del self.app
        gc.collect()

    def get_file_size(self, filename):
        stat_info = os.stat(filename)
        return stat_info.st_size

    def test_loading_and_saving_mask_files(self):
        self.mask_controller.load_mask_btn_click(os.path.join(data_path, 'test.mask'))
        self.mask_model.mask_below_threshold(self.img_model, 1)
        filename = os.path.join(data_path, 'dummy.mask')
        self.mask_controller.save_mask_btn_click(filename)
        self.assertTrue(os.path.exists(filename))
        os.remove(filename)

    def test_loading_and_saving_with_super_sampling(self):
        self.mask_model.set_supersampling(2)
        self.mask_controller.load_mask_btn_click(os.path.join(data_path, 'test.mask'))

        self.assertEqual(self.mask_model.get_mask().shape[0], 4096)
        self.assertEqual(self.mask_model.get_mask().shape[1], 4096)

        self.assertEqual(self.mask_model.get_img().shape[0], 2048)
        self.assertEqual(self.mask_model.get_img().shape[1], 2048)

        self.mask_model.mask_below_threshold(self.img_model, 1)

        filename = os.path.join(data_path, 'dummy.mask')
        self.mask_controller.save_mask_btn_click(filename)
        self.assertEqual(self.get_file_size(filename), self.get_file_size(os.path.join(data_path, 'test.mask')))

    def test_grow_and_shrinking(self):
        self.mask_model.mask_ellipse(100,100,20,20)
        previous_mask = np.copy(self.mask_model._mask_data)

        QTest.mouseClick(self.mask_widget.grow_btn, QtCore.Qt.LeftButton)
        self.assertFalse(np.array_equal(previous_mask, self.mask_model._mask_data))

        QTest.mouseClick(self.mask_widget.shrink_btn, QtCore.Qt.LeftButton)
        self.assertTrue(np.array_equal(previous_mask, self.mask_model._mask_data))
    def setUp(self):
        self.app = QtGui.QApplication(sys.argv)
        self.working_dir = {}

        self.img_model = ImgModel()
        self.mask_model = MaskModel()
        self.mask_widget = MaskWidget()
        self.mask_controller = MaskController(self.working_dir, self.mask_widget, self.img_model, self.mask_model)
Exemplo n.º 5
0
    def __init__(self, use_settings=True):
        self.use_settings = use_settings

        self.widget = MainWidget()
        # create data
        self.img_model = ImgModel()
        self.calibration_model = CalibrationModel(self.img_model)
        self.mask_model = MaskModel()
        self.spectrum_model = PatternModel()
        self.phase_model = PhaseModel()

        self.settings_directory = os.path.join(os.path.expanduser("~"),
                                               '.Dioptas')
        self.working_directories = {
            'calibration': '',
            'mask': '',
            'image': '',
            'spectrum': '',
            'overlay': '',
            'phase': ''
        }

        if use_settings:
            self.load_settings()

        self.calibration_controller = CalibrationController(
            self.working_directories, self.widget.calibration_widget,
            self.img_model, self.mask_model, self.calibration_model)
        self.mask_controller = MaskController(self.working_directories,
                                              self.widget.mask_widget,
                                              self.img_model, self.mask_model)
        self.integration_controller = IntegrationController(
            self.working_directories, self.widget.integration_widget,
            self.img_model, self.mask_model, self.calibration_model,
            self.spectrum_model, self.phase_model)
        self.create_signals()
        self.update_title()

        self.current_tab_index = 0
 def setUp(self):
     self.app = QtGui.QApplication(sys.argv)
     self.img_model = ImgModel()
     self.mask_model = MaskModel()
     self.calibration_model = CalibrationModel(self.img_model)
     self.calibration_model._calibrants_working_dir = os.path.join(data_path, 'calibrants')
     self.calibration_widget = CalibrationWidget()
     self.working_dir = {}
     self.calibration_controller = CalibrationController(working_dir=self.working_dir,
                                                         img_model=self.img_model,
                                                         mask_model=self.mask_model,
                                                         widget=self.calibration_widget,
                                                         calibration_model=self.calibration_model)
Exemplo n.º 7
0
    def setUp(self):
        self.working_dir = {'image': ''}

        self.widget = IntegrationWidget()
        self.image_model = ImgModel()
        self.mask_model = MaskModel()
        self.spectrum_model = PatternModel()
        self.calibration_model = CalibrationModel(self.image_model)

        self.controller = ImageController(
            working_dir=self.working_dir,
            widget=self.widget,
            img_model=self.image_model,
            mask_model=self.mask_model,
            spectrum_model=self.spectrum_model,
            calibration_model=self.calibration_model)
    def setUp(self):
        self.img_model = ImgModel()
        self.mask_model = MaskModel()
        self.calibration_model = CalibrationModel(self.img_model)
        self.calibration_model._calibrants_working_dir = os.path.join(
            data_path, 'calibrants')
        self.calibration_model.integrate_1d = MagicMock()
        self.calibration_model.integrate_2d = MagicMock()

        self.calibration_widget = CalibrationWidget()
        self.working_dir = {}
        self.calibration_controller = CalibrationController(
            working_dir=self.working_dir,
            img_model=self.img_model,
            mask_model=self.mask_model,
            widget=self.calibration_widget,
            calibration_model=self.calibration_model)
Exemplo n.º 9
0
    def __init__(self, use_settings=True):
        self.use_settings = use_settings

        self.widget = MainWidget()
        # create data
        self.img_model = ImgModel()
        self.calibration_model = CalibrationModel(self.img_model)
        self.mask_model = MaskModel()
        self.spectrum_model = PatternModel()
        self.phase_model = PhaseModel()

        self.settings_directory = os.path.join(os.path.expanduser("~"), '.Dioptas')
        self.working_directories = {'calibration': '', 'mask': '', 'image': '', 'spectrum': '', 'overlay': '',
                                    'phase': ''}

        if use_settings:
            self.load_settings()

        self.calibration_controller = CalibrationController(self.working_directories,
                                                            self.widget.calibration_widget,
                                                            self.img_model,
                                                            self.mask_model,
                                                            self.calibration_model)
        self.mask_controller = MaskController(self.working_directories,
                                              self.widget.mask_widget,
                                              self.img_model,
                                              self.mask_model)
        self.integration_controller = IntegrationController(self.working_directories,
                                                            self.widget.integration_widget,
                                                            self.img_model,
                                                            self.mask_model,
                                                            self.calibration_model,
                                                            self.spectrum_model,
                                                            self.phase_model)
        self.create_signals()
        self.update_title()

        self.current_tab_index = 0
Exemplo n.º 10
0
 def setUp(self):
     self.mask_model = MaskModel()
     self.img = np.zeros((10, 10))
     self.mask_model.set_dimension(self.img.shape)
Exemplo n.º 11
0
class MaskModelTest(unittest.TestCase):
    def setUp(self):
        self.mask_model = MaskModel()
        self.img = np.zeros((10, 10))
        self.mask_model.set_dimension(self.img.shape)

    def tearDown(self):
        del self.mask_model
        del self.img
        gc.collect()

    def test_growing_masks(self):
        self.mask_model._mask_data[4, 4] = 1
        self.mask_model._mask_data[0, 0] = 1
        self.mask_model._mask_data[0, 9] = 1
        self.mask_model._mask_data[9, 9] = 1
        self.mask_model._mask_data[9, 0] = 1

        self.mask_model.grow()

        # test corners
        self.assertEqual(self.mask_model._mask_data[0, 1], 1)
        self.assertEqual(self.mask_model._mask_data[1, 1], 1)
        self.assertEqual(self.mask_model._mask_data[1, 0], 1)

        self.assertEqual(self.mask_model._mask_data[0, 8], 1)
        self.assertEqual(self.mask_model._mask_data[1, 8], 1)
        self.assertEqual(self.mask_model._mask_data[1, 9], 1)

        self.assertEqual(self.mask_model._mask_data[8, 0], 1)
        self.assertEqual(self.mask_model._mask_data[8, 1], 1)
        self.assertEqual(self.mask_model._mask_data[9, 1], 1)

        self.assertEqual(self.mask_model._mask_data[8, 8], 1)
        self.assertEqual(self.mask_model._mask_data[8, 9], 1)
        self.assertEqual(self.mask_model._mask_data[9, 8], 1)

        # test center
        self.assertEqual(self.mask_model._mask_data[3, 3], 1)
        self.assertEqual(self.mask_model._mask_data[4, 3], 1)
        self.assertEqual(self.mask_model._mask_data[5, 3], 1)

        self.assertEqual(self.mask_model._mask_data[3, 5], 1)
        self.assertEqual(self.mask_model._mask_data[4, 5], 1)
        self.assertEqual(self.mask_model._mask_data[5, 5], 1)

        self.assertEqual(self.mask_model._mask_data[3, 4], 1)
        self.assertEqual(self.mask_model._mask_data[5, 4], 1)

    def test_shrink_mask(self):
        self.mask_model._mask_data[4, 4] = 1
        self.mask_model._mask_data[0, 0] = 1
        self.mask_model._mask_data[0, 9] = 1
        self.mask_model._mask_data[9, 9] = 1
        self.mask_model._mask_data[9, 0] = 1

        self.before_mask = np.copy(self.mask_model._mask_data)
        self.mask_model.grow()
        self.mask_model.shrink()

        self.assertTrue(np.array_equal(self.before_mask, self.mask_model._mask_data))

        self.mask_model.clear_mask()

        self.mask_model._mask_data[4, 4] = 1
        self.mask_model._mask_data[5, 4] = 1
        self.mask_model._mask_data[5, 5] = 1
        self.mask_model._mask_data[4, 5] = 1
        self.mask_model.shrink()

        self.assertEqual(np.sum(self.mask_model._mask_data), 0)

    def test_saving_and_loading(self):
        self.mask_model.mask_ellipse(1024, 1024, 100, 100)
        self.mask_model.set_dimension((2048, 2048))

        mask_array = np.copy(self.mask_model.get_img())

        filename = os.path.join(data_path, "dummy.mask")

        self.mask_model.save_mask(filename)
        self.mask_model.load_mask(filename)

        self.assertTrue(np.array_equal(mask_array, self.mask_model.get_img()))
        os.remove(filename)
Exemplo n.º 12
0
class MainController(object):
    """
    Creates a the main controller for Dioptas. Creates all the data objects and connects them with the other controllers
    """

    def __init__(self, use_settings=True):
        self.use_settings = use_settings

        self.widget = MainWidget()
        # create data
        self.img_model = ImgModel()
        self.calibration_model = CalibrationModel(self.img_model)
        self.mask_model = MaskModel()
        self.spectrum_model = PatternModel()
        self.phase_model = PhaseModel()

        self.settings_directory = os.path.join(os.path.expanduser("~"), '.Dioptas')
        self.working_directories = {'calibration': '', 'mask': '', 'image': '', 'spectrum': '', 'overlay': '',
                                    'phase': ''}

        if use_settings:
            self.load_settings()

        self.calibration_controller = CalibrationController(self.working_directories,
                                                            self.widget.calibration_widget,
                                                            self.img_model,
                                                            self.mask_model,
                                                            self.calibration_model)
        self.mask_controller = MaskController(self.working_directories,
                                              self.widget.mask_widget,
                                              self.img_model,
                                              self.mask_model)
        self.integration_controller = IntegrationController(self.working_directories,
                                                            self.widget.integration_widget,
                                                            self.img_model,
                                                            self.mask_model,
                                                            self.calibration_model,
                                                            self.spectrum_model,
                                                            self.phase_model)
        self.create_signals()
        self.update_title()

        self.current_tab_index = 0

    def show_window(self):
        """
        Displays the main window on the screen and makes it active.
        """
        self.widget.show()

        if _platform == "darwin":
            self.widget.setWindowState(self.widget.windowState() & ~QtCore.Qt.WindowMinimized | QtCore.Qt.WindowActive)
            self.widget.activateWindow()
            self.widget.raise_()

    def create_signals(self):
        """
        Creates subscriptions for changing tabs and also newly loaded files which will update the title of the main
                window.
        """
        self.widget.tabWidget.currentChanged.connect(self.tab_changed)
        self.widget.closeEvent = self.close_event
        self.img_model.img_changed.connect(self.update_title)
        self.spectrum_model.pattern_changed.connect(self.update_title)

    def tab_changed(self, ind):
        """
        Function which is called when a tab has been selected (calibration, mask, or integration). Performs
        needed initialization tasks.
        :param ind: index for the tab selected (2 - integration, 1 = mask, 0 - calibration)
        :return:
        """
        old_index = self.current_tab_index
        self.current_tab_index = ind

        # get the old view range
        old_view_range = None
        old_hist_levels = None
        if old_index == 0:  # calibration tab
            old_view_range = self.widget.calibration_widget.img_widget.img_view_box.targetRange()
            old_hist_levels = self.widget.calibration_widget.img_widget.img_histogram_LUT.getExpLevels()
        elif old_index == 1:  # mask tab
            old_view_range = self.widget.mask_widget.img_widget.img_view_box.targetRange()
            old_hist_levels = self.widget.mask_widget.img_widget.img_histogram_LUT.getExpLevels()
        elif old_index == 2:
            old_view_range = self.widget.integration_widget.img_widget.img_view_box.targetRange()
            old_hist_levels = self.widget.integration_widget.img_widget.img_histogram_LUT.getExpLevels()

        # update the GUI
        if ind == 2:  # integration tab
            self.mask_model.set_supersampling()
            self.integration_controller.image_controller.plot_mask()
            self.integration_controller.widget.calibration_lbl.setText(self.calibration_model.calibration_name)
            self.integration_controller.image_controller._auto_scale = False
            self.integration_controller.spectrum_controller.image_changed()
            self.integration_controller.image_controller.update_img()
            self.widget.integration_widget.img_widget.set_range(x_range=old_view_range[0], y_range=old_view_range[1])
            self.widget.integration_widget.img_widget.img_histogram_LUT.setLevels(*old_hist_levels)
        elif ind == 1:  # mask tab
            self.mask_controller.plot_mask()
            self.mask_controller.plot_image()
            self.widget.mask_widget.img_widget.set_range(x_range=old_view_range[0], y_range=old_view_range[1])
            self.widget.mask_widget.img_widget.img_histogram_LUT.setLevels(*old_hist_levels)
        elif ind == 0:  # calibration tab
            self.calibration_controller.plot_mask()
            try:
                self.calibration_controller.update_calibration_parameter_in_view()
            except (TypeError, AttributeError):
                pass
            self.widget.calibration_widget.img_widget.set_range(x_range=old_view_range[0], y_range=old_view_range[1])
            self.widget.calibration_widget.img_widget.img_histogram_LUT.setLevels(*old_hist_levels)

    def update_title(self):
        """
        Updates the title bar of the main window. The title bar will always show the current version of Dioptas, the
        image or spectrum filenames loaded and the current calibration name.
        """
        img_filename = os.path.basename(self.img_model.filename)
        spec_filename = os.path.basename(self.spectrum_model.pattern_filename)
        calibration_name = self.calibration_model.calibration_name
        str = 'Dioptas ' + __version__
        if img_filename is '' and spec_filename is '':
            self.widget.setWindowTitle(str + u' - © 2015 C. Prescher')
            self.widget.integration_widget.img_frame.setWindowTitle(str + u' - © 2015 C. Prescher')
            return

        if img_filename is not '' or spec_filename is not '':
            str += ' - ['
        if img_filename is not '':
            str += img_filename
        elif img_filename is '' and spec_filename is not '':
            str += spec_filename
        if not img_filename == spec_filename:
            str += ', ' + spec_filename
        if calibration_name is not None:
            str += ', calibration: ' + calibration_name
        str += ']'
        str += u' - © 2015 C. Prescher'
        self.widget.setWindowTitle(str)
        self.widget.integration_widget.img_frame.setWindowTitle(str)

    def load_settings(self):
        """
        Loads previously saved Dioptas settings.
        """
        if os.path.exists(self.settings_directory):
            self.load_directories()
            self.load_xml_settings()

    def load_directories(self):
        """
        Loads previously used Dioptas directory paths.
        """
        working_directories_path = os.path.join(self.settings_directory, 'working_directories.csv')
        if os.path.exists(working_directories_path):
            reader = csv.reader(open(working_directories_path, 'r'))
            self.working_directories = dict(x for x in reader)

    def load_xml_settings(self):
        """
        Loads previously used Dioptas settings. Currently this is only the calibration.
        :return:
        """
        xml_settings_path = os.path.join(self.settings_directory, "settings.xml")
        if os.path.exists(xml_settings_path):
            tree = ET.parse(xml_settings_path)
            root = tree.getroot()
            filenames = root.find("filenames")
            calibration_path = filenames.find("calibration").text
            if os.path.exists(str(calibration_path)):
                self.calibration_model.load(calibration_path)

    def save_settings(self):
        """
        Saves current settings of Dioptas in the users directory.
        """
        if not os.path.exists(self.settings_directory):
            os.mkdir(self.settings_directory)
        self.save_directories()
        self.save_xml_settings()

    def save_directories(self):
        """
        Currently used working directories for images, spectra, etc. are saved as csv file in the users directory for
        reuse when Dioptas is started again
        """

        working_directories_path = os.path.join(self.settings_directory, 'working_directories.csv')
        writer = csv.writer(open(working_directories_path, 'w'))
        for key, value in list(self.working_directories.items()):
            writer.writerow([key, value])
            writer.writerow([key, value])

    def save_xml_settings(self):
        """
        Currently used settings of Dioptas are saved in to an xml file in the users directory for reuse when Dioptas is
        started again. Right now this is only saving the calibration filename.
        """
        root = ET.Element("DioptasSettings")
        filenames = ET.SubElement(root, "filenames")
        calibration_filename = ET.SubElement(filenames, "calibration")
        calibration_filename.text = self.calibration_model.filename
        tree = ET.ElementTree(root)
        tree.write(os.path.join(self.settings_directory, "settings.xml"))

    def close_event(self, _):
        """
        Intervention of the Dioptas close event to save settings before closing the Program.
        """
        if self.use_settings:
            self.save_settings()
        QtGui.QApplication.closeAllWindows()
        QtGui.QApplication.quit()
Exemplo n.º 13
0
class MaskControllerTest(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.app = QtGui.QApplication([])

    @classmethod
    def tearDownClass(cls):
        cls.app.quit()
        cls.app.deleteLater()

    def setUp(self):
        self.working_dir = {}

        self.img_model = ImgModel()
        self.mask_model = MaskModel()
        self.mask_widget = MaskWidget()
        self.mask_controller = MaskController(self.working_dir,
                                              self.mask_widget, self.img_model,
                                              self.mask_model)

    def tearDown(self):
        del self.img_model
        del self.mask_model
        self.mask_widget.close()
        del self.mask_widget
        del self.mask_controller
        gc.collect()

    def get_file_size(self, filename):
        stat_info = os.stat(filename)
        return stat_info.st_size

    def test_loading_and_saving_mask_files(self):
        self.mask_controller.load_mask_btn_click(
            os.path.join(data_path, 'test.mask'))
        self.mask_model.mask_below_threshold(self.img_model, 1)
        filename = os.path.join(data_path, 'dummy.mask')
        self.mask_controller.save_mask_btn_click(filename)
        self.assertTrue(os.path.exists(filename))
        os.remove(filename)

    def test_loading_and_saving_with_super_sampling(self):
        self.mask_model.set_supersampling(2)
        self.mask_controller.load_mask_btn_click(
            os.path.join(data_path, 'test.mask'))

        self.assertEqual(self.mask_model.get_mask().shape[0], 4096)
        self.assertEqual(self.mask_model.get_mask().shape[1], 4096)

        self.assertEqual(self.mask_model.get_img().shape[0], 2048)
        self.assertEqual(self.mask_model.get_img().shape[1], 2048)

        self.mask_model.mask_below_threshold(self.img_model, 1)

        filename = os.path.join(data_path, 'dummy.mask')
        self.mask_controller.save_mask_btn_click(filename)
        self.assertAlmostEqual(self.get_file_size(filename),
                               self.get_file_size(
                                   os.path.join(data_path, 'test.mask')),
                               delta=20)

    def test_grow_and_shrinking(self):
        self.mask_model.mask_ellipse(100, 100, 20, 20)
        previous_mask = np.copy(self.mask_model._mask_data)

        QTest.mouseClick(self.mask_widget.grow_btn, QtCore.Qt.LeftButton)
        self.assertFalse(
            np.array_equal(previous_mask, self.mask_model._mask_data))

        QTest.mouseClick(self.mask_widget.shrink_btn, QtCore.Qt.LeftButton)
        self.assertTrue(
            np.array_equal(previous_mask, self.mask_model._mask_data))
Exemplo n.º 14
0
 def setUp(self):
     self.mask_model = MaskModel()
     self.img = np.zeros((10, 10))
     self.mask_model.set_dimension(self.img.shape)
Exemplo n.º 15
0
class MaskModelTest(unittest.TestCase):
    def setUp(self):
        self.mask_model = MaskModel()
        self.img = np.zeros((10, 10))
        self.mask_model.set_dimension(self.img.shape)

    def tearDown(self):
        del self.mask_model
        del self.img
        gc.collect()

    def test_growing_masks(self):
        self.mask_model._mask_data[4, 4] = 1
        self.mask_model._mask_data[0, 0] = 1
        self.mask_model._mask_data[0, 9] = 1
        self.mask_model._mask_data[9, 9] = 1
        self.mask_model._mask_data[9, 0] = 1

        self.mask_model.grow()

        # tests corners
        self.assertEqual(self.mask_model._mask_data[0, 1], 1)
        self.assertEqual(self.mask_model._mask_data[1, 1], 1)
        self.assertEqual(self.mask_model._mask_data[1, 0], 1)

        self.assertEqual(self.mask_model._mask_data[0, 8], 1)
        self.assertEqual(self.mask_model._mask_data[1, 8], 1)
        self.assertEqual(self.mask_model._mask_data[1, 9], 1)

        self.assertEqual(self.mask_model._mask_data[8, 0], 1)
        self.assertEqual(self.mask_model._mask_data[8, 1], 1)
        self.assertEqual(self.mask_model._mask_data[9, 1], 1)

        self.assertEqual(self.mask_model._mask_data[8, 8], 1)
        self.assertEqual(self.mask_model._mask_data[8, 9], 1)
        self.assertEqual(self.mask_model._mask_data[9, 8], 1)

        # tests center
        self.assertEqual(self.mask_model._mask_data[3, 3], 1)
        self.assertEqual(self.mask_model._mask_data[4, 3], 1)
        self.assertEqual(self.mask_model._mask_data[5, 3], 1)

        self.assertEqual(self.mask_model._mask_data[3, 5], 1)
        self.assertEqual(self.mask_model._mask_data[4, 5], 1)
        self.assertEqual(self.mask_model._mask_data[5, 5], 1)

        self.assertEqual(self.mask_model._mask_data[3, 4], 1)
        self.assertEqual(self.mask_model._mask_data[5, 4], 1)

    def test_shrink_mask(self):
        self.mask_model._mask_data[4, 4] = 1
        self.mask_model._mask_data[0, 0] = 1
        self.mask_model._mask_data[0, 9] = 1
        self.mask_model._mask_data[9, 9] = 1
        self.mask_model._mask_data[9, 0] = 1

        self.before_mask = np.copy(self.mask_model._mask_data)
        self.mask_model.grow()
        self.mask_model.shrink()

        self.assertTrue(np.array_equal(self.before_mask, self.mask_model._mask_data))

        self.mask_model.clear_mask()

        self.mask_model._mask_data[4, 4] = 1
        self.mask_model._mask_data[5, 4] = 1
        self.mask_model._mask_data[5, 5] = 1
        self.mask_model._mask_data[4, 5] = 1
        self.mask_model.shrink()

        self.assertEqual(np.sum(self.mask_model._mask_data), 0)

    def test_saving_and_loading(self):
        self.mask_model.mask_ellipse(1024, 1024, 100, 100)
        self.mask_model.set_dimension((2048, 2048))

        mask_array = np.copy(self.mask_model.get_img())

        filename = os.path.join(data_path, 'dummy.mask')

        self.mask_model.save_mask(filename)
        self.mask_model.load_mask(filename)

        self.assertTrue(np.array_equal(mask_array, self.mask_model.get_img()))
        os.remove(filename)
Exemplo n.º 16
0
class CbnAbsorptionCorrectionOptimizationTest(unittest.TestCase):
    def setUp(self):
        # creating Data objects
        self.img_data = ImgModel()
        self.img_data.load("Data/CbnCorrectionOptimization/Mg2SiO4_091.tif")
        self.calibration_data = CalibrationModel(self.img_data)
        self.calibration_data.load("Data/CbnCorrectionOptimization/LaB6_40keV side.poni")
        self.mask_data = MaskModel()
        self.mask_data.load_mask("Data/CbnCorrectionOptimization/Mg2SiO4_91_combined.mask")

        # creating the ObliqueAngleDetectorAbsorptionCorrection
        _, fit2d_parameter = self.calibration_data.get_calibration_parameter()
        detector_tilt = fit2d_parameter['tilt']
        detector_tilt_rotation = fit2d_parameter['tiltPlanRotation']

        self.tth_array = self.calibration_data.spectrum_geometry.twoThetaArray((2048, 2048))
        self.azi_array = self.calibration_data.spectrum_geometry.chiArray((2048, 2048))

        self.oiadac_correction = ObliqueAngleDetectorAbsorptionCorrection(
                self.tth_array, self.azi_array,
                detector_thickness=40,
                absorption_length=465.5,
                tilt=detector_tilt,
                rotation=detector_tilt_rotation,
        )
        self.img_data.add_img_correction(self.oiadac_correction, "oiadac")

    def tearDown(self):
        del self.calibration_data.cake_geometry
        del self.calibration_data.spectrum_geometry

    def test_the_world(self):
        params = Parameters()
        params.add("diamond_thickness", value=2, min=1.9, max=2.3)
        params.add("seat_thickness", value=5.3, min=4.0, max=6.6, vary=False)
        params.add("small_cbn_seat_radius", value=0.2, min=0.10, max=0.5, vary=True)
        params.add("large_cbn_seat_radius", value=1.95, min=1.85, max=2.05, vary=False)
        params.add("tilt", value=3.3, min=0, max=8)
        params.add("tilt_rotation", value=0, min=-15, max=+15)
        params.add("cbn_abs_length", value=14.05, min=12, max=16)

        region = [8, 26]

        self.tth_array = 180.0 / np.pi * self.tth_array
        self.azi_array = 180.0 / np.pi * self.azi_array

        def fcn2min(params):
            cbn_correction = CbnCorrection(
                    tth_array=self.tth_array,
                    azi_array=self.azi_array,
                    diamond_thickness=params['diamond_thickness'].value,
                    seat_thickness=params['seat_thickness'].value,
                    small_cbn_seat_radius=params['small_cbn_seat_radius'].value,
                    large_cbn_seat_radius=params['large_cbn_seat_radius'].value,
                    tilt=params['tilt'].value,
                    tilt_rotation=params['tilt_rotation'].value,
                    cbn_abs_length=params["cbn_abs_length"].value
            )
            self.img_data.add_img_correction(cbn_correction, "cbn")
            tth, int = self.calibration_data.integrate_1d(mask=self.mask_data.get_mask())
            self.img_data.delete_img_correction("cbn")
            ind = np.where((tth > region[0]) & (tth < region[1]))
            int = gaussian_filter1d(int, 20)
            return (np.diff(int[ind])) ** 2

        def output_values(param1, iteration, residual):
            report_fit(param1)

        result = minimize(fcn2min, params, iter_cb=output_values)
        report_fit(params)

        # plotting result:
        cbn_correction = CbnCorrection(
                tth_array=self.tth_array,
                azi_array=self.azi_array,
                diamond_thickness=params['diamond_thickness'].value,
                seat_thickness=params['seat_thickness'].value,
                small_cbn_seat_radius=params['small_cbn_seat_radius'].value,
                large_cbn_seat_radius=params['large_cbn_seat_radius'].value,
                tilt=params['tilt'].value,
                tilt_rotation=params['tilt_rotation'].value,
                cbn_abs_length=params['cbn_abs_length'].value
        )
        self.img_data.add_img_correction(cbn_correction, "cbn")
        tth, int = self.calibration_data.integrate_1d(mask=self.mask_data.get_mask())
        ind = np.where((tth > region[0]) & (tth < region[1]))
        tth = tth[ind]
        int = int[ind]
        int_smooth = gaussian_filter1d(int, 10)

        int_diff1 = np.diff(int)
        int_diff1_smooth = np.diff(int_smooth)
        int_diff2 = np.diff(int_diff1)
        int_diff2_smooth = np.diff(int_diff1_smooth)

        plt.figure()
        plt.subplot(3, 1, 1)
        plt.plot(tth, int)
        plt.plot(tth, int_smooth)
        plt.subplot(3, 1, 2)
        plt.plot(int_diff1)
        plt.plot(int_diff1_smooth)
        plt.subplot(3, 1, 3)
        plt.plot(int_diff2)
        plt.plot(int_diff2_smooth)
        plt.savefig("Results/optimize_cbn_absorption.png", dpi=300)

        os.system("open " + "Results/optimize_cbn_absorption.png")
Exemplo n.º 17
0
class MainController(object):
    """
    Creates a the main controller for Dioptas. Creates all the data objects and connects them with the other controllers
    """
    def __init__(self, use_settings=True):
        self.use_settings = use_settings

        self.widget = MainWidget()
        # create data
        self.img_model = ImgModel()
        self.calibration_model = CalibrationModel(self.img_model)
        self.mask_model = MaskModel()
        self.spectrum_model = PatternModel()
        self.phase_model = PhaseModel()

        self.settings_directory = os.path.join(os.path.expanduser("~"),
                                               '.Dioptas')
        self.working_directories = {
            'calibration': '',
            'mask': '',
            'image': '',
            'spectrum': '',
            'overlay': '',
            'phase': ''
        }

        if use_settings:
            self.load_settings()

        self.calibration_controller = CalibrationController(
            self.working_directories, self.widget.calibration_widget,
            self.img_model, self.mask_model, self.calibration_model)
        self.mask_controller = MaskController(self.working_directories,
                                              self.widget.mask_widget,
                                              self.img_model, self.mask_model)
        self.integration_controller = IntegrationController(
            self.working_directories, self.widget.integration_widget,
            self.img_model, self.mask_model, self.calibration_model,
            self.spectrum_model, self.phase_model)
        self.create_signals()
        self.update_title()

        self.current_tab_index = 0

    def show_window(self):
        """
        Displays the main window on the screen and makes it active.
        """
        self.widget.show()

        if _platform == "darwin":
            self.widget.setWindowState(self.widget.windowState()
                                       & ~QtCore.Qt.WindowMinimized
                                       | QtCore.Qt.WindowActive)
            self.widget.activateWindow()
            self.widget.raise_()

    def create_signals(self):
        """
        Creates subscriptions for changing tabs and also newly loaded files which will update the title of the main
                window.
        """
        self.widget.tabWidget.currentChanged.connect(self.tab_changed)
        self.widget.closeEvent = self.close_event
        self.img_model.img_changed.connect(self.update_title)
        self.spectrum_model.pattern_changed.connect(self.update_title)

    def tab_changed(self, ind):
        """
        Function which is called when a tab has been selected (calibration, mask, or integration). Performs
        needed initialization tasks.
        :param ind: index for the tab selected (2 - integration, 1 = mask, 0 - calibration)
        :return:
        """
        old_index = self.current_tab_index
        self.current_tab_index = ind

        # get the old view range
        old_view_range = None
        old_hist_levels = None
        if old_index == 0:  # calibration tab
            old_view_range = self.widget.calibration_widget.img_widget.img_view_box.targetRange(
            )
            old_hist_levels = self.widget.calibration_widget.img_widget.img_histogram_LUT.getExpLevels(
            )
        elif old_index == 1:  # mask tab
            old_view_range = self.widget.mask_widget.img_widget.img_view_box.targetRange(
            )
            old_hist_levels = self.widget.mask_widget.img_widget.img_histogram_LUT.getExpLevels(
            )
        elif old_index == 2:
            old_view_range = self.widget.integration_widget.img_widget.img_view_box.targetRange(
            )
            old_hist_levels = self.widget.integration_widget.img_widget.img_histogram_LUT.getExpLevels(
            )

        # update the GUI
        if ind == 2:  # integration tab
            self.mask_model.set_supersampling()
            self.integration_controller.image_controller.plot_mask()
            self.integration_controller.widget.calibration_lbl.setText(
                self.calibration_model.calibration_name)
            self.integration_controller.image_controller._auto_scale = False
            self.integration_controller.spectrum_controller.image_changed()
            self.integration_controller.image_controller.update_img()
            self.widget.integration_widget.img_widget.set_range(
                x_range=old_view_range[0], y_range=old_view_range[1])
            self.widget.integration_widget.img_widget.img_histogram_LUT.setLevels(
                *old_hist_levels)
        elif ind == 1:  # mask tab
            self.mask_controller.plot_mask()
            self.mask_controller.plot_image()
            self.widget.mask_widget.img_widget.set_range(
                x_range=old_view_range[0], y_range=old_view_range[1])
            self.widget.mask_widget.img_widget.img_histogram_LUT.setLevels(
                *old_hist_levels)
        elif ind == 0:  # calibration tab
            self.calibration_controller.plot_mask()
            try:
                self.calibration_controller.update_calibration_parameter_in_view(
                )
            except (TypeError, AttributeError):
                pass
            self.widget.calibration_widget.img_widget.set_range(
                x_range=old_view_range[0], y_range=old_view_range[1])
            self.widget.calibration_widget.img_widget.img_histogram_LUT.setLevels(
                *old_hist_levels)

    def update_title(self):
        """
        Updates the title bar of the main window. The title bar will always show the current version of Dioptas, the
        image or spectrum filenames loaded and the current calibration name.
        """
        img_filename = os.path.basename(self.img_model.filename)
        spec_filename = os.path.basename(self.spectrum_model.pattern_filename)
        calibration_name = self.calibration_model.calibration_name
        str = 'Dioptas ' + __version__
        if img_filename is '' and spec_filename is '':
            self.widget.setWindowTitle(str + u' - © 2015 C. Prescher')
            self.widget.integration_widget.img_frame.setWindowTitle(
                str + u' - © 2015 C. Prescher')
            return

        if img_filename is not '' or spec_filename is not '':
            str += ' - ['
        if img_filename is not '':
            str += img_filename
        elif img_filename is '' and spec_filename is not '':
            str += spec_filename
        if not img_filename == spec_filename:
            str += ', ' + spec_filename
        if calibration_name is not None:
            str += ', calibration: ' + calibration_name
        str += ']'
        str += u' - © 2015 C. Prescher'
        self.widget.setWindowTitle(str)
        self.widget.integration_widget.img_frame.setWindowTitle(str)

    def load_settings(self):
        """
        Loads previously saved Dioptas settings.
        """
        if os.path.exists(self.settings_directory):
            self.load_directories()
            self.load_xml_settings()

    def load_directories(self):
        """
        Loads previously used Dioptas directory paths.
        """
        working_directories_path = os.path.join(self.settings_directory,
                                                'working_directories.csv')
        if os.path.exists(working_directories_path):
            reader = csv.reader(open(working_directories_path, 'r'))
            self.working_directories = dict(x for x in reader)

    def load_xml_settings(self):
        """
        Loads previously used Dioptas settings. Currently this is only the calibration.
        :return:
        """
        xml_settings_path = os.path.join(self.settings_directory,
                                         "settings.xml")
        if os.path.exists(xml_settings_path):
            tree = ET.parse(xml_settings_path)
            root = tree.getroot()
            filenames = root.find("filenames")
            calibration_path = filenames.find("calibration").text
            if os.path.exists(str(calibration_path)):
                self.calibration_model.load(calibration_path)

    def save_settings(self):
        """
        Saves current settings of Dioptas in the users directory.
        """
        if not os.path.exists(self.settings_directory):
            os.mkdir(self.settings_directory)
        self.save_directories()
        self.save_xml_settings()

    def save_directories(self):
        """
        Currently used working directories for images, spectra, etc. are saved as csv file in the users directory for
        reuse when Dioptas is started again
        """

        working_directories_path = os.path.join(self.settings_directory,
                                                'working_directories.csv')
        writer = csv.writer(open(working_directories_path, 'w'))
        for key, value in list(self.working_directories.items()):
            writer.writerow([key, value])
            writer.writerow([key, value])

    def save_xml_settings(self):
        """
        Currently used settings of Dioptas are saved in to an xml file in the users directory for reuse when Dioptas is
        started again. Right now this is only saving the calibration filename.
        """
        root = ET.Element("DioptasSettings")
        filenames = ET.SubElement(root, "filenames")
        calibration_filename = ET.SubElement(filenames, "calibration")
        calibration_filename.text = self.calibration_model.filename
        tree = ET.ElementTree(root)
        tree.write(os.path.join(self.settings_directory, "settings.xml"))

    def close_event(self, _):
        """
        Intervention of the Dioptas close event to save settings before closing the Program.
        """
        if self.use_settings:
            self.save_settings()
        QtGui.QApplication.closeAllWindows()
        QtGui.QApplication.quit()
Exemplo n.º 18
0
class MainController(object):
    """
    Creates a the main controller for Dioptas. Loads all the data objects and connects them with the other controllers
    """

    def __init__(self, use_settings=True):
        self.use_settings = use_settings

        self.widget = MainWidget()
        #create data
        self.img_model = ImgModel()
        self.calibration_model = CalibrationModel(self.img_model)
        self.mask_model = MaskModel()
        self.spectrum_model = SpectrumModel()
        self.phase_model = PhaseModel()

        self.settings_directory = os.path.join(os.path.expanduser("~"), '.Dioptas')
        self.working_directories = {'calibration': '', 'mask': '', 'image': '', 'spectrum': '', 'overlay': '',
                                'phase': ''}


        if use_settings:
            self.load_settings()
        #create controller
        self.calibration_controller = CalibrationController(self.working_directories,
                                                            self.widget.calibration_widget,
                                                            self.img_model,
                                                            self.mask_model,
                                                            self.calibration_model)
        self.mask_controller = MaskController(self.working_directories,
                                              self.widget.mask_widget,
                                              self.img_model,
                                              self.mask_model)
        self.integration_controller = IntegrationController(self.working_directories,
                                                            self.widget.integration_widget,
                                                            self.img_model,
                                                            self.mask_model,
                                                            self.calibration_model,
                                                            self.spectrum_model,
                                                            self.phase_model)
        self.create_signals()
        self.set_title()

    def show_window(self):
        self.widget.show()
        self.widget.setWindowState(self.widget.windowState() & ~QtCore.Qt.WindowMinimized | QtCore.Qt.WindowActive)
        self.widget.activateWindow()
        self.widget.raise_()

    def create_signals(self):
        self.widget.tabWidget.currentChanged.connect(self.tab_changed)
        self.widget.closeEvent = self.close_event
        self.img_model.subscribe(self.set_title)
        self.spectrum_model.spectrum_changed.connect(self.set_title)

    def tab_changed(self, ind):
        if ind == 2:
            self.mask_model.set_supersampling()
            self.integration_controller.image_controller.plot_mask()
            self.integration_controller.widget.calibration_lbl.setText(self.calibration_model.calibration_name)
            self.integration_controller.image_controller._auto_scale = False
            self.integration_controller.spectrum_controller.image_changed()
            self.integration_controller.image_controller.update_img()
        elif ind == 1:
            self.mask_controller.plot_mask()
            self.mask_controller.plot_image()
        elif ind == 0:
            self.calibration_controller.plot_mask()
            try:
                self.calibration_controller.update_calibration_parameter_in_view()
            except (TypeError, AttributeError):
                pass

    def set_title(self):
        img_filename = os.path.basename(self.img_model.filename)
        spec_filename = os.path.basename(self.spectrum_model.spectrum_filename)
        calibration_name = self.calibration_model.calibration_name
        str = 'Dioptas ' + __version__
        if img_filename is '' and spec_filename is '':
            self.widget.setWindowTitle(str + u' - © 2015 C. Prescher')
            self.widget.integration_widget.img_frame.setWindowTitle(str + u' - © 2015 C. Prescher')
            return

        if img_filename is not '' or spec_filename is not '':
            str += ' - ['
        if img_filename is not '':
            str += img_filename
        elif img_filename is '' and spec_filename is not '':
            str += spec_filename
        if not img_filename == spec_filename:
            str += ', ' + spec_filename
        if calibration_name is not None:
            str += ', calibration: ' + calibration_name
        str += ']'
        str += u' - © 2015 C. Prescher'
        self.widget.setWindowTitle(str)
        self.widget.integration_widget.img_frame.setWindowTitle(str)

    def load_settings(self):
        if os.path.exists(self.settings_directory):
            self.load_directories()
            self.load_xml_settings()

    def load_directories(self):
        working_directories_path = os.path.join(self.settings_directory, 'working_directories.csv')
        if os.path.exists(working_directories_path):
            reader = csv.reader(open(working_directories_path, 'r'))
            self.working_directories = dict(x for x in reader)


    def load_xml_settings(self):
        xml_settings_path = os.path.join(self.settings_directory, "settings.xml")
        if os.path.exists(xml_settings_path):
            tree = ET.parse(xml_settings_path)
            root = tree.getroot()
            filenames = root.find("filenames")
            calibration_path=filenames.find("calibration").text
            if os.path.exists(str(calibration_path)):
                self.calibration_model.load(calibration_path)

    def save_settings(self):
        if not os.path.exists(self.settings_directory):
            os.mkdir(self.settings_directory)
        self.save_directories()
        self.save_xml_settings()

    def save_directories(self):
        working_directories_path = os.path.join(self.settings_directory, 'working_directories.csv')
        writer = csv.writer(open(working_directories_path, 'w'))
        for key, value in list(self.working_directories.items()):
            writer.writerow([key, value])
            writer.writerow([key, value])

    def save_xml_settings(self):
        root = ET.Element("DioptasSettings")
        filenames = ET.SubElement(root, "filenames")
        calibration_filename = ET.SubElement(filenames, "calibration")
        calibration_filename.text = self.calibration_model.filename
        tree = ET.ElementTree(root)
        tree.write(os.path.join(self.settings_directory, "settings.xml"))

    def close_event(self, _):
        if self.use_settings:
            self.save_settings()
        QtGui.QApplication.closeAllWindows()
        QtGui.QApplication.quit()
class CalibrationControllerTest(unittest.TestCase):
    def setUp(self):
        self.app = QtGui.QApplication(sys.argv)
        self.img_model = ImgModel()
        self.mask_model = MaskModel()
        self.calibration_model = CalibrationModel(self.img_model)
        self.calibration_model._calibrants_working_dir = os.path.join(data_path, 'calibrants')
        self.calibration_widget = CalibrationWidget()
        self.working_dir = {}
        self.calibration_controller = CalibrationController(working_dir=self.working_dir,
                                                            img_model=self.img_model,
                                                            mask_model=self.mask_model,
                                                            widget=self.calibration_widget,
                                                            calibration_model=self.calibration_model)

    def tearDown(self):
        del self.img_model
        del self.calibration_model.cake_geometry
        del self.calibration_model.spectrum_geometry
        del self.calibration_model
        del self.app
        gc.collect()

    def load_pilatus_1M_and_pick_peaks(self):
        self.calibration_controller.load_img(os.path.join(data_path,'CeO2_Pilatus1M.tif'))
        QTest.mouseClick(self.calibration_widget.automatic_peak_num_inc_cb, QtCore.Qt.LeftButton)

        self.assertFalse(self.calibration_widget.automatic_peak_num_inc_cb.isChecked())
        self.calibration_controller.search_peaks(517.664434674, 647.529865592)
        self.calibration_controller.search_peaks(667.380513299, 525.252854758)
        self.calibration_controller.search_peaks(671.110095329, 473.571503774)
        self.calibration_controller.search_peaks(592.788872703, 350.495296791)
        self.calibration_controller.search_peaks(387.395462348, 390.987901686)
        self.calibration_controller.search_peaks(367.94835605, 554.290314848)

        self.calibration_widget.sv_wavelength_txt.setText('0.406626')
        self.calibration_widget.sv_distance_txt.setText('200')
        self.calibration_widget.sv_pixel_width_txt.setText('172')
        self.calibration_widget.sv_pixel_height_txt.setText('172')
        calibrant_index = self.calibration_widget.calibrant_cb.findText('CeO2')
        self.calibration_widget.calibrant_cb.setCurrentIndex(calibrant_index)

        self.mask_model.set_dimension(self.img_model.img_data.shape)

    def test_automatic_calibration1(self):
        self.calibration_controller.load_img(os.path.join(data_path,'LaB6_40keV_MarCCD.tif'))
        self.calibration_controller.search_peaks(1179.6, 1129.4)
        self.calibration_controller.search_peaks(1268.5, 1119.8)
        self.calibration_controller.widget.sv_wavelength_txt.setText('0.31')
        self.calibration_controller.widget.sv_distance_txt.setText('200')
        self.calibration_controller.widget.sv_pixel_width_txt.setText('79')
        self.calibration_controller.widget.sv_pixel_height_txt.setText('79')
        calibrant_index = self.calibration_widget.calibrant_cb.findText('LaB6')
        self.calibration_controller.widget.calibrant_cb.setCurrentIndex(calibrant_index)
        self.calibration_controller.calibrate()
        self.calibration_controller.widget.cake_view.set_vertical_line_pos(1419.8, 653.4)

    def test_automatic_calibration2(self):
        self.calibration_controller.load_img(os.path.join(data_path,'LaB6_OffCenter_PE.tif'))
        self.calibration_controller.search_peaks(1245.2, 1919.3)
        self.calibration_controller.search_peaks(1334.0, 1823.7)
        self.calibration_controller.widget.sv_wavelength_txt.setText('0.3344')
        self.calibration_controller.widget.sv_distance_txt.setText('500')
        self.calibration_controller.widget.sv_pixel_width_txt.setText('200')
        self.calibration_controller.widget.sv_pixel_height_txt.setText('200')
        calibrant_index = self.calibration_widget.calibrant_cb.findText('LaB6')
        self.calibration_controller.widget.calibrant_cb.setCurrentIndex(calibrant_index)
        self.calibration_controller.calibrate()
        self.calibration_controller.widget.cake_view.set_vertical_line_pos(206.5, 171.6)

    def test_automatic_calibration3(self):
        self.load_pilatus_1M_and_pick_peaks()

        start_values = self.calibration_widget.get_start_values()
        self.assertAlmostEqual(start_values['wavelength'], 0.406626e-10)
        self.assertAlmostEqual(start_values['pixel_height'], 172e-6)
        self.assertAlmostEqual(start_values['pixel_width'], 172e-6)
        self.calibration_controller.load_calibrant()
        self.assertAlmostEqual(self.calibration_model.calibrant.wavelength, 0.406626e-10)

        QTest.mouseClick(self.calibration_widget.integrate_btn, QtCore.Qt.LeftButton)
        calibration_parameter = self.calibration_model.get_calibration_parameter()[0]

        self.assertAlmostEqual(calibration_parameter['dist'], .2086, places=4)

    def test_automatic_calibration_with_supersampling(self):
        self.load_pilatus_1M_and_pick_peaks()
        self.img_model.set_supersampling(2)
        self.calibration_model.set_supersampling(2)
        self.calibration_controller.calibrate()

    def test_automatic_calibration_with_supersampling_and_mask(self):
        self.load_pilatus_1M_and_pick_peaks()
        self.img_model.set_supersampling(2)
        self.mask_model.mask_below_threshold(self.img_model._img_data, 1)
        self.mask_model.set_supersampling(2)
        self.calibration_model.set_supersampling(2)
        self.calibration_controller.widget.use_mask_cb.setChecked(True)
        self.calibration_controller.calibrate()

    def test_calibrating_one_image_size_and_loading_different_image_size(self):
        self.load_pilatus_1M_and_pick_peaks()
        self.calibration_controller.calibrate()
        self.calibration_model.integrate_1d()
        self.calibration_model.integrate_2d()
        self.calibration_controller.load_img(os.path.join(data_path, 'CeO2_Pilatus1M.tif'))
        self.calibration_model.integrate_1d()
        self.calibration_model.integrate_2d()

    def test_loading_and_saving_of_calibration_files(self):
        self.calibration_controller.load_calibration(os.path.join(data_path, 'LaB6_40keV_MarCCD.poni'))
        self.calibration_controller.save_calibration(os.path.join(data_path, 'calibration.poni'))
        self.assertTrue(os.path.exists(os.path.join(data_path, 'calibration.poni')))
        os.remove(os.path.join(data_path, 'calibration.poni'))