コード例 #1
0
ファイル: MainController.py プロジェクト: kif/Py2DeX
    def __init__(self, app):
        self.splash_img = QtGui.QPixmap("UiFiles/splash.png")
        self.splash_screen = QtGui.QSplashScreen(
            self.splash_img, QtCore.Qt.WindowStaysOnTopHint)
        self.splash_screen.show()
        app.processEvents()
        time.sleep(1)
        app.processEvents()

        self.view = MainView()
        #create data
        self.img_data = ImgData()
        self.calibration_data = CalibrationData(self.img_data)
        self.mask_data = MaskData()
        self.spectrum_data = SpectrumData()
        self.phase_data = PhaseData()

        self.load_directories()
        #create controller
        self.calibration_controller = CalibrationController(
            self.working_dir, self.view.calibration_widget, self.img_data,
            self.mask_data, self.calibration_data)
        self.mask_controller = MaskController(self.working_dir,
                                              self.view.mask_widget,
                                              self.img_data, self.mask_data)
        self.integration_controller = IntegrationController(
            self.working_dir, self.view.integration_widget, self.img_data,
            self.mask_data, self.calibration_data, self.spectrum_data,
            self.phase_data)
        self.create_signals()
        self.set_title()
        self.raise_window()
        self.splash_screen.finish(self.view)
コード例 #2
0
ファイル: CombinedDataTest.py プロジェクト: kif/Py2DeX
 def setUp(self):
     self.img_data = ImgData()
     self.img_data.load('Data/Mg2SiO4_ambient_001.tif')
     self.calibration_data = CalibrationData(self.img_data)
     self.calibration_data.load('Data/calibration.poni')
     self.mask_data = MaskData()
     self.mask_data.load_mask('Data/test.mask')
     self.spectrum_data = SpectrumData()
コード例 #3
0
ファイル: test_CombinedData.py プロジェクト: ggarba/Dioptas
class CombinedDataTest(unittest.TestCase):
    def setUp(self):
        self.img_data = ImgData()
        self.img_data.load('Data/Mg2SiO4_ambient_001.tif')
        self.calibration_data = CalibrationData(self.img_data)
        self.calibration_data.load('Data/calibration.poni')
        self.mask_data = MaskData()
        self.mask_data.mask_ellipse(500, 500, 100, 100)
        self.spectrum_data = SpectrumData()

    def test_dependencies(self):
        tth1, int1 = self.calibration_data.integrate_1d()
        self.img_data.load_next_file()

        self.assertEqual(os.path.abspath(self.img_data.filename),
                         os.path.abspath('Data/Mg2SiO4_ambient_002.tif'))
        tth2, int2 = self.calibration_data.integrate_1d()
        self.assertFalse(np.array_equal(int1, int2))

        plt.figure(1)
        plt.plot(tth1, int1)
        plt.plot(tth2, int2)
        plt.savefig('Results/dependencies1.png')

        tth3, int3 = self.calibration_data.integrate_1d(mask=self.mask_data.get_mask())
        self.assertFalse(np.array_equal(int2, int3))
        plt.figure(2)
        plt.plot(tth2, int2)
        plt.plot(tth3, int3)
        plt.savefig('Results/dependencies2.png')

        tth4, int4 = self.calibration_data.integrate_1d(polarization_factor=0.90, mask=None)
        plt.figure(3)
        plt.plot(tth2, int2)
        plt.plot(tth4, int4)
        plt.savefig('Results/dependencies3.png')

        tth5, int5 = self.calibration_data.integrate_1d(polarization_factor=.5, mask=None)
        plt.figure(4)
        plt.plot(tth4, int4)
        plt.plot(tth5, int5)
        plt.savefig('Results/dependencies4.png')

    def test_automatism(self):
        def integrate_and_set_spectrum():
            tth, I = self.calibration_data.integrate_1d()
            self.spectrum_data.set_spectrum(tth, I, self.img_data.filename)

        self.img_data.subscribe(integrate_and_set_spectrum)

        y1 = self.spectrum_data.spectrum.data[1]
        self.img_data.load_next_file()
        y2 = self.spectrum_data.spectrum.data[1]
        self.assertFalse(np.array_equal(y1, y2))
