Example #1
0
    def __init__(self, fits_file, settings, database, project=None):
        super(CalibrateSpectrum, self).__init__()
        self.project = project
        self.settings = settings
        self.fits_spectrum = FitsSpectrum(fits_file)
        self.fits_spectrum.spectrum.normalize_to_max()
        self.fits_file = fits_file
        self.ui = Ui_CalibrateSpectrum()
        self.ui.setupUi(self)
        self.toolbar = QToolBar('Calibration Toolbar')
        self.toolbar.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
        self.ui.x_axis_pick.setMenu(QMenu())
        self.ui.x_axis_pick.menu().addAction(
            "Maximum from range").triggered.connect(
                lambda: self.pick_from_range('maximum'))
        self.ui.x_axis_pick.menu().addAction(
            "Minimum from range").triggered.connect(
                lambda: self.pick_from_range('minimum'))
        self.ui.x_axis_pick.menu().addAction(
            "Central value from range").triggered.connect(
                lambda: self.pick_from_range('central'))
        self.ui.wavelength_pick.clicked.connect(
            lambda: self.lines_dialog.show())

        save_action = self.toolbar.addAction(QIcon(':/save_20'), 'Save',
                                             self.save_spectrum)
        self.spectrum_plot = QtCommons.nestWidget(self.ui.spectrum_plot_widget,
                                                  QMathPlotWidget())

        self.reference_spectra_dialog = ReferenceSpectraDialog(database)
        self.reference_spectra_dialog.setup_menu(self.toolbar,
                                                 self.spectrum_plot.axes,
                                                 settings)

        self.object_properties = ObjectProperties(self.fits_file,
                                                  project=project)
        self.object_properties_dialog = ObjectPropertiesDialog(
            settings, self.object_properties)
        self.toolbar.addAction("Object properties",
                               self.object_properties_dialog.show)

        self.calibration_model = QStandardItemModel()
        self.calibration_model.setHorizontalHeaderLabels(
            ["x-axis", "wavelength", "error"])
        self.ui.calibration_points.setModel(self.calibration_model)
        self.ui.calibration_points.selectionModel().selectionChanged.connect(
            lambda selected, deselected: self.ui.remove_calibration_point.
            setEnabled(len(selected.indexes()) > 0))
        self.ui.add_calibration_point.clicked.connect(
            self.add_calibration_point)
        self.ui.remove_calibration_point.setEnabled(False)
        self.ui.remove_calibration_point.clicked.connect(
            self.remove_calibration_point)
        if project and project.avg_dispersion():
            self.ui.set_dispersion.setMenu(QMenu())
            self.ui.set_dispersion.menu().addAction('From input value',
                                                    self.calculate_calibration)
            self.ui.set_dispersion.menu().addAction(
                'From Project',
                lambda: self.calculate_calibration(project.avg_dispersion()))
        else:
            self.ui.set_dispersion.clicked.connect(self.calculate_calibration)
        self.ui.point_is_star.toggled.connect(
            lambda checked: self.ui.wavelength_pick.setEnabled(not checked))
        self.ui.point_is_star.toggled.connect(
            lambda checked: self.ui.point_wavelength.setEnabled(not checked))
        self.fits_spectrum.plot_to(self.spectrum_plot.axes)

        self.toolbar.addSeparator()
        self.toolbar.addAction("Zoom", self.spectrum_plot.select_zoom)
        self.toolbar.addAction(
            "Reset Zoom", lambda: self.spectrum_plot.reset_zoom(
                self.fits_spectrum.spectrum.wavelengths,
                self.fits_spectrum.spectrum.fluxes.min(),
                self.fits_spectrum.spectrum.fluxes.max()))
        self.toolbar.addSeparator()

        self.lines_dialog = LinesDialog(database,
                                        settings,
                                        self.spectrum_plot,
                                        enable_picker=False,
                                        selection_mode='single')
        self.lines_dialog.lines.connect(self.picked_line)

        hdu_calibration_points = [
            h for h in self.fits_file
            if h.name == FitsSpectrum.CALIBRATION_DATA
        ]
        if len(hdu_calibration_points) > 0:
            for point in hdu_calibration_points[-1].data:
                self.add_calibration_point_data(point[0], point[1])
        self.calculate_calibration()
