SpecProc 1.0.0__py3-none-any.whl

specproc/gui/settings_dialog.py

@@ -0,0 +1,946 @@
+
+"""
+Settings dialog for SpecProc configuration.
+
+Provides a GUI for editing configuration parameters organized by tabs.
+"""
+# 提供按类别编辑处理配置的设置界面。
+
+from PyQt5.QtWidgets import (
+    QDialog, QVBoxLayout, QHBoxLayout, QLabel, QLineEdit,
+    QSpinBox, QDoubleSpinBox, QComboBox, QCheckBox,
+    QPushButton, QTabWidget, QWidget, QGroupBox, QFormLayout, QScrollArea,
+    QFileDialog
+)
+from PyQt5.QtCore import Qt
+
+from specproc.config.config_manager import ConfigManager
+
+
+# 提供处理配置的分项编辑界面。
+class SettingsDialog(QDialog):
+    """Settings dialog for configuration editing."""
+
+    # 初始化设置对话框。
+    def __init__(self, config: ConfigManager, parent=None, initial_tab: int = 0):
+        """
+        Initialize settings dialog.
+
+        Args:
+            config: Configuration manager instance
+            parent: Parent widget
+            initial_tab: Initial tab index to show (0: Data & Instruments, 1: Data Reduction, etc.)
+        """
+        super().__init__(parent)
+        self.config = config
+        self.setWindowTitle("SpecProc Settings")
+        self.setModal(True)
+        self.resize(800, 600)
+        
+        self.initial_tab = initial_tab
+        self.tab_widget = None
+
+        self.init_ui()
+        self.load_current_values()
+        
+        # Set initial tab
+        if self.tab_widget:
+            self.tab_widget.setCurrentIndex(initial_tab)
+
+    # 构建设置界面及选项卡。
+    def init_ui(self):
+        """Initialize user interface."""
+        layout = QVBoxLayout()
+
+        # Tab widget with different configuration categories
+        self.tab_widget = QTabWidget()
+
+        # Create tabs following data reduction pipeline order
+        self.tab_widget.addTab(self._create_data_tab(), "Data & Instruments")
+        self.tab_widget.addTab(self._create_reduction_tab(), "Data Reduction")
+        self.tab_widget.addTab(self._create_extraction_tab(), "Apertures Tracing")
+        self.tab_widget.addTab(self._create_wlcalib_tab(), "Wavelength Calibration")
+        self.tab_widget.addTab(self._create_processing_tab(), "Processing & Output")
+
+        layout.addWidget(self.tab_widget)
+
+        # Buttons
+        button_layout = QHBoxLayout()
+        save_btn = QPushButton("Save")
+        save_btn.clicked.connect(self._save_settings)
+        cancel_btn = QPushButton("Cancel")
+        cancel_btn.clicked.connect(self.reject)
+        button_layout.addStretch()
+        button_layout.addWidget(save_btn)
+        button_layout.addWidget(cancel_btn)
+        layout.addLayout(button_layout)
+
+        self.setLayout(layout)
+
+    # 创建数据输入与探测器设置页。
+    def _create_data_tab(self) -> QWidget:
+        """Create data input and detector settings tab."""
+        scroll = QScrollArea()
+        scroll.setWidgetResizable(True)
+        widget = QWidget()
+        layout = QFormLayout()
+
+        # Data input group
+        data_group = QGroupBox("Data Input")
+        data_layout = QFormLayout()
+
+        self.rawdata_path_edit = QLineEdit()
+        data_layout.addRow("Raw Data Path:", self.rawdata_path_edit)
+
+        self.statime_key_edit = QLineEdit()
+        data_layout.addRow("Start Time Key (DATE-OBS):", self.statime_key_edit)
+
+        self.exptime_key_edit = QLineEdit()
+        data_layout.addRow("Exposure Time Key (EXPTIME):", self.exptime_key_edit)
+
+        self.direction_combo = QComboBox()
+        self.direction_combo.addItems(['xrb', 'xlb', 'yrb', 'ylb'])
+        data_layout.addRow("Dispersion Direction:", self.direction_combo)
+
+        self.output_path_edit = QLineEdit()
+        data_layout.addRow("Output Path:", self.output_path_edit)
+
+        data_group.setLayout(data_layout)
+        layout.addRow(data_group)
+
+        # Detector parameters
+        detector_group = QGroupBox("Detector Parameters")
+        detector_layout = QFormLayout()
+
+        self.detector_gain_spin = QDoubleSpinBox()
+        self.detector_gain_spin.setRange(0.1, 100.0)
+        self.detector_gain_spin.setSingleStep(0.1)
+        detector_layout.addRow("CCD Gain:", self.detector_gain_spin)
+
+        self.detector_readnoise_spin = QDoubleSpinBox()
+        self.detector_readnoise_spin.setRange(0.0, 100.0)
+        self.detector_readnoise_spin.setSingleStep(0.5)
+        detector_layout.addRow("Read Noise:", self.detector_readnoise_spin)
+
+        detector_group.setLayout(detector_layout)
+        layout.addRow(detector_group)
+
+        widget.setLayout(layout)
+        widget.setMinimumWidth(400)
+        scroll.setWidget(widget)
+        return scroll
+
+    # 创建数据预处理设置页。
+    def _create_reduction_tab(self) -> QWidget:
+        """Create bias, flat, background and cosmic ray correction settings tab."""
+        scroll = QScrollArea()
+        scroll.setWidgetResizable(True)
+        widget = QWidget()
+        layout = QFormLayout()
+
+        # Overscan configuration
+        overscan_group = QGroupBox("Overscan Correction")
+        overscan_layout = QFormLayout()
+
+        self.overscan_start_column_spin = QSpinBox()
+        self.overscan_start_column_spin.setRange(-1, 10000)
+        self.overscan_start_column_spin.setSpecialValueText("None")
+        overscan_layout.addRow("Overscan Start Column (1-based):", self.overscan_start_column_spin)
+
+        self.overscan_method_combo = QComboBox()
+        self.overscan_method_combo.addItems(['mean_only', 'mean_savgol', 'mean_polynomial'])
+        self.overscan_method_combo.setToolTip(
+            "mean_only: Sigma-clipped mean only, no smoothing\n"
+            "mean_savgol: Sigma-clipped mean with Savitzky-Golay smoothing\n"
+            "mean_polynomial: Sigma-clipped mean with polynomial fitting (IRAF style)"
+        )
+        overscan_layout.addRow("Overscan Method:", self.overscan_method_combo)
+
+        self.overscan_smooth_window_spin = QSpinBox()
+        self.overscan_smooth_window_spin.setRange(-1, 10000)
+        self.overscan_smooth_window_spin.setSpecialValueText("Auto (1/5 height)")
+        self.overscan_smooth_window_spin.setToolTip("Savitzky-Golay smoothing window size. -1 for auto (1/5 of image height)")
+        overscan_layout.addRow("Smooth Window:", self.overscan_smooth_window_spin)
+
+        self.overscan_poly_type_combo = QComboBox()
+        self.overscan_poly_type_combo.addItems(['legendre', 'chebyshev', 'polynomial'])
+        self.overscan_poly_type_combo.setToolTip(
+            "Polynomial type for mean_polynomial method:\n"
+            "legendre: Legendre polynomial (IRAF default)\n"
+            "chebyshev: Chebyshev polynomial\n"
+            "polynomial: Standard power series"
+        )
+        overscan_layout.addRow("Poly Type:", self.overscan_poly_type_combo)
+
+        self.overscan_poly_order_spin = QSpinBox()
+        self.overscan_poly_order_spin.setRange(1, 10)
+        self.overscan_poly_order_spin.setValue(3)
+        self.overscan_poly_order_spin.setToolTip("Polynomial order (degree) for mean_polynomial method")
+        overscan_layout.addRow("Poly Order:", self.overscan_poly_order_spin)
+
+        self.detector_split_row_spin = QSpinBox()
+        self.detector_split_row_spin.setRange(-1, 20000)
+        self.detector_split_row_spin.setSpecialValueText("Auto (rows/2)")
+        self.detector_split_row_spin.setToolTip(
+            "Detector amplifier split row (1-based).\n"
+            "Divides the CCD into lower and upper readout halves.\n"
+            "Used by overscan correction and step 3 background fitting.\n"
+            "For Xinglong 216 HRS 4136-row CCD: 2068. Set -1 for auto."
+        )
+        overscan_layout.addRow("Amplifier Split Row:", self.detector_split_row_spin)
+
+        overscan_group.setLayout(overscan_layout)
+        layout.addRow(overscan_group)
+
+        # Connect overscan method change to update parameter states
+        self.overscan_method_combo.currentTextChanged.connect(self._update_overscan_params_enabled)
+
+        # Bias correction
+        bias_group = QGroupBox("Bias Correction")
+        bias_layout = QFormLayout()
+
+        self.bias_combine_method_combo = QComboBox()
+        self.bias_combine_method_combo.addItems(['mean', 'median', 'sigma_clip'])
+        bias_layout.addRow("Combine Method:", self.bias_combine_method_combo)
+
+        self.bias_combine_sigma_spin = QDoubleSpinBox()
+        self.bias_combine_sigma_spin.setRange(1.0, 10.0)
+        self.bias_combine_sigma_spin.setSingleStep(0.1)
+        bias_layout.addRow("Sigma Clipping Threshold:", self.bias_combine_sigma_spin)
+
+        bias_group.setLayout(bias_layout)
+        layout.addRow(bias_group)
+
+        # Cosmic ray correction (Step 1)
+        cosmic_group = QGroupBox("Cosmic Ray Correction (L.A.Cosmic)")
+        cosmic_layout = QFormLayout()
+
+        self.cosmic_enabled_check = QCheckBox("Enable cosmic ray correction")
+        cosmic_layout.addRow(self.cosmic_enabled_check)
+
+        self.cosmic_sigclip_spin = QDoubleSpinBox()
+        self.cosmic_sigclip_spin.setRange(1.0, 20.0)
+        self.cosmic_sigclip_spin.setSingleStep(0.1)
+        self.cosmic_sigclip_spin.setToolTip("Detection threshold (sigma). Higher values are more conservative.")
+        cosmic_layout.addRow("Sigma Clip:", self.cosmic_sigclip_spin)
+
+        self.cosmic_objlim_spin = QDoubleSpinBox()
+        self.cosmic_objlim_spin.setRange(1.0, 20.0)
+        self.cosmic_objlim_spin.setSingleStep(0.1)
+        self.cosmic_objlim_spin.setToolTip("Contrast limit between cosmic ray and underlying object.")
+        cosmic_layout.addRow("Object Limit:", self.cosmic_objlim_spin)
+
+        self.cosmic_gain_spin = QDoubleSpinBox()
+        self.cosmic_gain_spin.setRange(0.0, 10.0)
+        self.cosmic_gain_spin.setSingleStep(0.1)
+        self.cosmic_gain_spin.setToolTip("Detector gain. Set to 0.0 to auto-detect from config.")
+        cosmic_layout.addRow("Gain:", self.cosmic_gain_spin)
+
+        cosmic_group.setLayout(cosmic_layout)
+        layout.addRow(cosmic_group)
+
+        # Background subtraction (Step 3)
+        bg_group = QGroupBox("Background Subtraction")
+        bg_layout = QFormLayout()
+
+        self.bg_method_combo = QComboBox()
+        self.bg_method_combo.addItems(['convolution', 'column_spline', 'bspline'])
+        self.bg_method_combo.setToolTip(
+            "'convolution': astropy NaN-aware 2D Gaussian convolution (recommended,\n"
+            "  reproduces local ripples/fringes);\n"
+            "'column_spline': per-column 1D smoothing spline (follows ripple peaks/troughs,\n"
+            "  through inter-aperture pixels then lightly smooths horizontally);\n"
+            "'bspline': bivariate spline fit.")
+        bg_layout.addRow("Background Method:", self.bg_method_combo)
+        self.bg_method_combo.currentTextChanged.connect(self._update_bg_params_enabled)
+
+        self.bg_kernel_sigma_x_spin = QDoubleSpinBox()
+        self.bg_kernel_sigma_x_spin.setRange(5.0, 100.0)
+        self.bg_kernel_sigma_x_spin.setSingleStep(1.0)
+        self.bg_kernel_sigma_x_spin.setValue(13.0)
+        self.bg_kernel_sigma_x_spin.setToolTip(
+            "Gaussian kernel σ_x (色散方向, 水平, X) for convolution method.\n"
+            "建议 10–20 px。\n"
+            "σ_x 应极细以还原干涉波峰（如 60-110 px），较小的值（13）能完美刻画横向条纹。")
+        bg_layout.addRow("Kernel σ_x (px):", self.bg_kernel_sigma_x_spin)
+
+        self.bg_kernel_sigma_y_spin = QDoubleSpinBox()
+        self.bg_kernel_sigma_y_spin.setRange(5.0, 80.0)
+        self.bg_kernel_sigma_y_spin.setSingleStep(1.0)
+        self.bg_kernel_sigma_y_spin.setValue(13.0)
+        self.bg_kernel_sigma_y_spin.setToolTip(
+            "Gaussian kernel σ_y (交叉色散方向, 垂直, Y) for convolution method.\n"
+            "建议 12–20 px。\n"
+            "σ_y (13) 刚好能跨越 mask 宽度（10-12 px），同时保留纵向高频变化。")
+        bg_layout.addRow("Kernel σ_y (px):", self.bg_kernel_sigma_y_spin)
+
+        self.bg_spline_smooth_factor_spin = QDoubleSpinBox()
+        self.bg_spline_smooth_factor_spin.setRange(0.01, 10.0)
+        self.bg_spline_smooth_factor_spin.setSingleStep(0.05)
+        self.bg_spline_smooth_factor_spin.setDecimals(3)
+        self.bg_spline_smooth_factor_spin.setToolTip(
+            "Smoothing factor multiplier for column_spline method.\n"
+            "s = factor × N_bg_pixels.  Smaller values let the spline follow\n"
+            "ripple peaks/troughs more closely.  Typical 0.1–1.0.")
+        bg_layout.addRow("Spline Smooth Factor:", self.bg_spline_smooth_factor_spin)
+
+        self.bg_spline_post_smooth_x_spin = QDoubleSpinBox()
+        self.bg_spline_post_smooth_x_spin.setRange(0.0, 50.0)
+        self.bg_spline_post_smooth_x_spin.setSingleStep(1.0)
+        self.bg_spline_post_smooth_x_spin.setToolTip(
+            "Gaussian σ (pixels) for light horizontal smoothing after column-wise\n"
+            "spline assembly.  Removes column-to-column discontinuities.\n"
+            "Set to 0 to disable.  Typical 3–10 px.")
+        bg_layout.addRow("Spline Post-smooth σ_x:", self.bg_spline_post_smooth_x_spin)
+
+        self.bg_poly_order_spin = QSpinBox()
+        self.bg_poly_order_spin.setRange(1, 10)
+        bg_layout.addRow("Fit Order:", self.bg_poly_order_spin)
+
+        self.bg_sigma_clip_spin = QDoubleSpinBox()
+        self.bg_sigma_clip_spin.setRange(0.0, 10.0)
+        self.bg_sigma_clip_spin.setSingleStep(0.1)
+        bg_layout.addRow("Sigma Clip:", self.bg_sigma_clip_spin)
+
+        self.bg_sigma_clip_iter_spin = QSpinBox()
+        self.bg_sigma_clip_iter_spin.setRange(1, 20)
+        bg_layout.addRow("Clip Iterations:", self.bg_sigma_clip_iter_spin)
+
+        self.bg_clip_mode_combo = QComboBox()
+        self.bg_clip_mode_combo.addItems(['upper', 'both', 'lower'])
+        self.bg_clip_mode_combo.setToolTip(
+            "'upper': reject only bright outliers (recommended for flats with "
+            "unmasked faint apertures);\n"
+            "'both': symmetric rejection;\n"
+            "'lower': reject only faint outliers.")
+        bg_layout.addRow("Clip Mode:", self.bg_clip_mode_combo)
+
+        self.bg_mask_margin_spin = QSpinBox()
+        self.bg_mask_margin_spin.setRange(0, 20)
+        bg_layout.addRow("Mask Margin (px):", self.bg_mask_margin_spin)
+
+        self.bg_bspline_smooth_spin = QDoubleSpinBox()
+        self.bg_bspline_smooth_spin.setRange(0.0, 100.0)
+        self.bg_bspline_smooth_spin.setSingleStep(0.1)
+        bg_layout.addRow("B-spline Smooth:", self.bg_bspline_smooth_spin)
+
+        bg_group.setLayout(bg_layout)
+        layout.addRow(bg_group)
+
+        # Flat fielding (Step 4)
+        flat_group = QGroupBox("Flat Fielding")
+        flat_layout = QFormLayout()
+
+        self.flat_combine_method_combo = QComboBox()
+        self.flat_combine_method_combo.addItems(['mean', 'median'])
+        flat_layout.addRow("Combine Method:", self.flat_combine_method_combo)
+
+        self.flat_q_threshold_spin = QDoubleSpinBox()
+        self.flat_q_threshold_spin.setRange(0.0, 1.0)
+        self.flat_q_threshold_spin.setSingleStep(0.05)
+        flat_layout.addRow("Quality Threshold:", self.flat_q_threshold_spin)
+
+        self.flat_mosaic_maxcount_spin = QDoubleSpinBox()
+        self.flat_mosaic_maxcount_spin.setRange(0.0, 100000.0)
+        flat_layout.addRow("Mosaic Max Count:", self.flat_mosaic_maxcount_spin)
+
+        self.flat_blaze_smooth_factor_spin = QDoubleSpinBox()
+        self.flat_blaze_smooth_factor_spin.setRange(0.1, 100.0)
+        self.flat_blaze_smooth_factor_spin.setSingleStep(0.1)
+        self.flat_blaze_smooth_factor_spin.setToolTip(
+            "Smoothing factor for automated B-spline blaze fitting in blue/dark apertures.\n"
+            "s = factor * N * variance. Typical values: 1.0 (soft) to 20.0 (rigid).\n"
+            "Larger = more rigid curve, Smaller = softer fit.")
+        flat_layout.addRow("Blaze Smooth Factor:", self.flat_blaze_smooth_factor_spin)
+
+        self.flat_fringe_orders_spin = QSpinBox()
+        self.flat_fringe_orders_spin.setRange(0, 150)
+        self.flat_fringe_orders_spin.setToolTip(
+            "Number of red-end apertures to apply Upper Envelope Chebyshev fitting for fringe removal.\n"
+            "Default is 20. Set to 0 to disable and use standard B-spline for all apertures.")
+        flat_layout.addRow("Fringe Apertures (Red end):", self.flat_fringe_orders_spin)
+
+        self.flat_width_smooth_window_spin = QSpinBox()
+        self.flat_width_smooth_window_spin.setRange(5, 401)
+        self.flat_width_smooth_window_spin.setSingleStep(2)
+        flat_layout.addRow("Width Smooth Window:", self.flat_width_smooth_window_spin)
+
+        self.flat_n_profile_segments_spin = QSpinBox()
+        self.flat_n_profile_segments_spin.setRange(1, 200)
+        self.flat_n_profile_segments_spin.setSingleStep(10)
+        self.flat_n_profile_segments_spin.setToolTip(
+            "Number of segments along X (dispersion) for the\n"
+            "cross-dispersion profile. Each segment builds a median\n"
+            "binned profile, then all segments are Gaussian-smoothed\n"
+            "along X to produce a continuously varying P(y_norm; x).\n"
+            "50-100 recommended for 4k detectors.")
+        flat_layout.addRow("Profile Segments:", self.flat_n_profile_segments_spin)
+
+        self.flat_profile_smooth_sigma_spin = QDoubleSpinBox()
+        self.flat_profile_smooth_sigma_spin.setRange(0.0, 50.0)
+        self.flat_profile_smooth_sigma_spin.setSingleStep(1.0)
+        self.flat_profile_smooth_sigma_spin.setToolTip(
+            "Gaussian sigma (in segment units) for smoothing the\n"
+            "cross-dispersion profiles along the dispersion direction.\n"
+            "0 = no smoothing. 4-8 typical for 100 segments.")
+        flat_layout.addRow("Profile Smooth Sigma:", self.flat_profile_smooth_sigma_spin)
+
+        self.flat_profile_bin_step_spin = QDoubleSpinBox()
+        self.flat_profile_bin_step_spin.setRange(0.002, 0.2)
+        self.flat_profile_bin_step_spin.setDecimals(3)
+        self.flat_profile_bin_step_spin.setSingleStep(0.001)
+        flat_layout.addRow("y_norm Bin Step:", self.flat_profile_bin_step_spin)
+
+        self.flat_pixel_min_spin = QDoubleSpinBox()
+        self.flat_pixel_min_spin.setRange(0.01, 2.0)
+        self.flat_pixel_min_spin.setSingleStep(0.01)
+        flat_layout.addRow("Pixel Flat Min:", self.flat_pixel_min_spin)
+
+        self.flat_pixel_max_spin = QDoubleSpinBox()
+        self.flat_pixel_max_spin.setRange(0.1, 5.0)
+        self.flat_pixel_max_spin.setSingleStep(0.01)
+        flat_layout.addRow("Pixel Flat Max:", self.flat_pixel_max_spin)
+
+        flat_group.setLayout(flat_layout)
+        layout.addRow(flat_group)
+
+        widget.setLayout(layout)
+        scroll.setWidget(widget)
+        return scroll
+
+    # 按过扫描方法启用对应参数。
+    def _update_overscan_params_enabled(self):
+        """Enable/disable overscan parameters based on selected method."""
+        method = self.overscan_method_combo.currentText()
+        
+        if method == 'mean_only':
+            # No additional parameters needed
+            self.overscan_smooth_window_spin.setEnabled(False)
+            self.overscan_poly_type_combo.setEnabled(False)
+            self.overscan_poly_order_spin.setEnabled(False)
+        elif method == 'mean_savgol':
+            # Only smooth window needed
+            self.overscan_smooth_window_spin.setEnabled(True)
+            self.overscan_poly_type_combo.setEnabled(False)
+            self.overscan_poly_order_spin.setEnabled(False)
+        elif method == 'mean_polynomial':
+            # Poly type and order needed
+            self.overscan_smooth_window_spin.setEnabled(False)
+            self.overscan_poly_type_combo.setEnabled(True)
+            self.overscan_poly_order_spin.setEnabled(True)
+
+    # 按背景方法启用对应参数。
+    def _update_bg_params_enabled(self):
+        """Enable/disable background parameters based on selected method."""
+        method = self.bg_method_combo.currentText()
+
+        # Method-specific params
+        is_conv = (method == 'convolution')
+        is_spline = (method == 'column_spline')
+        is_bspline = (method == 'bspline')
+
+        self.bg_kernel_sigma_x_spin.setEnabled(is_conv)
+        self.bg_kernel_sigma_y_spin.setEnabled(is_conv)
+        self.bg_spline_smooth_factor_spin.setEnabled(is_spline)
+        self.bg_spline_post_smooth_x_spin.setEnabled(is_spline)
+        self.bg_poly_order_spin.setEnabled(is_bspline)
+        self.bg_bspline_smooth_spin.setEnabled(is_bspline)
+
+        # Common params always enabled: sigma_clip, clip_iterations, clip_mode, mask_margin
+
+    # 创建波长标定设置页。
+    def _create_wlcalib_tab(self) -> QWidget:
+        """Create wavelength calibration settings tab."""
+        scroll = QScrollArea()
+        scroll.setWidgetResizable(True)
+        widget = QWidget()
+        layout = QFormLayout()
+
+        # Calibration lamp type and files
+        calib_group = QGroupBox("Calibration Files")
+        calib_layout = QFormLayout()
+
+        self.linelist_combo = QComboBox()
+        self.linelist_combo.addItems(['ThAr', 'Ar', 'Ne', 'He', 'Fe', 'custom'])
+        calib_layout.addRow("Calibration Lamp Type:", self.linelist_combo)
+
+        # --- Anchor File ---
+        self.anchor_file_edit = QLineEdit()
+        anchor_file_layout = QHBoxLayout()
+        anchor_file_layout.setContentsMargins(0, 0, 0, 0)
+        anchor_file_layout.addWidget(self.anchor_file_edit)
+        anchor_browse_btn = QPushButton("...")
+        anchor_browse_btn.setFixedWidth(30)
+        anchor_browse_btn.clicked.connect(self._select_anchor_file)
+        anchor_file_layout.addWidget(anchor_browse_btn)
+        calib_layout.addRow("Anchor File (Identified Lines):", anchor_file_layout)
+
+        # --- Full Linelist ---
+        self.full_linelist_edit = QLineEdit()
+        full_linelist_layout = QHBoxLayout()
+        full_linelist_layout.setContentsMargins(0, 0, 0, 0)
+        full_linelist_layout.addWidget(self.full_linelist_edit)
+        full_linelist_browse_btn = QPushButton("...")
+        full_linelist_browse_btn.setFixedWidth(30)
+        full_linelist_browse_btn.clicked.connect(self._select_full_linelist_file)
+        full_linelist_layout.addWidget(full_linelist_browse_btn)
+        calib_layout.addRow("Full Linelist Catalog:", full_linelist_layout)
+
+        self.use_precomputed_calib_check = QCheckBox("Use pre-identified calibration files")
+        calib_layout.addRow(self.use_precomputed_calib_check)
+
+        # --- Precomputed Calibration File ---
+        self.precomputed_calib_file_edit = QLineEdit()
+        precomputed_calib_layout = QHBoxLayout()
+        precomputed_calib_layout.setContentsMargins(0, 0, 0, 0)
+        precomputed_calib_layout.addWidget(self.precomputed_calib_file_edit)
+        precomputed_browse_btn = QPushButton("...")
+        precomputed_browse_btn.setFixedWidth(30)
+        precomputed_browse_btn.clicked.connect(self._select_precomputed_calib_file)
+        precomputed_calib_layout.addWidget(precomputed_browse_btn)
+        calib_layout.addRow("Precomputed Calibration File:", precomputed_calib_layout)
+
+        calib_group.setLayout(calib_layout)
+        layout.addRow(calib_group)
+
+        # Polynomial solution
+        poly_group = QGroupBox("Polynomial Solution")
+        poly_layout = QFormLayout()
+
+        self.wlcalib_xorder_spin = QSpinBox()
+        self.wlcalib_xorder_spin.setRange(1, 10)
+        poly_layout.addRow("X Order (dispersion):", self.wlcalib_xorder_spin)
+
+        self.wlcalib_yorder_spin = QSpinBox()
+        self.wlcalib_yorder_spin.setRange(1, 10)
+        poly_layout.addRow("Y Order (spatial):", self.wlcalib_yorder_spin)
+
+        poly_group.setLayout(poly_layout)
+        layout.addRow(poly_group)
+
+        # Quality control
+        quality_group = QGroupBox("Quality Control")
+        quality_layout = QFormLayout()
+
+        self.wlcalib_match_tol_spin = QDoubleSpinBox()
+        self.wlcalib_match_tol_spin.setRange(0.1, 10.0)
+        self.wlcalib_match_tol_spin.setSingleStep(0.1)
+        self.wlcalib_match_tol_spin.setToolTip("Maximum allowed distance (in Angstroms) to match a detected peak to a catalog line.")
+        quality_layout.addRow("Catalog Match Tolerance (Å):", self.wlcalib_match_tol_spin)
+
+        self.wlcalib_rms_threshold_spin = QDoubleSpinBox()
+        self.wlcalib_rms_threshold_spin.setRange(0.01, 5.0)
+        self.wlcalib_rms_threshold_spin.setSingleStep(0.05)
+        self.wlcalib_rms_threshold_spin.setToolTip("Absolute maximum residual (in Angstroms) for a line to be kept in the final 2D polynomial fit.")
+        quality_layout.addRow("Max Residual Limit (Å):", self.wlcalib_rms_threshold_spin)
+
+        quality_group.setLayout(quality_layout)
+        layout.addRow(quality_group)
+
+        # Advanced parameters
+        adv_group = QGroupBox("Advanced Parameters")
+        adv_layout = QFormLayout()
+
+        self.wlcalib_discard_highest_spin = QSpinBox()
+        self.wlcalib_discard_highest_spin.setRange(0, 50)
+        self.wlcalib_discard_highest_spin.setToolTip("Number of apertures to discard at the highest aperture IDs during anchor matching.")
+        adv_layout.addRow("Discard Highest Aperture IDs:", self.wlcalib_discard_highest_spin)
+
+        self.wlcalib_discard_lowest_spin = QSpinBox()
+        self.wlcalib_discard_lowest_spin.setRange(0, 50)
+        self.wlcalib_discard_lowest_spin.setToolTip("Number of apertures to discard at the lowest aperture IDs during anchor matching.")
+        adv_layout.addRow("Discard Lowest Aperture IDs:", self.wlcalib_discard_lowest_spin)
+
+        adv_group.setLayout(adv_layout)
+        layout.addRow(adv_group)
+
+        widget.setLayout(layout)
+        scroll.setWidget(widget)
+        return scroll
+
+    # 创建孔径追踪与光谱提取设置页。
+    def _create_extraction_tab(self) -> QWidget:
+        """Create aperture tracing and spectrum extraction settings tab."""
+        scroll = QScrollArea()
+        scroll.setWidgetResizable(True)
+        widget = QWidget()
+        layout = QFormLayout()
+
+        # Aperture tracing
+        trace_group = QGroupBox("Apertures Tracing")
+        trace_layout = QFormLayout()
+
+        self.trace_snr_threshold_spin = QDoubleSpinBox()
+        self.trace_snr_threshold_spin.setRange(1.0, 100000.0)
+        self.trace_snr_threshold_spin.setSingleStep(0.5)
+        self.trace_snr_threshold_spin.setToolTip(
+            "Aperture detection SNR threshold (multiples of sigma above background).\n"
+            "Typical: 3.0–10.0. Lower to detect very faint apertures.")
+        trace_layout.addRow("Detection SNR Threshold:", self.trace_snr_threshold_spin)
+
+        self.trace_aperture_boundary_snr_spin = QDoubleSpinBox()
+        self.trace_aperture_boundary_snr_spin.setRange(1.0, 20.0)
+        self.trace_aperture_boundary_snr_spin.setSingleStep(0.5)
+        self.trace_aperture_boundary_snr_spin.setToolTip(
+            "Aperture boundary SNR threshold: the aperture edge is where the signal\n"
+            "drops to N × σ above background. Lower = wider apertures. Typical 2.0-5.0.")
+        trace_layout.addRow("Aperture Boundary SNR:", self.trace_aperture_boundary_snr_spin)
+
+        self.trace_min_coverage_spin = QDoubleSpinBox()
+        self.trace_min_coverage_spin.setRange(0.05, 0.80)
+        self.trace_min_coverage_spin.setSingleStep(0.05)
+        self.trace_min_coverage_spin.setDecimals(2)
+        self.trace_min_coverage_spin.setToolTip(
+            "Minimum fraction of detector width an aperture must span.\n"
+            "Lower to accept faint partial apertures; raise to reject short false traces.")
+        trace_layout.addRow("Min Trace Coverage:", self.trace_min_coverage_spin)
+
+        self.trace_degree_spin = QSpinBox()
+        self.trace_degree_spin.setRange(1, 10)
+        self.trace_degree_spin.setToolTip(
+            "Polynomial degree for Chebyshev fit of the aperture trace (applies to both center and edges).")
+        trace_layout.addRow("Trace Degree:", self.trace_degree_spin)
+
+        self.trace_width_cheb_degree_spin = QSpinBox()
+        self.trace_width_cheb_degree_spin.setRange(1, 10)
+        self.trace_width_cheb_degree_spin.setToolTip("Chebyshev polynomial degree for fitting the aperture width.")
+        trace_layout.addRow("Width Cheb Degree:", self.trace_width_cheb_degree_spin)
+
+        # --- Gap-fill parameters (only relevant when checkbox is checked) ---
+
+        self.trace_gap_fill_factor_spin = QDoubleSpinBox()
+        self.trace_gap_fill_factor_spin.setRange(1.0, 4.0)
+        self.trace_gap_fill_factor_spin.setSingleStep(0.1)
+        trace_layout.addRow("Gap Fill Factor:", self.trace_gap_fill_factor_spin)
+
+        self.trace_gap_fill_factor_interp_spin = QDoubleSpinBox()
+        self.trace_gap_fill_factor_interp_spin.setRange(1.0, 4.0)
+        self.trace_gap_fill_factor_interp_spin.setSingleStep(0.05)
+        self.trace_gap_fill_factor_interp_spin.setToolTip("Gap factor to trigger missing-aperture insertion during interpolation.")
+        trace_layout.addRow("Gap Fill Factor (Interp):", self.trace_gap_fill_factor_interp_spin)
+
+        self.trace_n_extend_below_spin = QSpinBox()
+        self.trace_n_extend_below_spin.setRange(0, 10)
+        trace_layout.addRow("Extend Below (Step2):", self.trace_n_extend_below_spin)
+
+        self.trace_n_extend_above_spin = QSpinBox()
+        self.trace_n_extend_above_spin.setRange(0, 10)
+        trace_layout.addRow("Extend Above (Step2):", self.trace_n_extend_above_spin)
+
+        self.trace_n_mask_below_spin = QSpinBox()
+        self.trace_n_mask_below_spin.setRange(0, 10)
+        trace_layout.addRow("Mask Below (Step3):", self.trace_n_mask_below_spin)
+
+        self.trace_n_mask_above_spin = QSpinBox()
+        self.trace_n_mask_above_spin.setRange(0, 10)
+        trace_layout.addRow("Mask Above (Step3):", self.trace_n_mask_above_spin)
+
+        trace_group.setLayout(trace_layout)
+        layout.addRow(trace_group)
+
+        widget.setLayout(layout)
+        scroll.setWidget(widget)
+        # Initialize UI state
+        self._update_trace_param_interactions()
+        return scroll
+
+    # 更新追踪参数间的启用状态。
+    def _update_trace_param_interactions(self):
+        """Enable/disable parameters (Placeholder, logic simplified)."""
+        pass
+
+    # 创建处理与输出设置页。
+    def _create_processing_tab(self) -> QWidget:
+        """Create general processing and output settings tab."""
+        scroll = QScrollArea()
+        scroll.setWidgetResizable(True)
+        widget = QWidget()
+        layout = QFormLayout()
+
+        # Processing mode
+        self.mode_combo = QComboBox()
+        self.mode_combo.addItems(['normal', 'debug'])
+        layout.addRow("Processing Mode:", self.mode_combo)
+
+        # Figure format
+        self.fig_format_combo = QComboBox()
+        self.fig_format_combo.addItems(['png', 'pdf', 'jpg'])
+        layout.addRow("Figure Format:", self.fig_format_combo)
+
+        # Output suffix
+        self.oned_suffix_edit = QLineEdit()
+        layout.addRow("Output Suffix:", self.oned_suffix_edit)
+
+        # Auto process
+        self.auto_process_check = QCheckBox("Auto process all science images without confirmation")
+        layout.addRow(self.auto_process_check)
+
+        # Output options
+        output_group = QGroupBox("Output Options")
+        output_layout = QFormLayout()
+
+        self.save_plots_check = QCheckBox("Save diagnostic plots")
+        output_layout.addRow(self.save_plots_check)
+
+        self.save_overscan_check = QCheckBox("Save overscan correction results")
+        output_layout.addRow(self.save_overscan_check)
+
+        self.save_bias_check = QCheckBox("Save bias correction results")
+        output_layout.addRow(self.save_bias_check)
+
+        self.save_flat_check = QCheckBox("Save flat fielding results")
+        output_layout.addRow(self.save_flat_check)
+
+        self.save_background_check = QCheckBox("Save background subtraction results")
+        output_layout.addRow(self.save_background_check)
+
+        self.save_cosmic_check = QCheckBox("Save cosmic ray correction results")
+        output_layout.addRow(self.save_cosmic_check)
+
+        self.save_extraction_check = QCheckBox("Save spectrum extraction results")
+        output_layout.addRow(self.save_extraction_check)
+
+        self.save_wlcalib_check = QCheckBox("Save wavelength calibration results")
+        output_layout.addRow(self.save_wlcalib_check)
+
+        self.save_deblaze_check = QCheckBox("Save de-blazing results")
+        output_layout.addRow(self.save_deblaze_check)
+
+        output_group.setLayout(output_layout)
+        layout.addRow(output_group)
+
+        widget.setLayout(layout)
+        scroll.setWidget(widget)
+        return scroll
+
+    # 选择已标识谱线的锚点文件。
+    def _select_anchor_file(self):
+        """Open file dialog to select anchor file."""
+        file_path, _ = QFileDialog.getOpenFileName(
+            self, "Select Anchor File", "", "CSV Files (*.csv);;Text Files (*.txt *.dat);;All Files (*)"
+        )
+        if file_path:
+            self.anchor_file_edit.setText(file_path)
+
+    # 选择完整谱线目录文件。
+    def _select_full_linelist_file(self):
+        """Open file dialog to select full linelist catalog."""
+        file_path, _ = QFileDialog.getOpenFileName(
+            self, "Select Full Linelist Catalog", "", "Data Files (*.dat *.txt);;All Files (*)"
+        )
+        if file_path:
+            self.full_linelist_edit.setText(file_path)
+
+    # 选择预先标定结果文件。
+    def _select_precomputed_calib_file(self):
+        """Open file dialog to select precomputed calibration FITS file."""
+        file_path, _ = QFileDialog.getOpenFileName(
+            self, "Select Precomputed Calibration File", "", "FITS Files (*.fits *.fit);;All Files (*)"
+        )
+        if file_path:
+            self.precomputed_calib_file_edit.setText(file_path)
+
+    # 将当前配置载入界面控件。
+    def load_current_values(self):
+        """Load current configuration values into UI."""
+        # Data & Instruments tab
+        self.rawdata_path_edit.setText(self.config.get('data', 'rawdata_path', './rawdata'))
+        self.statime_key_edit.setText(self.config.get('data', 'statime_key', 'DATE-OBS'))
+        self.exptime_key_edit.setText(self.config.get('data', 'exptime_key', 'EXPTIME'))
+        self.direction_combo.setCurrentText(self.config.get('data', 'direction', 'xrb'))
+        self.output_path_edit.setText(self.config.get('reduce', 'output_path', 'output'))
+        self.detector_gain_spin.setValue(self.config.get_float('telescope.detector', 'gain', 1.0))
+        self.detector_readnoise_spin.setValue(self.config.get_float('telescope.detector', 'readnoise', 5.0))
+
+        # Data Reduction tab
+        overscan_val = self.config.get_int('data', 'overscan_start_column', -1)
+        self.overscan_start_column_spin.setValue(overscan_val)
+        self.overscan_method_combo.setCurrentText(self.config.get('data', 'overscan_method', 'mean_only'))
+        self.overscan_smooth_window_spin.setValue(self.config.get_int('data', 'overscan_smooth_window', -1))
+        self.overscan_poly_type_combo.setCurrentText(self.config.get('data', 'overscan_poly_type', 'legendre'))
+        self.overscan_poly_order_spin.setValue(self.config.get_int('data', 'overscan_poly_order', 3))
+        self.detector_split_row_spin.setValue(self.config.get_int('data', 'detector_split_row', 2068))
+        # Update enabled state of overscan params based on selected method
+        self._update_overscan_params_enabled()
+        self.bias_combine_method_combo.setCurrentText(self.config.get('reduce.bias', 'combine_method', 'median'))
+        self.bias_combine_sigma_spin.setValue(self.config.get_float('reduce.bias', 'combine_sigma', 3.0))
+        self.flat_combine_method_combo.setCurrentText(self.config.get('reduce.flat', 'combine_method', 'median'))
+        self.flat_q_threshold_spin.setValue(self.config.get_float('reduce.flat', 'q_threshold', 0.5))
+        self.flat_mosaic_maxcount_spin.setValue(self.config.get_float('reduce.flat', 'mosaic_maxcount', 65535.0))
+        self.flat_blaze_smooth_factor_spin.setValue(self.config.get_float('reduce.flat', 'blaze_smooth_factor', 1.0))
+        self.flat_fringe_orders_spin.setValue(self.config.get_int('reduce.flat', 'fringe_orders', 20))
+        self.flat_width_smooth_window_spin.setValue(self.config.get_int('reduce.flat', 'width_smooth_window', 41))
+        self.flat_n_profile_segments_spin.setValue(self.config.get_int('reduce.flat', 'n_profile_segments', 100))
+        self.flat_profile_smooth_sigma_spin.setValue(self.config.get_float('reduce.flat', 'profile_smooth_sigma', 6.0))
+        self.flat_profile_bin_step_spin.setValue(self.config.get_float('reduce.flat', 'profile_bin_step', 0.01))
+        self.flat_pixel_min_spin.setValue(self.config.get_float('reduce.flat', 'pixel_flat_min', 0.5))
+        self.flat_pixel_max_spin.setValue(self.config.get_float('reduce.flat', 'pixel_flat_max', 1.5))
+        bg_method = self.config.get('reduce.background', 'method', 'convolution')
+        if bg_method not in ['convolution', 'column_spline', 'bspline']:
+            bg_method = 'convolution'
+        self.bg_method_combo.setCurrentText(bg_method)
+        self.bg_kernel_sigma_x_spin.setValue(self.config.get_float('reduce.background', 'kernel_sigma_x', 13.0))
+        self.bg_kernel_sigma_y_spin.setValue(self.config.get_float('reduce.background', 'kernel_sigma_y', 13.0))
+        self.bg_spline_smooth_factor_spin.setValue(self.config.get_float('reduce.background', 'spline_smooth_factor', 1.0))
+        self.bg_spline_post_smooth_x_spin.setValue(self.config.get_float('reduce.background', 'spline_post_smooth_x', 5.0))
+        self.bg_poly_order_spin.setValue(self.config.get_int('reduce.background', 'poly_order', 3))
+        self.bg_sigma_clip_spin.setValue(self.config.get_float('reduce.background', 'sigma_clip', 3.0))
+        self.bg_sigma_clip_iter_spin.setValue(self.config.get_int('reduce.background', 'sigma_clip_maxiters', 4))
+        clip_mode = self.config.get('reduce.background', 'sigma_clip_mode', 'upper')
+        self.bg_clip_mode_combo.setCurrentText(clip_mode)
+        self.bg_mask_margin_spin.setValue(self.config.get_int('reduce.background', 'mask_margin_pixels', 1))
+        self.bg_bspline_smooth_spin.setValue(self.config.get_float('reduce.background', 'bspline_smooth', 1.0))
+        self._update_bg_params_enabled()
+        self.cosmic_enabled_check.setChecked(self.config.get_bool('reduce', 'cosmic_enabled', 'yes'))
+        self.cosmic_sigclip_spin.setValue(self.config.get_float('reduce', 'cosmic_sigclip', 5.0))
+        self.cosmic_objlim_spin.setValue(self.config.get_float('reduce', 'cosmic_objlim', 5.0))
+        self.cosmic_gain_spin.setValue(self.config.get_float('reduce', 'cosmic_gain', 1.0))
+
+        # Wavelength Calibration tab
+        self.linelist_combo.setCurrentText(self.config.get('telescope.linelist', 'linelist_type', 'ThAr'))
+        self.anchor_file_edit.setText(self.config.get('telescope.linelist', 'anchor_file', 'calib_data/telescopes/xinglong216hrs/xinglong_thar_lines.csv'))
+        self.full_linelist_edit.setText(self.config.get('telescope.linelist', 'full_linelist', 'calib_data/linelists/thar-noao.dat'))
+        self.use_precomputed_calib_check.setChecked(self.config.get_bool('telescope.linelist', 'use_precomputed_calibration', False))
+        self.precomputed_calib_file_edit.setText(self.config.get('telescope.linelist', 'precomputed_calib_file', 'calib_data/telescopes/xinglong216hrs/wlcalib_20211123011_A.fits'))
+        self.wlcalib_xorder_spin.setValue(self.config.get_int('reduce.wlcalib', 'xorder', 4))
+        self.wlcalib_yorder_spin.setValue(self.config.get_int('reduce.wlcalib', 'yorder', 4))
+        self.wlcalib_match_tol_spin.setValue(self.config.get_float('reduce.wlcalib', 'match_tolerance', 2.0))
+        self.wlcalib_rms_threshold_spin.setValue(self.config.get_float('reduce.wlcalib', 'rms_threshold', 0.5))
+        self.wlcalib_discard_highest_spin.setValue(self.config.get_int('reduce.wlcalib', 'discard_highest_apertures', 20))
+        self.wlcalib_discard_lowest_spin.setValue(self.config.get_int('reduce.wlcalib', 'discard_lowest_apertures', 10))
+
+        # Orders Tracing tab
+        self.trace_snr_threshold_spin.setValue(self.config.get_float('reduce.trace', 'snr_threshold', 5.0))
+        self.trace_aperture_boundary_snr_spin.setValue(self.config.get_float('reduce.trace', 'aperture_boundary_snr', 3.0))
+        self.trace_gap_fill_factor_spin.setValue(self.config.get_float('reduce.trace', 'gap_fill_factor', 1.6))
+        self.trace_gap_fill_factor_interp_spin.setValue(self.config.get_float('reduce.trace', 'gap_fill_factor_interp', 1.35))
+        self.trace_min_coverage_spin.setValue(self.config.get_float('reduce.trace', 'min_trace_coverage', 0.20))
+        self.trace_degree_spin.setValue(self.config.get_int('reduce.trace', 'degree', 4))
+        self.trace_width_cheb_degree_spin.setValue(self.config.get_int('reduce.trace', 'width_cheb_degree', 3))
+        self.trace_n_extend_below_spin.setValue(self.config.get_int('reduce.trace', 'n_extend_below', 0))
+        self.trace_n_extend_above_spin.setValue(self.config.get_int('reduce.trace', 'n_extend_above', 0))
+        self.trace_n_mask_below_spin.setValue(self.config.get_int('reduce.trace', 'n_mask_below', 4))
+        self.trace_n_mask_above_spin.setValue(self.config.get_int('reduce.trace', 'n_mask_above', 4))
+
+        # Processing & Output tab
+        self.mode_combo.setCurrentText(self.config.get('reduce', 'mode', 'normal'))
+        self.fig_format_combo.setCurrentText(self.config.get('reduce', 'fig_format', 'png'))
+        self.oned_suffix_edit.setText(self.config.get('reduce', 'oned_suffix', '_ods'))
+        self.auto_process_check.setChecked(self.config.get_bool('reduce', 'auto_process_all_images', False))
+        self.save_plots_check.setChecked(self.config.get_bool('reduce', 'save_plots', True))
+        self.save_overscan_check.setChecked(self.config.get_bool('reduce.save_intermediate', 'save_overscan', True))
+        self.save_bias_check.setChecked(self.config.get_bool('reduce.save_intermediate', 'save_bias', True))
+        self.save_flat_check.setChecked(self.config.get_bool('reduce.save_intermediate', 'save_flat', True))
+        self.save_background_check.setChecked(self.config.get_bool('reduce.save_intermediate', 'save_background', True))
+        self.save_cosmic_check.setChecked(self.config.get_bool('reduce.save_intermediate', 'save_cosmic', True))
+        self.save_extraction_check.setChecked(self.config.get_bool('reduce.save_intermediate', 'save_extraction', True))
+        self.save_wlcalib_check.setChecked(self.config.get_bool('reduce.save_intermediate', 'save_wlcalib', True))
+        self.save_deblaze_check.setChecked(self.config.get_bool('reduce.save_intermediate', 'save_deblaze', True))
+
+    # 保存界面中的配置项。
+    def _save_settings(self):
+        """Save settings to configuration."""
+        try:
+            # Data & Instruments tab
+            self.config.set('data', 'rawdata_path', self.rawdata_path_edit.text())
+            self.config.set('data', 'statime_key', self.statime_key_edit.text())
+            self.config.set('data', 'exptime_key', self.exptime_key_edit.text())
+            self.config.set('data', 'direction', self.direction_combo.currentText())
+            self.config.set('reduce', 'output_path', self.output_path_edit.text())
+            self.config.set('telescope.detector', 'gain', str(self.detector_gain_spin.value()))
+            self.config.set('telescope.detector', 'readnoise', str(self.detector_readnoise_spin.value()))
+
+            # Data Reduction tab
+            self.config.set('data', 'overscan_start_column', str(self.overscan_start_column_spin.value()))
+            self.config.set('data', 'overscan_method', self.overscan_method_combo.currentText())
+            self.config.set('data', 'overscan_smooth_window', str(self.overscan_smooth_window_spin.value()))
+            self.config.set('data', 'overscan_poly_type', self.overscan_poly_type_combo.currentText())
+            self.config.set('data', 'overscan_poly_order', str(self.overscan_poly_order_spin.value()))
+            self.config.set('data', 'detector_split_row', str(self.detector_split_row_spin.value()))
+            self.config.set('reduce.bias', 'combine_method', self.bias_combine_method_combo.currentText())
+            self.config.set('reduce.bias', 'combine_sigma', str(self.bias_combine_sigma_spin.value()))
+            self.config.set('reduce.flat', 'combine_method', self.flat_combine_method_combo.currentText())
+            self.config.set('reduce.flat', 'q_threshold', str(self.flat_q_threshold_spin.value()))
+            self.config.set('reduce.flat', 'mosaic_maxcount', str(self.flat_mosaic_maxcount_spin.value()))
+            self.config.set('reduce.flat', 'blaze_smooth_factor', str(self.flat_blaze_smooth_factor_spin.value()))
+            self.config.set('reduce.flat', 'fringe_orders', str(self.flat_fringe_orders_spin.value()))
+            self.config.set('reduce.flat', 'width_smooth_window', str(self.flat_width_smooth_window_spin.value()))
+            self.config.set('reduce.flat', 'n_profile_segments', str(self.flat_n_profile_segments_spin.value()))
+            self.config.set('reduce.flat', 'profile_smooth_sigma', str(self.flat_profile_smooth_sigma_spin.value()))
+            self.config.set('reduce.flat', 'profile_bin_step', str(self.flat_profile_bin_step_spin.value()))
+            self.config.set('reduce.flat', 'pixel_flat_min', str(self.flat_pixel_min_spin.value()))
+            self.config.set('reduce.flat', 'pixel_flat_max', str(self.flat_pixel_max_spin.value()))
+            self.config.set('reduce.background', 'method', self.bg_method_combo.currentText())
+            self.config.set('reduce.background', 'kernel_sigma_x', str(self.bg_kernel_sigma_x_spin.value()))
+            self.config.set('reduce.background', 'kernel_sigma_y', str(self.bg_kernel_sigma_y_spin.value()))
+            self.config.set('reduce.background', 'spline_smooth_factor', str(self.bg_spline_smooth_factor_spin.value()))
+            self.config.set('reduce.background', 'spline_post_smooth_x', str(self.bg_spline_post_smooth_x_spin.value()))
+            self.config.set('reduce.background', 'poly_order', str(self.bg_poly_order_spin.value()))
+            self.config.set('reduce.background', 'sigma_clip', str(self.bg_sigma_clip_spin.value()))
+            self.config.set('reduce.background', 'sigma_clip_maxiters', str(self.bg_sigma_clip_iter_spin.value()))
+            self.config.set('reduce.background', 'sigma_clip_mode', self.bg_clip_mode_combo.currentText())
+            self.config.set('reduce.background', 'mask_margin_pixels', str(self.bg_mask_margin_spin.value()))
+            self.config.set('reduce.background', 'bspline_smooth', str(self.bg_bspline_smooth_spin.value()))
+            self.config.set('reduce', 'cosmic_enabled', 'yes' if self.cosmic_enabled_check.isChecked() else 'no')
+            self.config.set('reduce', 'cosmic_sigclip', str(self.cosmic_sigclip_spin.value()))
+            self.config.set('reduce', 'cosmic_objlim', str(self.cosmic_objlim_spin.value()))
+            self.config.set('reduce', 'cosmic_gain', str(self.cosmic_gain_spin.value()))
+
+            # Wavelength Calibration tab
+            self.config.set('telescope.linelist', 'linelist_type', self.linelist_combo.currentText())
+            self.config.set('telescope.linelist', 'anchor_file', self.anchor_file_edit.text())
+            self.config.set('telescope.linelist', 'full_linelist', self.full_linelist_edit.text())
+            self.config.set('telescope.linelist', 'use_precomputed_calibration',
+                           'yes' if self.use_precomputed_calib_check.isChecked() else 'no')
+            self.config.set('telescope.linelist', 'precomputed_calib_file', self.precomputed_calib_file_edit.text())
+            self.config.set('reduce.wlcalib', 'xorder', str(self.wlcalib_xorder_spin.value()))
+            self.config.set('reduce.wlcalib', 'yorder', str(self.wlcalib_yorder_spin.value()))
+            self.config.set('reduce.wlcalib', 'match_tolerance', str(self.wlcalib_match_tol_spin.value()))
+            self.config.set('reduce.wlcalib', 'rms_threshold', str(self.wlcalib_rms_threshold_spin.value()))
+            self.config.set('reduce.wlcalib', 'discard_highest_apertures', str(self.wlcalib_discard_highest_spin.value()))
+            self.config.set('reduce.wlcalib', 'discard_lowest_apertures', str(self.wlcalib_discard_lowest_spin.value()))
+
+            # Orders Tracing tab
+            self.config.set('reduce.trace', 'snr_threshold', str(self.trace_snr_threshold_spin.value()))
+            self.config.set('reduce.trace', 'aperture_boundary_snr', str(self.trace_aperture_boundary_snr_spin.value()))
+            self.config.set('reduce.trace', 'gap_fill_factor', str(self.trace_gap_fill_factor_spin.value()))
+            self.config.set('reduce.trace', 'gap_fill_factor_interp', str(self.trace_gap_fill_factor_interp_spin.value()))
+            self.config.set('reduce.trace', 'min_trace_coverage', str(self.trace_min_coverage_spin.value()))
+            self.config.set('reduce.trace', 'degree', str(self.trace_degree_spin.value()))
+            self.config.set('reduce.trace', 'width_cheb_degree', str(self.trace_width_cheb_degree_spin.value()))
+            self.config.set('reduce.trace', 'n_extend_below', str(self.trace_n_extend_below_spin.value()))
+            self.config.set('reduce.trace', 'n_extend_above', str(self.trace_n_extend_above_spin.value()))
+            self.config.set('reduce.trace', 'n_mask_below', str(self.trace_n_mask_below_spin.value()))
+            self.config.set('reduce.trace', 'n_mask_above', str(self.trace_n_mask_above_spin.value()))
+
+            # Processing & Output tab
+            self.config.set('reduce', 'mode', self.mode_combo.currentText())
+            self.config.set('reduce', 'fig_format', self.fig_format_combo.currentText())
+            self.config.set('reduce', 'oned_suffix', self.oned_suffix_edit.text())
+            self.config.set('reduce', 'auto_process_all_images', 'yes' if self.auto_process_check.isChecked() else 'no')
+            self.config.set('reduce', 'save_plots', 'yes' if self.save_plots_check.isChecked() else 'no')
+            self.config.set('reduce.save_intermediate', 'save_overscan',
+                           'yes' if self.save_overscan_check.isChecked() else 'no')
+            self.config.set('reduce.save_intermediate', 'save_bias',
+                           'yes' if self.save_bias_check.isChecked() else 'no')
+            self.config.set('reduce.save_intermediate', 'save_flat',
+                           'yes' if self.save_flat_check.isChecked() else 'no')
+            self.config.set('reduce.save_intermediate', 'save_background',
+                           'yes' if self.save_background_check.isChecked() else 'no')
+            self.config.set('reduce.save_intermediate', 'save_cosmic',
+                           'yes' if self.save_cosmic_check.isChecked() else 'no')
+            self.config.set('reduce.save_intermediate', 'save_extraction',
+                           'yes' if self.save_extraction_check.isChecked() else 'no')
+            self.config.set('reduce.save_intermediate', 'save_wlcalib',
+                           'yes' if self.save_wlcalib_check.isChecked() else 'no')
+            self.config.set('reduce.save_intermediate', 'save_deblaze',
+                           'yes' if self.save_deblaze_check.isChecked() else 'no')
+
+            # Save to file
+            self.config.save()
+
+            self.accept()
+
+        except Exception as e:
+            from PyQt5.QtWidgets import QMessageBox
+            QMessageBox.critical(self, "Error", f"Failed to save settings: {e}")