コード例 #4
0
ファイル: SpectrumDataTest.py プロジェクト: kif/Py2DeX
class SpectrumDataTest(unittest.TestCase):
    def setUp(self):
        self.spectrum = Spectrum()
        self.spectrum_data = SpectrumData()

    def test_spectrum_class(self):
        self.spectrum.save('Data/spec_test.txt')
        self.spectrum.save(
            'Data/spec_test2.txt',
            header='This is not only ridiculous\n but more and more '
            'challenging...')
        self.spectrum.load('Data/spec_test.txt')
        self.spectrum.load('Data/spec_test2.txt')

        self.assertTrue(
            np.array_equal(self.spectrum.data[0], np.linspace(0, 30, 100)))
        self.assertTrue(self.spectrum.load('Data/test_001.tif') == -1)

        self.spectrum.data = (np.linspace(0, 30), np.linspace(0, 20))
        self.spectrum.offset = 100
        self.assertTrue(
            np.array_equal(self.spectrum.data[1],
                           np.linspace(0, 20) + 100))
        self.assertTrue(
            np.array_equal(self.spectrum.data[0], np.linspace(0, 30)))

        self.spectrum.scaling = 10
        self.assertTrue(
            np.array_equal(self.spectrum.data[1],
                           np.linspace(0, 20) * 10 + 100))

        self.spectrum.data = (np.linspace(0, 20), np.linspace(0, 30))
        self.assertTrue(
            np.array_equal(self.spectrum.data[1], np.linspace(0, 30)))

        self.spectrum.scaling = -100
        self.assertTrue(
            np.array_equal(self.spectrum.data[1],
                           np.zeros(self.spectrum.data[0].shape)))

    def test_spectrum_data_class(self):
        self.spectrum_data.set_spectrum(np.linspace(0, 10),
                                        np.linspace(0, 10)**2, 'SQUARED')
        self.spectrum_data.add_overlay(np.linspace(0, 10),
                                       np.linspace(0, 10)**3, 'CUBED')
        self.spectrum_data.add_overlay(np.linspace(0, 10),
                                       np.linspace(0, 10)**4, 'QUADRUPOLED')

        self.assertTrue(len(self.spectrum_data.overlays) == 2)
        self.spectrum_data.del_overlay(0)
        self.assertTrue(self.spectrum_data.overlays[0].name == 'QUADRUPOLED')

        self.spectrum_data.add_overlay_file('Data/spec_test2.txt')
        self.assertTrue(self.spectrum_data.overlays[-1].name == 'spec_test2')
コード例 #5
0
ファイル: CombinedDataTest.py プロジェクト: kif/Py2DeX
class CombinedDataTest(unittest.TestCase):
    def setUp(self):
        self.img_data = ImgData()
        self.img_data.load('Data/Mg2SiO4_ambient_001.tif')
        self.calibration_data = CalibrationData(self.img_data)
        self.calibration_data.load('Data/calibration.poni')
        self.mask_data = MaskData()
        self.mask_data.load_mask('Data/test.mask')
        self.spectrum_data = SpectrumData()

    def test_dependencies(self):
        tth1, int1 = self.calibration_data.integrate_1d()
        self.img_data.load_next()
        tth2, int2 = self.calibration_data.integrate_1d()
        self.assertFalse(np.array_equal(int1, int2))

        plt.figure(1)
        plt.plot(tth1, int1)
        plt.plot(tth2, int2)
        plt.savefig('Results/dependencies1.jpg')

        tth3, int3 = self.calibration_data.integrate_1d(mask=self.mask_data.get_mask())
        self.assertFalse(np.array_equal(int2, int3))
        plt.figure(2)
        plt.plot(tth2, int2)
        plt.plot(tth3, int3)
        plt.savefig('Results/dependencies2.jpg')

        tth4, int4 = self.calibration_data.integrate_1d(polarization_factor=0.90, mask=None)
        plt.figure(3)
        plt.plot(tth2, int2)
        plt.plot(tth4, int4)
        plt.savefig('Results/dependencies3.jpg')

        tth5, int5 = self.calibration_data.integrate_1d(polarization_factor=.5, mask=None)
        plt.figure(4)
        plt.plot(tth4, int4)
        plt.plot(tth5, int5)
        plt.savefig('Results/dependencies4.jpg')

    def test_automatism(self):
        def integrate_and_set_spectrum():
            tth, I = self.calibration_data.integrate_1d()
            self.spectrum_data.set_spectrum(tth, I, self.img_data.filename)

        self.img_data.subscribe(integrate_and_set_spectrum)

        y1 = self.spectrum_data.spectrum.data[1]
        self.img_data.load_next()
        y2 = self.spectrum_data.spectrum.data[1]
        self.assertFalse(np.array_equal(y1, y2))