Example #2
0
    def __init__(self, fits_file, settings, database, project=None):
        super(FinishSpectrum, self).__init__()
        self.settings = settings
        self.ui = Ui_FinishSpectrum()
        self.ui.setupUi(self)
        self.profile_line = None
        self.project = project
        self.fits_spectrum = FitsSpectrum(fits_file)
        self.undo = Undo(self.fits_spectrum.spectrum, self.draw)
        try:
            fits_file.index_of('ORIGINAL_DATA')
        except KeyError:
            hdu = fits.ImageHDU(data=fits_file[0].data,
                                header=fits_file[0].header,
                                name='ORIGINAL_DATA')
            fits_file.append(hdu)

        self.fits_spectrum.spectrum.normalize_to_max()
        self.spectrum = self.fits_spectrum.spectrum
        self.spectrum_plot = QtCommons.nestWidget(self.ui.plot,
                                                  QMathPlotWidget())
        self.spectrum_plot.mouse_moved.connect(
            Instances.MainWindow.print_coordinates)

        self.split_view()
        self.toolbar = QToolBar('Finish Spectrum Toolbar')
        if project:
            instrument_response_action = QtCommons.addToolbarPopup(
                self.toolbar, "Instrument Response")
            instrument_response_action.menu().addAction(
                'From FITS file...', lambda: open_file_sticky(
                    'Open Instrument Response Profile', FITS_EXTS, lambda f:
                    self.instrument_response(f[
                        0]), settings, MATH_OPERATION, [RAW_PROFILE]))
            for instrument_response in project.get_instrument_responses():
                print("Adding instrument response {}".format(
                    instrument_response))
                instrument_response_action.menu().addAction(
                    os.path.basename(instrument_response[1]),
                    lambda: self.instrument_response(instrument_response[1]))
        else:
            self.toolbar.addAction(
                'Instrument Response', lambda: open_file_sticky(
                    'Open Instrument Response Profile', FITS_EXTS, lambda f:
                    self.instrument_response(f[
                        0]), settings, MATH_OPERATION, [RAW_PROFILE]))
        self.toolbar.addAction(
            "Zoom",
            lambda: self.spectrum_plot.select_zoom(self.profile_plot.axes))
        self.toolbar.addAction(
            "Reset Zoom", lambda: self.spectrum_plot.reset_zoom(
                self.spectrum.wavelengths, self.spectrum.fluxes.min(),
                self.spectrum.fluxes.max(), self.profile_plot.axes))
        remove_action = QtCommons.addToolbarPopup(self.toolbar, "Remove")
        remove_action.menu().addAction(
            "Before point",
            lambda: spectrum_trim_dialog(self.spectrum,
                                         'before',
                                         self.profile_plot.axes,
                                         lambda: self.draw(),
                                         self,
                                         before_removal=self.undo.save_undo))
        remove_action.menu().addAction(
            "After point",
            lambda: spectrum_trim_dialog(self.spectrum,
                                         'after',
                                         self.profile_plot.axes,
                                         lambda: self.draw(),
                                         self,
                                         before_removal=self.undo.save_undo))
        self.undo.add_actions(self.toolbar)
        self.toolbar.addSeparator()

        self.reference_spectra_dialog = ReferenceSpectraDialog(
            database, self.fits_spectrum.spectrum)
        self.reference_spectra_dialog.setup_menu(self.toolbar,
                                                 self.profile_plot.axes,
                                                 settings)

        lines_menu = QtCommons.addToolbarPopup(self.toolbar,
                                               "Spectral Lines..")
        lines_menu.menu().addAction('Lines Database',
                                    lambda: self.lines_dialog.show())
        lines_menu.menu().addAction('Custom line', self.add_custom_line)
        labels_action = QtCommons.addToolbarPopup(self.toolbar, "Labels..")
        self.object_properties = ObjectProperties(fits_file, project=project)
        labels_action.menu().addAction('Title', self.add_title)
        if self.object_properties:
            labels_action.menu().addAction('Information from FITS file',
                                           self.add_fits_information_label)
        labels_action.menu().addAction('Custom', self.add_label)

        self.object_properties_dialog = ObjectPropertiesDialog(
            settings, self.object_properties)
        self.toolbar.addAction("Object properties",
                               self.object_properties_dialog.show)

        self.labels, self.lines = [], []
        for label in self.fits_spectrum.labels():
            self.add_label(text=label['text'],
                           coords=label['coords'],
                           type=label['type'],
                           fontsize=label['fontsize'])

        self.toolbar.addSeparator()
        if project:
            self.toolbar.addAction(
                QIcon(':/image_20'), "Export Image...",
                lambda: QtCommons.save_file(
                    'Export plot to image',
                    'PNG (*.png);;PDF (*.pdf);;PostScript (*.ps);;SVG (*.svg)',
                    lambda f: self.save_image(f[0]),
                    project.directory_path(Project.EXPORTED_IMAGES)))
            self.toolbar.addAction(QIcon(':/save_20'), 'Save',
                                   self.save_finished_in_project)
        else:
            self.toolbar.addAction(
                QIcon(':/image_20'), "Export Image...",
                lambda: save_file_sticky(
                    'Export plot to image',
                    'PNG (*.png);;PDF (*.pdf);;PostScript (*.ps);;SVG (*.svg)',
                    lambda f: self.save_image(f[0]), self.settings,
                    EXPORT_IMAGES, [CALIBRATED_PROFILE]))
            self.toolbar.addAction(
                QIcon(':/save_20'), 'Save', lambda: save_file_sticky(
                    'Save plot...', 'FITS file (.fit)', lambda f: self.__save(
                        f[0]), self.settings, CALIBRATED_PROFILE))

        self.lines_dialog = LinesDialog(database, settings, self.spectrum_plot,
                                        self.profile_plot.axes)
        self.lines_dialog.lines.connect(self.add_lines)
        for line in self.fits_spectrum.lines_labels():
            self.lines.append(
                ReferenceLine(line['text'],
                              line['wavelength'],
                              self.profile_plot.axes,
                              lambda line: self.lines.remove(line),
                              show_wavelength=line['display_wavelength'],
                              fontsize=line['fontsize'],
                              position=line['position']))