コード例 #6
0
ファイル: MainController.py プロジェクト: ggarba/Dioptas
    def __init__(self):
        self.view = MainView()
        #create data
        self.img_data = ImgData()
        self.calibration_data = CalibrationData(self.img_data)
        self.mask_data = MaskData()
        self.spectrum_data = SpectrumData()
        self.phase_data = PhaseData()

        self.settings_directory = os.path.join(os.path.expanduser("~"), '.Dioptas')
        self.working_directories = {'calibration': '', 'mask': '', 'image': '', 'spectrum': '', 'overlay': '',
                                'phase': ''}
        self.load_settings()
        #create controller
        self.calibration_controller = CalibrationController(self.working_directories,
                                                            self.view.calibration_widget,
                                                            self.img_data,
                                                            self.mask_data,
                                                            self.calibration_data)
        self.mask_controller = MaskController(self.working_directories,
                                              self.view.mask_widget,
                                              self.img_data,
                                              self.mask_data)
        self.integration_controller = IntegrationController(self.working_directories,
                                                            self.view.integration_widget,
                                                            self.img_data,
                                                            self.mask_data,
                                                            self.calibration_data,
                                                            self.spectrum_data,
                                                            self.phase_data)
        self.create_signals()
        self.set_title()
        self.raise_window(self.view)
コード例 #7
0
    def __init__(self):
        self.view = MainView()

        #create data
        self.img_data = ImgData()
        self.calibration_data = CalibrationData(self.img_data)
        self.mask_data = MaskData()
        self.spectrum_data = SpectrumData()
        self.phase_data = PhaseData()

        self.load_directories()
        #create controller
        self.calibration_controller = CalibrationController(
            self.working_dir, self.view.calibration_widget, self.img_data,
            self.calibration_data)
        self.mask_controller = MaskController(self.working_dir,
                                              self.view.mask_widget,
                                              self.img_data, self.mask_data)
        self.integration_controller = IntegrationController(
            self.working_dir, self.view.integration_widget, self.img_data,
            self.mask_data, self.calibration_data, self.spectrum_data,
            self.phase_data)

        self.create_signals()
        self.raise_window()
コード例 #8
0
ファイル: test_CombinedData.py プロジェクト: ggarba/Dioptas
 def setUp(self):
     self.img_data = ImgData()
     self.img_data.load('Data/Mg2SiO4_ambient_001.tif')
     self.calibration_data = CalibrationData(self.img_data)
     self.calibration_data.load('Data/calibration.poni')
     self.mask_data = MaskData()
     self.mask_data.mask_ellipse(500, 500, 100, 100)
     self.spectrum_data = SpectrumData()
コード例 #9
0
ファイル: SpectrumDataTest.py プロジェクト: kif/Py2DeX
class SpectrumDataTest(unittest.TestCase):
    def setUp(self):
        self.spectrum = Spectrum()
        self.spectrum_data = SpectrumData()

    def test_spectrum_class(self):
        self.spectrum.save('Data/spec_test.txt')
        self.spectrum.save('Data/spec_test2.txt',
                           header='This is not only ridiculous\n but more and more '
                                  'challenging...')
        self.spectrum.load('Data/spec_test.txt')
        self.spectrum.load('Data/spec_test2.txt')

        self.assertTrue(np.array_equal(self.spectrum.data[0], np.linspace(0, 30, 100)))
        self.assertTrue(self.spectrum.load('Data/test_001.tif') == -1)

        self.spectrum.data = (np.linspace(0, 30), np.linspace(0, 20))
        self.spectrum.offset = 100
        self.assertTrue(np.array_equal(self.spectrum.data[1], np.linspace(0, 20) + 100))
        self.assertTrue(np.array_equal(self.spectrum.data[0], np.linspace(0, 30)))

        self.spectrum.scaling = 10
        self.assertTrue(np.array_equal(self.spectrum.data[1], np.linspace(0, 20) * 10 + 100))

        self.spectrum.data = (np.linspace(0, 20), np.linspace(0, 30))
        self.assertTrue(np.array_equal(self.spectrum.data[1], np.linspace(0, 30)))

        self.spectrum.scaling = -100
        self.assertTrue(np.array_equal(self.spectrum.data[1], np.zeros(self.spectrum.data[0].shape)))

    def test_spectrum_data_class(self):
        self.spectrum_data.set_spectrum(np.linspace(0, 10), np.linspace(0, 10) ** 2, 'SQUARED')
        self.spectrum_data.add_overlay(np.linspace(0, 10), np.linspace(0, 10) ** 3, 'CUBED')
        self.spectrum_data.add_overlay(np.linspace(0, 10), np.linspace(0, 10) ** 4, 'QUADRUPOLED')

        self.assertTrue(len(self.spectrum_data.overlays) == 2)
        self.spectrum_data.del_overlay(0)
        self.assertTrue(self.spectrum_data.overlays[0].name == 'QUADRUPOLED')

        self.spectrum_data.add_overlay_file('Data/spec_test2.txt')
        self.assertTrue(self.spectrum_data.overlays[-1].name == 'spec_test2')
コード例 #10
0
ファイル: IntegrationController.py プロジェクト: kif/Py2DeX
    def __init__(self,
                 working_dir,
                 view=None,
                 img_data=None,
                 mask_data=None,
                 calibration_data=None,
                 spectrum_data=None,
                 phase_data=None):
        self.working_dir = working_dir
        if view == None:
            self.view = IntegrationView()
        else:
            self.view = view

        if img_data == None:
            self.img_data = ImgData()
        else:
            self.img_data = img_data

        if mask_data == None:
            self.mask_data = MaskData()
        else:
            self.mask_data = mask_data

        if calibration_data == None:
            self.calibration_data = CalibrationData(self.img_data)
        else:
            self.calibration_data = calibration_data

        if spectrum_data == None:
            self.spectrum_data = SpectrumData()
        else:
            self.spectrum_data = spectrum_data

        if phase_data == None:
            self.phase_data = PhaseData()
        else:
            self.phase_data = phase_data

        self.create_sub_controller()

        self.view.setWindowState(self.view.windowState()
                                 & ~QtCore.Qt.WindowMinimized
                                 | QtCore.Qt.WindowActive)
        self.view.activateWindow()
        self.view.raise_()
コード例 #11
0
ファイル: MainController.py プロジェクト: kif/Py2DeX
    def __init__(self, app):
        self.splash_img = QtGui.QPixmap("UiFiles/splash.png")
        self.splash_screen = QtGui.QSplashScreen(self.splash_img, QtCore.Qt.WindowStaysOnTopHint)
        self.splash_screen.show()
        app.processEvents()
        time.sleep(1)
        app.processEvents()

        self.view = MainView()
        #create data
        self.img_data = ImgData()
        self.calibration_data = CalibrationData(self.img_data)
        self.mask_data = MaskData()
        self.spectrum_data = SpectrumData()
        self.phase_data = PhaseData()

        self.load_directories()
        #create controller
        self.calibration_controller = CalibrationController(self.working_dir,
                                                            self.view.calibration_widget,
                                                            self.img_data,
                                                            self.mask_data,
                                                            self.calibration_data)
        self.mask_controller = MaskController(self.working_dir,
                                              self.view.mask_widget,
                                              self.img_data,
                                              self.mask_data)
        self.integration_controller = IntegrationController(self.working_dir,
                                                            self.view.integration_widget,
                                                            self.img_data,
                                                            self.mask_data,
                                                            self.calibration_data,
                                                            self.spectrum_data,
                                                            self.phase_data)
        self.create_signals()
        self.set_title()
        self.raise_window()
        self.splash_screen.finish(self.view)
コード例 #12
0
ファイル: MainController.py プロジェクト: kif/Py2DeX
class MainController(object):
    def __init__(self, app):
        self.splash_img = QtGui.QPixmap("UiFiles/splash.png")
        self.splash_screen = QtGui.QSplashScreen(
            self.splash_img, QtCore.Qt.WindowStaysOnTopHint)
        self.splash_screen.show()
        app.processEvents()
        time.sleep(1)
        app.processEvents()

        self.view = MainView()
        #create data
        self.img_data = ImgData()
        self.calibration_data = CalibrationData(self.img_data)
        self.mask_data = MaskData()
        self.spectrum_data = SpectrumData()
        self.phase_data = PhaseData()

        self.load_directories()
        #create controller
        self.calibration_controller = CalibrationController(
            self.working_dir, self.view.calibration_widget, self.img_data,
            self.mask_data, self.calibration_data)
        self.mask_controller = MaskController(self.working_dir,
                                              self.view.mask_widget,
                                              self.img_data, self.mask_data)
        self.integration_controller = IntegrationController(
            self.working_dir, self.view.integration_widget, self.img_data,
            self.mask_data, self.calibration_data, self.spectrum_data,
            self.phase_data)
        self.create_signals()
        self.set_title()
        self.raise_window()
        self.splash_screen.finish(self.view)

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

    def create_signals(self):
        self.view.tabWidget.currentChanged.connect(self.tab_changed)
        self.view.closeEvent = self.close_event
        self.img_data.subscribe(self.set_title)
        self.spectrum_data.subscribe(self.set_title)

    def tab_changed(self, ind):
        if ind == 2:
            self.integration_controller.image_controller.plot_mask()
            self.integration_controller.view.calibration_lbl.setText(
                self.calibration_data.calibration_name)
            auto_scale_previous = self.integration_controller.image_controller._auto_scale
            self.integration_controller.image_controller._auto_scale = False
            self.integration_controller.spectrum_controller.image_changed()
            self.integration_controller.image_controller._auto_scale = auto_scale_previous
        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()
            except TypeError:
                pass

    def set_title(self):
        img_filename = os.path.basename(self.img_data.filename)
        spec_filename = os.path.basename(self.spectrum_data.spectrum_filename)
        calibration_name = self.calibration_data.calibration_name
        str = 'Dioptas v' + __VERSION__
        if img_filename is '' and spec_filename is '':
            self.view.setWindowTitle(str)
            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 += ']'
        self.view.setWindowTitle(str)

    def load_directories(self):
        if os.path.exists('working_directories.csv'):
            reader = csv.reader(open('working_directories.csv', 'rb'))
            self.working_dir = dict(x for x in reader)
        else:
            self.working_dir = {
                'calibration': '',
                'mask': '',
                'image': '',
                'spectrum': '',
                'overlay': '',
                'phase': ''
            }

    def save_directories(self):
        writer = csv.writer(open('working_directories.csv', 'wb'))
        for key, value in self.working_dir.items():
            writer.writerow([key, value])

    def close_event(self, _):
        self.save_directories()
コード例 #13
0
ファイル: MainController.py プロジェクト: kif/Py2DeX
class MainController(object):
    def __init__(self, app):
        self.splash_img = QtGui.QPixmap("UiFiles/splash.png")
        self.splash_screen = QtGui.QSplashScreen(self.splash_img, QtCore.Qt.WindowStaysOnTopHint)
        self.splash_screen.show()
        app.processEvents()
        time.sleep(1)
        app.processEvents()

        self.view = MainView()
        #create data
        self.img_data = ImgData()
        self.calibration_data = CalibrationData(self.img_data)
        self.mask_data = MaskData()
        self.spectrum_data = SpectrumData()
        self.phase_data = PhaseData()

        self.load_directories()
        #create controller
        self.calibration_controller = CalibrationController(self.working_dir,
                                                            self.view.calibration_widget,
                                                            self.img_data,
                                                            self.mask_data,
                                                            self.calibration_data)
        self.mask_controller = MaskController(self.working_dir,
                                              self.view.mask_widget,
                                              self.img_data,
                                              self.mask_data)
        self.integration_controller = IntegrationController(self.working_dir,
                                                            self.view.integration_widget,
                                                            self.img_data,
                                                            self.mask_data,
                                                            self.calibration_data,
                                                            self.spectrum_data,
                                                            self.phase_data)
        self.create_signals()
        self.set_title()
        self.raise_window()
        self.splash_screen.finish(self.view)

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

    def create_signals(self):
        self.view.tabWidget.currentChanged.connect(self.tab_changed)
        self.view.closeEvent = self.close_event
        self.img_data.subscribe(self.set_title)
        self.spectrum_data.subscribe(self.set_title)

    def tab_changed(self, ind):
        if ind == 2:
            self.integration_controller.image_controller.plot_mask()
            self.integration_controller.view.calibration_lbl.setText(self.calibration_data.calibration_name)
            auto_scale_previous = self.integration_controller.image_controller._auto_scale
            self.integration_controller.image_controller._auto_scale = False
            self.integration_controller.spectrum_controller.image_changed()
            self.integration_controller.image_controller._auto_scale = auto_scale_previous
        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()
            except TypeError:
                pass

    def set_title(self):
        img_filename = os.path.basename(self.img_data.filename)
        spec_filename = os.path.basename(self.spectrum_data.spectrum_filename)
        calibration_name = self.calibration_data.calibration_name
        str = 'Dioptas v' + __VERSION__
        if img_filename is '' and spec_filename is '':
            self.view.setWindowTitle(str)
            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 += ']'
        self.view.setWindowTitle(str)

    def load_directories(self):
        if os.path.exists('working_directories.csv'):
            reader = csv.reader(open('working_directories.csv', 'rb'))
            self.working_dir = dict(x for x in reader)
        else:
            self.working_dir = {'calibration': '', 'mask': '', 'image': '', 'spectrum': '', 'overlay': '',
                                'phase': ''}

    def save_directories(self):
        writer = csv.writer(open('working_directories.csv', 'wb'))
        for key, value in self.working_dir.items():
            writer.writerow([key, value])


    def close_event(self, _):
        self.save_directories()
コード例 #14
0
ファイル: SpectrumDataTest.py プロジェクト: kif/Py2DeX
 def setUp(self):
     self.spectrum = Spectrum()
     self.spectrum_data = SpectrumData()
コード例 #15
0
ファイル: SpectrumDataTest.py プロジェクト: kif/Py2DeX
 def setUp(self):
     self.spectrum = Spectrum()
     self.spectrum_data = SpectrumData()
コード例 #16
0
ファイル: test_SpectrumData.py プロジェクト: ggarba/Dioptas
class SpectrumDataTest(unittest.TestCase):
    def setUp(self):
        self.x = np.linspace(0.1, 15, 100)
        self.y = np.sin(self.x)
        self.spectrum = Spectrum(self.x, self.y)
        self.spectrum_data = SpectrumData()

    def test_spectrum_class(self):
        self.spectrum.save('Data/spec_test.txt')
        self.spectrum.save('Data/spec_test2.txt',
                           header='This is not only ridiculous\n but more and more '
                                  'challenging...')
        self.spectrum.load('Data/spec_test.txt', 0)
        self.spectrum.load('Data/spec_test2.txt', 0)

        self.assertTrue(np.array_equal(self.spectrum.data[0], np.linspace(0.1, 15, 100)))
        self.assertTrue(self.spectrum.load('Data/test_001.tif') == -1)

        self.spectrum.data = (np.linspace(0, 30), np.linspace(0, 20))
        self.spectrum.offset = 100
        self.assertTrue(np.array_equal(self.spectrum.data[1], np.linspace(0, 20) + 100))
        self.assertTrue(np.array_equal(self.spectrum.data[0], np.linspace(0, 30)))

        self.spectrum.scaling = 10
        self.assertTrue(np.array_equal(self.spectrum.data[1], np.linspace(0, 20) * 10 + 100))

        self.spectrum.data = (np.linspace(0, 20), np.linspace(0, 30))
        self.assertTrue(np.array_equal(self.spectrum.data[1], np.linspace(0, 30)))

        self.spectrum.scaling = -100
        self.assertTrue(np.array_equal(self.spectrum.data[1], np.zeros(self.spectrum.data[0].shape)))

    def test_spectrum_data_class(self):
        self.spectrum_data.set_spectrum(np.linspace(0, 10), np.linspace(0, 10) ** 2, 'SQUARED')
        self.spectrum_data.add_overlay(np.linspace(0, 10), np.linspace(0, 10) ** 3, 'CUBED')
        self.spectrum_data.add_overlay(np.linspace(0, 10), np.linspace(0, 10) ** 4, 'QUADRUPOLED')

        self.assertTrue(len(self.spectrum_data.overlays) == 2)
        self.spectrum_data.del_overlay(0)
        self.assertTrue(self.spectrum_data.overlays[0].name == 'QUADRUPOLED')

        self.spectrum_data.add_overlay_file('Data/spec_test2.txt')
        self.assertTrue(self.spectrum_data.overlays[-1].name == 'spec_test2')

    def test_background(self):
        x_spectrum = np.linspace(0,100,1001)
        y_spectrum = np.sin(x_spectrum)
        x_background = np.linspace(0,91, 1002)
        y_background = np.cos(x_background)

        spec = Spectrum(x_spectrum, y_spectrum)
        spec.set_background(Spectrum(x_background, y_background))

        x, y = spec.data

        self.assertTrue(x[-1]<1000)
        self.assertEqual(len(x), 911)

        test_x = np.linspace(0,91, 911)
        test_y = np.sin(test_x) - np.cos(test_x)

        diff = abs(np.sum(test_y-y))
        self.assertLess(diff, 1e-3)

    def test_background_not_in_spectrum_range(self):
        x_spectrum = np.linspace(0,30,101)
        y_spectrum = np.sin(x_spectrum)
        x_background = np.linspace(50,60, 102)
        y_background = np.cos(x_background)

        spec = Spectrum(x_spectrum, y_spectrum)
        spec.set_background(Spectrum(x_background, y_background))

        self.assertRaises(BkgNotInRangeError)
コード例 #17
0
ファイル: MainController.py プロジェクト: ggarba/Dioptas
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):
        self.view = MainView()
        #create data
        self.img_data = ImgData()
        self.calibration_data = CalibrationData(self.img_data)
        self.mask_data = MaskData()
        self.spectrum_data = SpectrumData()
        self.phase_data = PhaseData()

        self.settings_directory = os.path.join(os.path.expanduser("~"), '.Dioptas')
        self.working_directories = {'calibration': '', 'mask': '', 'image': '', 'spectrum': '', 'overlay': '',
                                'phase': ''}
        self.load_settings()
        #create controller
        self.calibration_controller = CalibrationController(self.working_directories,
                                                            self.view.calibration_widget,
                                                            self.img_data,
                                                            self.mask_data,
                                                            self.calibration_data)
        self.mask_controller = MaskController(self.working_directories,
                                              self.view.mask_widget,
                                              self.img_data,
                                              self.mask_data)
        self.integration_controller = IntegrationController(self.working_directories,
                                                            self.view.integration_widget,
                                                            self.img_data,
                                                            self.mask_data,
                                                            self.calibration_data,
                                                            self.spectrum_data,
                                                            self.phase_data)
        self.create_signals()
        self.set_title()
        self.raise_window(self.view)

    @staticmethod
    def raise_window(widget):
        widget.show()
        widget.setWindowState(widget.windowState() & ~QtCore.Qt.WindowMinimized | QtCore.Qt.WindowActive)
        widget.activateWindow()
        widget.raise_()

    def create_signals(self):
        self.view.tabWidget.currentChanged.connect(self.tab_changed)
        self.view.closeEvent = self.close_event
        self.img_data.subscribe(self.set_title)
        self.spectrum_data.subscribe(self.set_title)

    def tab_changed(self, ind):
        if ind == 2:
            self.mask_data.set_supersampling()
            self.integration_controller.image_controller.plot_mask()
            self.integration_controller.view.calibration_lbl.setText(self.calibration_data.calibration_name)
            auto_scale_previous = self.integration_controller.image_controller._auto_scale
            self.integration_controller.image_controller._auto_scale = False
            self.integration_controller.spectrum_controller.image_changed()
            self.integration_controller.image_controller.update_img()
            self.integration_controller.image_controller._auto_scale = auto_scale_previous
        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_data.filename)
        spec_filename = os.path.basename(self.spectrum_data.spectrum_filename)
        calibration_name = self.calibration_data.calibration_name
        str = 'Dioptas ' + __VERSION__
        if img_filename is '' and spec_filename is '':
            self.view.setWindowTitle(str + u' - © 2014 C. Prescher')
            self.view.integration_widget.img_frame.setWindowTitle(str + u' - © 2014 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' - © 2014 C. Prescher'
        self.view.setWindowTitle(str)
        self.view.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_data.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_data.filename
        tree = ET.ElementTree(root)
        tree.write(os.path.join(self.settings_directory, "settings.xml"))

    def close_event(self, _):
        self.save_settings()
        QtGui.QApplication.closeAllWindows()
        QtGui.QApplication.quit()
コード例 #18
0
ファイル: test_SpectrumData.py プロジェクト: ggarba/Dioptas
 def setUp(self):
     self.x = np.linspace(0.1, 15, 100)
     self.y = np.sin(self.x)
     self.spectrum = Spectrum(self.x, self.y)
     self.spectrum_data = SpectrumData()