pyckster 26.1.3__py3-none-any.whl → 26.1.4__py3-none-any.whl

pyckster/core.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 """
-This script is a PyQt5 GUI for picking seismic traveltimes.
+This script is a PyQt5 GUI for the processing and analysis of active near-surface seismic data
 Copyright (C) 2026 Sylvain Pasquet
 Email: sylvain.pasquet@sorbonne-universite.fr
 
@@ -49,6 +49,7 @@ from PyQt5.QtWidgets import (
     QFileDialog, QAction, QActionGroup, QLabel, QListWidget, QComboBox, QStatusBar, QScrollArea,QProgressDialog,
     QPushButton, QDialog, QHBoxLayout, QVBoxLayout, QLineEdit, QCheckBox, QTableWidget, QTableWidgetItem, QMessageBox,
     QDoubleSpinBox, QFrame, QFormLayout, QDialogButtonBox, QGroupBox, QSpinBox, QGraphicsRectItem, QSlider, QStyle,
+    QStackedLayout,
     QTextEdit,
 )
 from PyQt5.QtCore import QLocale, pyqtSignal, Qt
@@ -1896,6 +1897,13 @@ class MainWindow(QMainWindow):
         self.dispersionShowCrosshairCheck.toggled.connect(self.onPickingShowCrosshairChanged)
         dispersionPicksLayout.addWidget(self.dispersionShowCrosshairCheck)
         
+        # Show Aliasing Limit checkbox
+        self.dispersionShowAliasingLimitCheck = QCheckBox("Show Aliasing Limit")
+        self.dispersionShowAliasingLimitCheck.setChecked(getattr(self, 'dispersion_show_aliasing_limit', False))
+        self.dispersionShowAliasingLimitCheck.setToolTip("Show spatial aliasing limits (energy below dispersion)")
+        self.dispersionShowAliasingLimitCheck.toggled.connect(self.onDispersionShowAliasingLimitChanged)
+        dispersionPicksLayout.addWidget(self.dispersionShowAliasingLimitCheck)
+        
         dispersionPicksLayout.addStretch()
 
         # Create top view selector controls panel
@@ -2971,7 +2979,8 @@ class MainWindow(QMainWindow):
                 for attr in ['topPseudosectionModeSpinBox', 'bottomPseudosectionModeSpinBox',
                             'topPseudosectionFreqLambdaCheck', 'bottomPseudosectionFreqLambdaCheck',
                             'topPseudosectionInterpCheck', 'bottomPseudosectionInterpCheck',
-                            'topPseudosectionInvertYCheck', 'bottomPseudosectionInvertYCheck']:
+                            'topPseudosectionInvertYCheck', 'bottomPseudosectionInvertYCheck',
+                            'topPseudosectionUseSourceXCheck', 'bottomPseudosectionUseSourceXCheck']:
                     if hasattr(self, attr):
                         setattr(self, attr, None)
         except Exception:
@@ -3473,12 +3482,31 @@ class MainWindow(QMainWindow):
             default_colormap = getattr(self, colormap_attr, 'plasma')
             colormap_combo.setCurrentText(default_colormap)
             
-            # Connect handler after setting initial value
+            # Reverse colormap checkbox (created before connecting combo handler)
+            reverse_cmap_check = QCheckBox("Reverse")
+            reverse_cmap_check.setToolTip("Reverse colormap direction (use _r version)")
+            
+            # Connect handler with reverse logic
             colormap_handler = f'onTopColormapChanged' if prefix == 'top' else 'onBottomColormapChanged'
-            colormap_combo.currentTextChanged.connect(getattr(self, colormap_handler))
+            def on_colormap_changed(cmap_name):
+                # Apply _r suffix if reverse is checked
+                if reverse_cmap_check.isChecked():
+                    getattr(self, colormap_handler)(cmap_name + '_r')
+                else:
+                    getattr(self, colormap_handler)(cmap_name)
+            colormap_combo.currentTextChanged.connect(on_colormap_changed)
             
             layout.addWidget(colormap_combo)
             setattr(self, f'{prefix}ColormapComboBox', colormap_combo)
+            
+            # Reverse checkbox toggle behavior
+            def toggle_reverse_cmap(checked):
+                current = colormap_combo.currentText()
+                # Trigger colormap change with current selection
+                on_colormap_changed(current)
+            reverse_cmap_check.toggled.connect(toggle_reverse_cmap)
+            layout.addWidget(reverse_cmap_check)
+            setattr(self, f'{prefix}ReverseColormapCheck', reverse_cmap_check)
         
         # Traveltimes: no additional dynamic controls beyond colormap
         if view_type == "Traveltimes":
@@ -3522,6 +3550,13 @@ class MainWindow(QMainWindow):
             invert_y_check.toggled.connect(self.onPseudoSectionInvertYToggled)
             layout.addWidget(invert_y_check)
             setattr(self, f'{prefix}PseudosectionInvertYCheck', invert_y_check)
+
+            # Use source position / FFID on X-axis
+            use_source_x_check = QCheckBox("Use source / FFID on X")
+            use_source_x_check.setChecked(getattr(self, 'pseudosection_use_source_x', False))
+            use_source_x_check.toggled.connect(self.onPseudoSectionUseSourceXToggled)
+            layout.addWidget(use_source_x_check)
+            setattr(self, f'{prefix}PseudosectionUseSourceXCheck', use_source_x_check)
             
             add_separator()
             layout.addStretch()
@@ -3625,9 +3660,31 @@ class MainWindow(QMainWindow):
                 seismo_colormap_combo = QComboBox()
                 seismo_colormap_combo.addItems(['viridis', 'plasma', 'inferno', 'magma', 'cividis', 'turbo', 'hot', 'cool', 'coolwarm', 'seismic', 'RdBu', 'spring', 'summer', 'autumn', 'winter', 'gray', 'bone', 'copper', 'Blues', 'Reds', 'Greens', 'Oranges', 'Purples', 'Greys', 'jet', 'rainbow', 'pink', 'terrain', 'ocean'])
                 seismo_colormap_combo.setCurrentText(getattr(self, 'seismogram_colormap_str', 'Greys'))
-                seismo_colormap_combo.currentTextChanged.connect(self.onSeismoColormapChanged)
+                
+                # Reverse colormap checkbox (created before connecting combo handler)
+                reverse_seismo_cmap_check = QCheckBox("Reverse")
+                reverse_seismo_cmap_check.setToolTip("Reverse colormap direction (use _r version)")
+                
+                # Connect handler with reverse logic
+                def on_seismo_colormap_changed(cmap_name):
+                    # Apply _r suffix if reverse is checked
+                    if reverse_seismo_cmap_check.isChecked():
+                        self.onSeismoColormapChanged(cmap_name + '_r')
+                    else:
+                        self.onSeismoColormapChanged(cmap_name)
+                seismo_colormap_combo.currentTextChanged.connect(on_seismo_colormap_changed)
+                
                 layout.addWidget(seismo_colormap_combo)
                 setattr(self, 'seismoImageColormapCombo', seismo_colormap_combo)
+                
+                # Reverse checkbox toggle behavior
+                def toggle_reverse_seismo_cmap(checked):
+                    current = seismo_colormap_combo.currentText()
+                    # Trigger colormap change with current selection
+                    on_seismo_colormap_changed(current)
+                reverse_seismo_cmap_check.toggled.connect(toggle_reverse_seismo_cmap)
+                layout.addWidget(reverse_seismo_cmap_check)
+                setattr(self, 'seismoReverseColormapCheck', reverse_seismo_cmap_check)
                                 
                 interp_check = QCheckBox("Interpolate")
                 interp_check.setChecked(getattr(self, 'seismo_image_interpolate', True))
@@ -3756,6 +3813,29 @@ class MainWindow(QMainWindow):
                 use_topo_check.toggled.connect(self.onUseTopographyChanged)
                 layout.addWidget(use_topo_check)
                 setattr(self, 'useTopographyCheck', use_topo_check)
+                
+                # Enhance checkbox for better mode visibility
+                enhance_check = QCheckBox("Enhance")
+                enhance_check.setChecked(bool(getattr(self, 'dispersion_enhance', False)))
+                enhance_check.setToolTip("Enhance weak modes via contrast transformation (makes weak modes more visible)")
+                enhance_check.toggled.connect(self.onDispersionEnhanceChanged)
+                layout.addWidget(enhance_check)
+                setattr(self, 'dispersionEnhanceCheck', enhance_check)
+                
+                # Saturation slider for clipping bright spots
+                layout.addWidget(QLabel("Saturation:"))
+                saturation_spin = QDoubleSpinBox()
+                saturation_spin.setRange(0.5, 1.5)
+                saturation_spin.setDecimals(2)
+                saturation_spin.setSingleStep(0.01)
+                saturation_spin.setValue(getattr(self, 'dispersion_saturation', 1.0))
+                saturation_spin.setToolTip("Colormap brightness: <1 darkens, 1=normal, >1 brightens (1.25 ≈ MATLAB brighten(0.5))")
+                saturation_spin.setMinimumWidth(60)
+                saturation_spin.setMaximumWidth(70)
+                saturation_spin.valueChanged.connect(self.onDispersionSaturationChanged)
+                layout.addWidget(saturation_spin)
+                setattr(self, 'dispersionSaturationSpin', saturation_spin)
+                
             
             # Permute axes button (Spectrogram only)
             if view_type == "Spectrogram":
@@ -3841,14 +3921,15 @@ class MainWindow(QMainWindow):
             
             add_separator()
             
+            # Trace selection for phase-shift using range slider
+            trace_range_container = QHBoxLayout()
+            
             batch_window_button = QPushButton("Batch windowing")
             batch_window_button.setToolTip("Set fixed window parameters for all shots")
             batch_window_button.clicked.connect(self.onDispersionBatchWindowing)
             trace_range_container.addWidget(batch_window_button)
             trace_range_container.addStretch()
 
-            # Trace selection for phase-shift using range slider
-            trace_range_container = QHBoxLayout()
             trace_range_label = QLabel("Trace range:")
             trace_range_container.addWidget(trace_range_label)
             
@@ -3870,6 +3951,32 @@ class MainWindow(QMainWindow):
             layout.addWidget(trace_range_slider)
             # Use view-specific attribute name for the slider itself (top_traceRangeSlider or bottom_traceRangeSlider)
             setattr(self, f'{prefix}_traceRangeSlider', trace_range_slider)
+
+            add_separator()
+            
+            # Add stack checkbox for dispersion view (after trace range slider)
+            stack_checkbox_container = QWidget()
+            stack_checkbox_layout = QHBoxLayout(stack_checkbox_container)
+            stack_checkbox_layout.setContentsMargins(0, 0, 0, 0)
+            stack_checkbox_layout.setSpacing(4)
+            stack_checkbox_layout.addStretch()
+            
+            # Use view-specific checkbox reference so we can keep state across top/bottom swaps
+            stack_checkbox = QCheckBox("Stack all shots")
+            stack_checkbox.setChecked(getattr(self, 'dispersion_stack_mode', False))
+            stack_checkbox.setToolTip("Sum dispersion images from all shots with traces in current window range")
+            stack_checkbox.stateChanged.connect(self.onDispersionStackToggled)
+            stack_checkbox_layout.addWidget(stack_checkbox)
+            setattr(self, f"{prefix}_dispersionStackCheckbox", stack_checkbox)
+
+            # Stacking parameters button
+            stack_params_button = QPushButton("Stack params")
+            stack_params_button.setToolTip("Set stacking parameters (offset limits, side preference)")
+            stack_params_button.clicked.connect(self.onDispersionStackParamsClicked)
+            stack_checkbox_layout.addWidget(stack_params_button)
+            setattr(self, f"{prefix}_dispersionStackParamsButton", stack_params_button)
+            
+            layout.addWidget(stack_checkbox_container)
             
             # Populate trace range if we have data
             if self.streams and self.currentIndex is not None:
@@ -4034,6 +4141,24 @@ class MainWindow(QMainWindow):
         if top_type == "dispersion" or bottom_type == "dispersion":
             self.updatePlots()
 
+    def onDispersionEnhanceChanged(self, state):
+        """Handle enhance checkbox toggle for dispersion images"""
+        self.dispersion_enhance = bool(state)
+        # Replot dispersion if showing
+        top_type = getattr(self, 'topPlotType', '').lower()
+        bottom_type = getattr(self, 'bottomPlotType', '').lower()
+        if top_type == "dispersion" or bottom_type == "dispersion":
+            self.updatePlots()
+    
+    def onDispersionSaturationChanged(self, value):
+        """Handle saturation slider change for dispersion images"""
+        self.dispersion_saturation = float(value)
+        # Replot dispersion if showing
+        top_type = getattr(self, 'topPlotType', '').lower()
+        bottom_type = getattr(self, 'bottomPlotType', '').lower()
+        if top_type == "dispersion" or bottom_type == "dispersion":
+            self.updatePlots()
+
     def onSpectrogramPermuteAxes(self):
         """Toggle permutation of frequency and trace axes in spectrogram"""
         self.spectrogram_freq_on_y = not self.spectrogram_freq_on_y
@@ -4054,31 +4179,132 @@ class MainWindow(QMainWindow):
 
     def onDispersionBatchWindowing(self):
         """Configure batch windowing parameters for all shots in dispersion view"""
-        parameters = [
-            {'label': 'Window length (traces)', 'initial_value': 10, 'type': 'int'},
-            {'label': 'Window side', 'initial_value': 'best', 'type': 'combo', 'values': ['left', 'right', 'best']},
-            {'label': 'Prefer side (when best)', 'initial_value': 'right', 'type': 'combo', 'values': ['left', 'right']},
-            {'label': 'Offset from shot (traces)', 'initial_value': 1, 'type': 'int'}
-        ]
-        
-        dialog = GenericParameterDialog(
-            title="Batch Windowing Parameters",
-            parameters=parameters,
-            parent=self
-        )
-        
+        class BatchWindowingDialog(QDialog):
+            def __init__(self, parent, default_center=None):
+                super().__init__(parent)
+                self.setWindowTitle("Batch Windowing Parameters")
+                self.setModal(True)
+
+                layout = QVBoxLayout(self)
+
+                # Mode selector
+                mode_row = QHBoxLayout()
+                mode_row.addWidget(QLabel("Mode:"))
+                self.modeCombo = QComboBox()
+                self.modeCombo.addItems(["Constant offset", "Constant xmid"])
+                mode_row.addWidget(self.modeCombo)
+                layout.addLayout(mode_row)
+
+                self.stack = QStackedLayout()
+
+                # Constant offset page (current behaviour)
+                offset_page = QWidget()
+                offset_form = QFormLayout(offset_page)
+                self.offset_window_len = QSpinBox()
+                self.offset_window_len.setRange(1, 100000)
+                self.offset_window_len.setValue(10)
+                offset_form.addRow("Window length (traces)", self.offset_window_len)
+
+                self.window_side_combo = QComboBox()
+                self.window_side_combo.addItems(["left", "right", "best"])
+                self.window_side_combo.setCurrentText("best")
+                offset_form.addRow("Window side", self.window_side_combo)
+
+                self.prefer_side_combo = QComboBox()
+                self.prefer_side_combo.addItems(["left", "right"])
+                self.prefer_side_combo.setCurrentText("right")
+                offset_form.addRow("Prefer side (when best)", self.prefer_side_combo)
+
+                self.offset_from_shot = QSpinBox()
+                self.offset_from_shot.setRange(0, 100000)
+                self.offset_from_shot.setValue(1)
+                offset_form.addRow("Offset from shot (traces)", self.offset_from_shot)
+
+                self.stack.addWidget(offset_page)
+
+                # Constant xmid page (new behaviour)
+                xmid_page = QWidget()
+                xmid_form = QFormLayout(xmid_page)
+                self.xmid_window_len = QSpinBox()
+                self.xmid_window_len.setRange(1, 100000)
+                self.xmid_window_len.setValue(10)
+                xmid_form.addRow("Window length (traces)", self.xmid_window_len)
+
+                self.xmid_center = QDoubleSpinBox()
+                self.xmid_center.setDecimals(2)
+                self.xmid_center.setRange(-1e9, 1e9)
+                if default_center is not None:
+                    self.xmid_center.setValue(float(default_center))
+                xmid_form.addRow("Center of window (m)", self.xmid_center)
+
+                self.stack.addWidget(xmid_page)
+
+                stack_container = QWidget()
+                stack_container.setLayout(self.stack)
+                layout.addWidget(stack_container)
+
+                # Buttons
+                buttons = QHBoxLayout()
+                self.okButton = QPushButton("OK")
+                self.cancelButton = QPushButton("Cancel")
+                buttons.addWidget(self.okButton)
+                buttons.addWidget(self.cancelButton)
+                layout.addLayout(buttons)
+
+                self.modeCombo.currentIndexChanged.connect(self.stack.setCurrentIndex)
+                self.okButton.clicked.connect(self.accept)
+                self.cancelButton.clicked.connect(self.reject)
+
+            def getValues(self):
+                mode = 'constant_offset' if self.modeCombo.currentIndex() == 0 else 'constant_xmid'
+                if mode == 'constant_offset':
+                    return {
+                        'mode': mode,
+                        'window_length': self.offset_window_len.value(),
+                        'window_side': self.window_side_combo.currentText(),
+                        'prefer_side': self.prefer_side_combo.currentText(),
+                        'offset_from_shot': self.offset_from_shot.value(),
+                        'center_xmid': None
+                    }
+                else:
+                    return {
+                        'mode': mode,
+                        'window_length': self.xmid_window_len.value(),
+                        'window_side': 'best',
+                        'prefer_side': 'right',
+                        'offset_from_shot': 0,
+                        'center_xmid': self.xmid_center.value()
+                    }
+
+        # Default center: use existing xmid if available, otherwise current shot midpoint
+        default_center = None
+        if hasattr(self, 'currentIndex') and self.currentIndex is not None:
+            if hasattr(self, 'xmid_values') and self.currentIndex in self.xmid_values:
+                default_center = self.xmid_values[self.currentIndex]
+            elif self.trace_position and self.currentIndex < len(self.trace_position):
+                positions = self.trace_position[self.currentIndex]
+                if positions is not None and len(positions) > 0:
+                    default_center = float(np.mean(positions))
+
+        dialog = BatchWindowingDialog(self, default_center=default_center)
+
         if dialog.exec_():
             values = dialog.getValues()
-            window_length = values.get('Window length (traces)', 10)
-            window_side = values.get('Window side', 'best')
-            prefer_side = values.get('Prefer side (when best)', 'right')
-            offset_from_shot = values.get('Offset from shot (traces)', 1)
+            window_length = values.get('window_length', 10)
+            window_side = values.get('window_side', 'best')
+            prefer_side = values.get('prefer_side', 'right')
+            offset_from_shot = values.get('offset_from_shot', 1)
+            mode = values.get('mode', 'constant_offset')
+            center_xmid = values.get('center_xmid', None)
             
             # Apply batch windowing to all shots
-            self._applyBatchWindowingToAllShots(window_length, window_side, offset_from_shot, prefer_side)
+            self._applyBatchWindowingToAllShots(window_length, window_side, offset_from_shot, prefer_side, mode, center_xmid)
 
-    def _applyBatchWindowingToAllShots(self, window_length, window_side, offset_from_shot, prefer_side='right'):
-        """Apply batch windowing parameters to all loaded shots using shot and geophone positions"""
+    def _applyBatchWindowingToAllShots(self, window_length, window_side, offset_from_shot, prefer_side='right', mode='constant_offset', center_xmid=None):
+        """Apply batch windowing parameters to all loaded shots using shot and geophone positions.
+
+        mode: 'constant_offset' (legacy) or 'constant_xmid' (fixed center across shots).
+        """
         if not self.streams:
             QMessageBox.warning(self, "No Data", "No data loaded.")
             return
@@ -4093,6 +4319,11 @@ class MainWindow(QMainWindow):
             self.batch_windowing_params['window_side'] = window_side
             self.batch_windowing_params['offset_from_shot'] = offset_from_shot
             self.batch_windowing_params['prefer_side'] = prefer_side
+            self.batch_windowing_params['mode'] = mode
+            self.batch_windowing_params['center_xmid'] = center_xmid
+            
+            applied_count = 0
+            total_shots = len(self.streams)
             
             # Apply to each shot
             for shot_idx, stream in enumerate(self.streams):
@@ -4104,181 +4335,146 @@ class MainWindow(QMainWindow):
                 
                 shot_pos = self.source_position[shot_idx]
                 trace_positions = np.array(self.trace_position[shot_idx])
+                if trace_positions is None or len(trace_positions) == 0:
+                    continue
                 
-                # Calculate mean geophone spacing
-                if len(trace_positions) > 1:
-                    sorted_positions = np.sort(trace_positions)
-                    mean_dg = np.mean(np.diff(sorted_positions))
-                else:
-                    mean_dg = 1.0  # Default spacing if only one trace
-                
-                # Calculate offset distance threshold
-                offset_distance = offset_from_shot * mean_dg
-                
-                # Calculate distances from shot (positive = right, negative = left)
-                distances = trace_positions - shot_pos
-                abs_distances = np.abs(distances)
-                
-                # Sort traces by distance from shot to determine left/right
-                sorted_indices = np.argsort(distances)
-                sorted_distances = distances[sorted_indices]
-                
-                # Find traces on left (negative distance) and right (positive distance)
-                left_mask = sorted_distances < 0
-                right_mask = sorted_distances > 0
-                
-                left_indices = sorted_indices[left_mask]
-                right_indices = sorted_indices[right_mask]
-                
-                # Calculate window range based on side preference
                 first_trace = None
                 last_trace = None
+                selected_traces = None
                 
-                if window_side == 'left':
-                    # Use traces to the left of shot, beyond offset_distance
-                    if len(left_indices) > 0:
-                        # Filter left traces that are beyond the offset distance
-                        left_beyond_offset = left_indices[abs_distances[left_indices] >= offset_distance]
-                        
-                        if len(left_beyond_offset) > 0:
-                            # Sort by absolute distance (closest to shot first, among those beyond offset)
-                            left_sorted = left_beyond_offset[np.argsort(abs_distances[left_beyond_offset])]
-                            # Take window_length traces
-                            selected_traces = left_sorted[:window_length]
-                            first_trace = int(np.min(selected_traces))
-                            last_trace = int(np.max(selected_traces))
-                
-                elif window_side == 'right':
-                    # Use traces to the right of shot, beyond offset_distance
-                    if len(right_indices) > 0:
-                        # Filter right traces that are beyond the offset distance
-                        right_beyond_offset = right_indices[abs_distances[right_indices] >= offset_distance]
-                        
-                        if len(right_beyond_offset) > 0:
-                            # Sort by distance (closest to shot first, among those beyond offset)
-                            right_sorted = right_beyond_offset[np.argsort(abs_distances[right_beyond_offset])]
-                            # Take window_length traces
-                            selected_traces = right_sorted[:window_length]
-                            first_trace = int(np.min(selected_traces))
-                            last_trace = int(np.max(selected_traces))
-                
-                elif window_side == 'best':
-                    # Try preferred side first, fallback to other side if not enough traces
-                    if prefer_side == 'right':
-                        # Prefer right side - check if enough traces beyond offset_distance
-                        right_beyond_offset = right_indices[abs_distances[right_indices] >= offset_distance] if len(right_indices) > 0 else np.array([])
-                        
-                        if len(right_beyond_offset) >= window_length:
-                            # Enough traces on the right beyond offset
-                            right_sorted = right_beyond_offset[np.argsort(abs_distances[right_beyond_offset])]
-                            selected_traces = right_sorted[:window_length]
-                            first_trace = int(np.min(selected_traces))
-                            last_trace = int(np.max(selected_traces))
-                        else:
-                            # Try left side
-                            left_beyond_offset = left_indices[abs_distances[left_indices] >= offset_distance] if len(left_indices) > 0 else np.array([])
-                            if len(left_beyond_offset) >= window_length:
+                if mode == 'constant_xmid':
+                    # Fixed center across shots; pick closest traces to requested xmid
+                    if center_xmid is None:
+                        continue
+                    if len(trace_positions) < 1:
+                        continue
+                    # Pick nearest window_length traces to the target center
+                    idx_sorted = np.argsort(np.abs(trace_positions - center_xmid))
+                    if len(idx_sorted) >= window_length:
+                        selected_traces = idx_sorted[:window_length]
+                    else:
+                        # Not enough traces → keep previous window for this shot
+                        continue
+                    first_trace = int(np.min(selected_traces))
+                    last_trace = int(np.max(selected_traces))
+                else:
+                    # Legacy constant offset behaviour
+                    # Calculate mean geophone spacing
+                    if len(trace_positions) > 1:
+                        sorted_positions = np.sort(trace_positions)
+                        mean_dg = np.mean(np.diff(sorted_positions))
+                    else:
+                        mean_dg = 1.0  # Default spacing if only one trace
+
+                    # Calculate offset distance threshold
+                    offset_distance = offset_from_shot * mean_dg
+
+                    # Calculate distances from shot (positive = right, negative = left)
+                    distances = trace_positions - shot_pos
+                    abs_distances = np.abs(distances)
+
+                    # Sort traces by distance from shot to determine left/right
+                    sorted_indices = np.argsort(distances)
+                    sorted_distances = distances[sorted_indices]
+
+                    # Find traces on left (negative distance) and right (positive distance)
+                    left_mask = sorted_distances < 0
+                    right_mask = sorted_distances > 0
+
+                    left_indices = sorted_indices[left_mask]
+                    right_indices = sorted_indices[right_mask]
+
+                    if window_side == 'left':
+                        if len(left_indices) > 0:
+                            left_beyond_offset = left_indices[abs_distances[left_indices] >= offset_distance]
+                            if len(left_beyond_offset) > 0:
                                 left_sorted = left_beyond_offset[np.argsort(abs_distances[left_beyond_offset])]
                                 selected_traces = left_sorted[:window_length]
-                                first_trace = int(np.min(selected_traces))
-                                last_trace = int(np.max(selected_traces))
-                    else:
-                        # Prefer left side - check if enough traces beyond offset_distance
-                        left_beyond_offset = left_indices[abs_distances[left_indices] >= offset_distance] if len(left_indices) > 0 else np.array([])
-                        
-                        if len(left_beyond_offset) >= window_length:
-                            # Enough traces on the left beyond offset
-                            left_sorted = left_beyond_offset[np.argsort(abs_distances[left_beyond_offset])]
-                            selected_traces = left_sorted[:window_length]
-                            first_trace = int(np.min(selected_traces))
-                            last_trace = int(np.max(selected_traces))
-                        else:
-                            # Try right side
-                            right_beyond_offset = right_indices[abs_distances[right_indices] >= offset_distance] if len(right_indices) > 0 else np.array([])
-                            if len(right_beyond_offset) >= window_length:
+                    elif window_side == 'right':
+                        if len(right_indices) > 0:
+                            right_beyond_offset = right_indices[abs_distances[right_indices] >= offset_distance]
+                            if len(right_beyond_offset) > 0:
                                 right_sorted = right_beyond_offset[np.argsort(abs_distances[right_beyond_offset])]
                                 selected_traces = right_sorted[:window_length]
-                                first_trace = int(np.min(selected_traces))
-                                last_trace = int(np.max(selected_traces))
-                    
-                    # If still no valid range, reduce requirements (fewer than window_length traces or closer than offset)
-                    if first_trace is None or last_trace is None:
-                        # Use what's available, respecting preference
+                    elif window_side == 'best':
                         if prefer_side == 'right':
-                            # Try right side with any available traces beyond offset
                             right_beyond_offset = right_indices[abs_distances[right_indices] >= offset_distance] if len(right_indices) > 0 else np.array([])
-                            if len(right_beyond_offset) > 0:
+                            if len(right_beyond_offset) >= window_length:
                                 right_sorted = right_beyond_offset[np.argsort(abs_distances[right_beyond_offset])]
-                                selected_traces = right_sorted
-                                first_trace = int(np.min(selected_traces))
-                                last_trace = int(np.max(selected_traces))
+                                selected_traces = right_sorted[:window_length]
                             else:
-                                # Try left side with any available traces beyond offset
                                 left_beyond_offset = left_indices[abs_distances[left_indices] >= offset_distance] if len(left_indices) > 0 else np.array([])
-                                if len(left_beyond_offset) > 0:
+                                if len(left_beyond_offset) >= window_length:
                                     left_sorted = left_beyond_offset[np.argsort(abs_distances[left_beyond_offset])]
-                                    selected_traces = left_sorted
-                                    first_trace = int(np.min(selected_traces))
-                                    last_trace = int(np.max(selected_traces))
-                                elif len(right_indices) > 0:
-                                    # No offset possible, use closest right traces
-                                    right_sorted = right_indices[np.argsort(abs_distances[right_indices])]
-                                    selected_traces = right_sorted[:window_length] if len(right_sorted) >= window_length else right_sorted
-                                    first_trace = int(np.min(selected_traces))
-                                    last_trace = int(np.max(selected_traces))
-                                elif len(left_indices) > 0:
-                                    # No right traces, use closest left traces
-                                    left_sorted = left_indices[np.argsort(abs_distances[left_indices])]
-                                    selected_traces = left_sorted[:window_length] if len(left_sorted) >= window_length else left_sorted
-                                    first_trace = int(np.min(selected_traces))
-                                    last_trace = int(np.max(selected_traces))
+                                    selected_traces = left_sorted[:window_length]
                         else:
-                            # Prefer left side
-                            # Try left side with any available traces beyond offset
                             left_beyond_offset = left_indices[abs_distances[left_indices] >= offset_distance] if len(left_indices) > 0 else np.array([])
-                            if len(left_beyond_offset) > 0:
+                            if len(left_beyond_offset) >= window_length:
                                 left_sorted = left_beyond_offset[np.argsort(abs_distances[left_beyond_offset])]
-                                selected_traces = left_sorted
-                                first_trace = int(np.min(selected_traces))
-                                last_trace = int(np.max(selected_traces))
+                                selected_traces = left_sorted[:window_length]
                             else:
-                                # Try right side with any available traces beyond offset
+                                right_beyond_offset = right_indices[abs_distances[right_indices] >= offset_distance] if len(right_indices) > 0 else np.array([])
+                                if len(right_beyond_offset) >= window_length:
+                                    right_sorted = right_beyond_offset[np.argsort(abs_distances[right_beyond_offset])]
+                                    selected_traces = right_sorted[:window_length]
+
+                        # If still no valid range, relax requirements
+                        if selected_traces is None:
+                            if prefer_side == 'right':
                                 right_beyond_offset = right_indices[abs_distances[right_indices] >= offset_distance] if len(right_indices) > 0 else np.array([])
                                 if len(right_beyond_offset) > 0:
                                     right_sorted = right_beyond_offset[np.argsort(abs_distances[right_beyond_offset])]
                                     selected_traces = right_sorted
-                                    first_trace = int(np.min(selected_traces))
-                                    last_trace = int(np.max(selected_traces))
-                                elif len(left_indices) > 0:
-                                    # No offset possible, use closest left traces
-                                    left_sorted = left_indices[np.argsort(abs_distances[left_indices])]
-                                    selected_traces = left_sorted[:window_length] if len(left_sorted) >= window_length else left_sorted
-                                    first_trace = int(np.min(selected_traces))
-                                    last_trace = int(np.max(selected_traces))
-                                elif len(right_indices) > 0:
-                                    # No left traces, use closest right traces
-                                    right_sorted = right_indices[np.argsort(abs_distances[right_indices])]
-                                    selected_traces = right_sorted[:window_length] if len(right_sorted) >= window_length else right_sorted
-                                    first_trace = int(np.min(selected_traces))
-                                    last_trace = int(np.max(selected_traces))
-                
-                # Final fallback if still no valid range (shouldn't reach here)
+                                else:
+                                    left_beyond_offset = left_indices[abs_distances[left_indices] >= offset_distance] if len(left_indices) > 0 else np.array([])
+                                    if len(left_beyond_offset) > 0:
+                                        left_sorted = left_beyond_offset[np.argsort(abs_distances[left_beyond_offset])]
+                                        selected_traces = left_sorted
+                                    elif len(right_indices) > 0:
+                                        right_sorted = right_indices[np.argsort(abs_distances[right_indices])]
+                                        selected_traces = right_sorted[:window_length] if len(right_sorted) >= window_length else right_sorted
+                                    elif len(left_indices) > 0:
+                                        left_sorted = left_indices[np.argsort(abs_distances[left_indices])]
+                                        selected_traces = left_sorted[:window_length] if len(left_sorted) >= window_length else left_sorted
+                            else:
+                                left_beyond_offset = left_indices[abs_distances[left_indices] >= offset_distance] if len(left_indices) > 0 else np.array([])
+                                if len(left_beyond_offset) > 0:
+                                    left_sorted = left_beyond_offset[np.argsort(abs_distances[left_beyond_offset])]
+                                    selected_traces = left_sorted
+                                else:
+                                    right_beyond_offset = right_indices[abs_distances[right_indices] >= offset_distance] if len(right_indices) > 0 else np.array([])
+                                    if len(right_beyond_offset) > 0:
+                                        right_sorted = right_beyond_offset[np.argsort(abs_distances[right_beyond_offset])]
+                                        selected_traces = right_sorted
+                                    elif len(left_indices) > 0:
+                                        left_sorted = left_indices[np.argsort(abs_distances[left_indices])]
+                                        selected_traces = left_sorted[:window_length] if len(left_sorted) >= window_length else left_sorted
+                                    elif len(right_indices) > 0:
+                                        right_sorted = right_indices[np.argsort(abs_distances[right_indices])]
+                                        selected_traces = right_sorted[:window_length] if len(right_sorted) >= window_length else right_sorted
+
+                    if selected_traces is None:
+                        abs_distances = np.abs(distances)
+                        closest_indices = np.argsort(abs_distances)[:min(window_length, n_traces)]
+                        selected_traces = closest_indices
+
+                    if selected_traces is not None and len(selected_traces) > 0:
+                        first_trace = int(np.min(selected_traces))
+                        last_trace = int(np.max(selected_traces))
+
+                # If we still don't have a valid window (e.g., constant_xmid with too few traces), keep previous
                 if first_trace is None or last_trace is None:
-                    # Use closest traces to shot position
-                    abs_distances = np.abs(distances)
-                    closest_indices = np.argsort(abs_distances)[:min(window_length, n_traces)]
-                    first_trace = int(np.min(closest_indices))
-                    last_trace = int(np.max(closest_indices))
-                
+                    continue
+
                 # Ensure valid range
                 first_trace = max(0, min(first_trace, n_traces - 1))
                 last_trace = max(first_trace, min(last_trace, n_traces - 1))
-                
+
                 # Store in trace range memory using shot_idx as key (consistent with onFileSelectionChanged)
                 file_key = shot_idx
                 if file_key not in self.trace_range_memory:
                     self.trace_range_memory[file_key] = {}
-                
+
                 # Store for both views (sync them) using dictionary structure
                 self.trace_range_memory[file_key]['top'] = {
                     'first': first_trace,
@@ -4298,6 +4494,8 @@ class MainWindow(QMainWindow):
                 if not hasattr(self, 'xmid_values'):
                     self.xmid_values = {}
                 self.xmid_values[shot_idx] = center
+
+                applied_count += 1
             
             # Update the current shot's range slider and attributes
             if self.currentIndex is not None and self.currentIndex < len(self.streams):
@@ -4358,10 +4556,17 @@ class MainWindow(QMainWindow):
                         self._plot_target_viewbox = None
             
             # Show confirmation message
-            prefer_text = f", Prefer: {prefer_side}" if window_side == 'best' else ""
-            QMessageBox.information(self, "Batch Windowing", 
-                                  f"Applied batch windowing to {len(self.streams)} shots.\n"
-                                  f"Window: {window_length} traces, Side: {window_side}{prefer_text}")
+            prefer_text = f", Prefer: {prefer_side}" if (mode == 'constant_offset' and window_side == 'best') else ""
+            mode_text = "Constant xmid" if mode == 'constant_xmid' else "Constant offset"
+            QMessageBox.information(
+                self,
+                "Batch Windowing",
+                f"Applied batch windowing to {applied_count}/{total_shots} shots.\n"
+                f"Mode: {mode_text}. Window: {window_length} traces"
+                f"{', Center: %.2f m' % center_xmid if (mode == 'constant_xmid' and center_xmid is not None) else ''}"
+                f"{', Side: ' + window_side if mode == 'constant_offset' else ''}"
+                f"{prefer_text}"
+            )
         
         except Exception as e:
             QMessageBox.critical(self, "Error", f"Failed to apply batch windowing: {str(e)}")
@@ -4694,6 +4899,9 @@ class MainWindow(QMainWindow):
         if not (hasattr(self, 'currentIndex') and self.currentIndex is not None and self.streams):
             return
         
+        # Update dispersion window info in status bar
+        self.updateDispersionWindowInfo()
+        
         # Update the trace extent indicator and replot only for the controlled view
         if controlled_view == "top":
             if hasattr(self, 'topPlotType') and self.topPlotType == "dispersion":
@@ -4744,23 +4952,36 @@ class MainWindow(QMainWindow):
                 self.streams and self.trace_position and self.currentIndex < len(self.trace_position)):
             self.dispersionWindowLabel.setText("")
             return
+
+        # Only show info when a dispersion view is active
+        top_dispersion = getattr(self, 'topPlotType', None) == 'dispersion'
+        bottom_dispersion = getattr(self, 'bottomPlotType', None) == 'dispersion'
+        if not (top_dispersion or bottom_dispersion):
+            self.dispersionWindowLabel.setText("")
+            return
         
         # Determine which trace range to use - prioritize view-specific ranges
         first_trace = None
         last_trace = None
         
-        # Check top view range first
-        if hasattr(self, 'top_first_trace') and hasattr(self, 'top_last_trace'):
-            first_trace = self.top_first_trace
-            last_trace = self.top_last_trace
-        # Then check bottom view range
-        elif hasattr(self, 'bottom_first_trace') and hasattr(self, 'bottom_last_trace'):
-            first_trace = self.bottom_first_trace
-            last_trace = self.bottom_last_trace
-        # Fallback to default trace range
-        elif hasattr(self, 'first_trace') and hasattr(self, 'last_trace'):
-            first_trace = self.first_trace
-            last_trace = self.last_trace
+        # Prefer the trace range from the view currently showing the dispersion image
+        if top_dispersion:
+            first_trace = getattr(self, 'top_first_trace', None)
+            last_trace = getattr(self, 'top_last_trace', None)
+            if first_trace is None or last_trace is None:
+                first_trace = getattr(self, 'bottom_first_trace', getattr(self, 'first_trace', None))
+                last_trace = getattr(self, 'bottom_last_trace', getattr(self, 'last_trace', None))
+        else:
+            first_trace = getattr(self, 'bottom_first_trace', None)
+            last_trace = getattr(self, 'bottom_last_trace', None)
+            if first_trace is None or last_trace is None:
+                first_trace = getattr(self, 'top_first_trace', getattr(self, 'first_trace', None))
+                last_trace = getattr(self, 'top_last_trace', getattr(self, 'last_trace', None))
+        # Final fallback to unified attributes if everything else is missing
+        if first_trace is None or last_trace is None:
+            if hasattr(self, 'first_trace') and hasattr(self, 'last_trace'):
+                first_trace = self.first_trace
+                last_trace = self.last_trace
         
         # If no trace range is set, don't show anything
         if first_trace is None or last_trace is None:
@@ -4792,10 +5013,16 @@ class MainWindow(QMainWindow):
             self.xmid_values = {}
         self.xmid_values[self.currentIndex] = center
         
+        # Build the status message
+        window_info = f"Disp. Window: First={pos_first:.1f}m, Last={pos_last:.1f}m, Center={center:.1f}m, Width={width:.1f}m ({n_traces_used} tr)"
+        
+        # Append stacking info if enabled
+        if getattr(self, 'dispersion_stack_mode', False):
+            shot_count = getattr(self, 'dispersion_stack_shot_count', 0)
+            window_info += f" | Stacked ({shot_count} shots)"
+        
         # Update the status bar label
-        self.dispersionWindowLabel.setText(
-            f"Disp. Window: First={pos_first:.1f}m, Last={pos_last:.1f}m, Center={center:.1f}m, Width={width:.1f}m ({n_traces_used} tr)"
-        )
+        self.dispersionWindowLabel.setText(window_info)
 
     def onTopNormPerTraceChanged(self, state):
         """Handle per-trace normalization toggle for top Spectrogram/Dispersion"""
@@ -5418,6 +5645,26 @@ class MainWindow(QMainWindow):
            (hasattr(self, 'bottomPlotType') and self.bottomPlotType == "seismogram"):
             self.updatePlots()
     
+    def onDispersionShowAliasingLimitChanged(self, state):
+        """Handle aliasing limit display toggle for dispersion view"""
+        self.dispersion_show_aliasing_limit = bool(state)
+        
+        # Replot dispersion if currently displayed (set correct target widget)
+        if hasattr(self, 'topPlotType') and self.topPlotType == "dispersion":
+            if self.streams and self.currentIndex is not None:
+                self._plot_target_widget = self.topPlotWidget
+                self._plot_target_viewbox = self.topViewBox
+                self.plotDispersion()
+                self._plot_target_widget = None
+                self._plot_target_viewbox = None
+        elif hasattr(self, 'bottomPlotType') and self.bottomPlotType == "dispersion":
+            if self.streams and self.currentIndex is not None:
+                self._plot_target_widget = self.bottomPlotWidget
+                self._plot_target_viewbox = self.bottomViewBox
+                self.plotDispersion()
+                self._plot_target_widget = None
+                self._plot_target_viewbox = None
+    
     def onSeismoShowDispWindowChanged(self, state):
         """Handle seismogram show dispersion window toggle"""
         self.seismo_show_disp_window = bool(state)
@@ -5722,15 +5969,24 @@ class MainWindow(QMainWindow):
             
             # Check if any of the dragged files are supported formats
             for url in urls:
-                file_path = url.toLocalFile()
-                # Check for seismic data formats: .su, .segy, .sgy, .sg2, .dat
-                if file_path.lower().endswith(('.su', '.segy', '.sgy', '.sg2', '.dat')):
-                    accepted = True
-                    break
-                # Check for pick files: .sgt
-                if file_path.lower().endswith('.sgt'):
-                    accepted = True
-                    break
+                try:
+                    file_path = url.toLocalFile()
+                    if not file_path:
+                        continue
+                    # Check for seismic data formats: .su, .segy, .sgy, .sg2, .dat
+                    if file_path.lower().endswith(('.su', '.segy', '.sgy', '.sg2', '.dat', '.seg2')):
+                        accepted = True
+                        break
+                    # Check for pick files: .sgt
+                    if file_path.lower().endswith('.sgt'):
+                        accepted = True
+                        break
+                    # Check for dispersion picks: .pvc
+                    if file_path.lower().endswith('.pvc'):
+                        accepted = True
+                        break
+                except Exception:
+                    continue
             
             if accepted:
                 event.acceptProposedAction()
@@ -5745,30 +6001,44 @@ class MainWindow(QMainWindow):
             urls = event.mimeData().urls()
             seismic_files = []
             pick_files = []
+            pvc_files = []
             
             # Categorize the dropped files
             for url in urls:
                 file_path = url.toLocalFile()
                 
                 # Seismic data files
-                if file_path.lower().endswith(('.su', '.segy', '.sgy', '.sg2', '.dat')):
+                if file_path.lower().endswith(('.su', '.segy', '.sgy', '.sg2', '.dat', '.seg2')):
                     seismic_files.append(file_path)
-                # Pick files
+                # Traveltime pick files
                 elif file_path.lower().endswith('.sgt'):
                     pick_files.append(file_path)
+                # Dispersion pick files
+                elif file_path.lower().endswith('.pvc'):
+                    pvc_files.append(file_path)
             
             # Process seismic files
             if seismic_files:
-                self.openFile(fileNames_new=seismic_files)
-                event.acceptProposedAction()
+                try:
+                    self.openFile(fileNames_new=seismic_files)
+                    event.acceptProposedAction()
+                except Exception as e:
+                    QMessageBox.critical(self, "Load Seismic Error", f"Error loading seismic files:\n{str(e)}")
             
-            # Process pick files (load them after seismic files are loaded)
+            # Process traveltime pick files (load them after seismic files are loaded)
             if pick_files and self.streams:
                 for pick_file in pick_files:
                     try:
                         self.loadPicks(pick_file, verbose=False)
                     except Exception as e:
                         QMessageBox.warning(self, "Load Picks Error", f"Error loading picks from {pick_file}:\n{str(e)}")
+            
+            # Process dispersion pick files
+            if pvc_files:
+                try:
+                    self.loadDispersionCurvesFromPvc(file_paths=pvc_files)
+                except Exception as e:
+                    QMessageBox.warning(self, "Load Dispersion Picks Error", f"Error loading dispersion picks:\n{str(e)}")
     
     def _get_wiggle_amplitude(self, x_pos, y_time):
         """
@@ -6168,6 +6438,129 @@ class MainWindow(QMainWindow):
                                 if amp is not None:
                                     amp_text = f", Amplitude: {amp:.4f}"
                             self.coordinatesLabel.setText(f"{x_label}: {x_value}, {y_label}: {y_value}{amp_text}")
+                        
+                        elif self.bottomPlotType == 'pseudosection':
+                            # Pseudo-section: X = source position/FFID or window center, Y = frequency or wavelength
+                            use_source_x = getattr(self, 'pseudosection_use_source_x', False)
+                            use_wavelength = getattr(self, 'pseudosection_use_wavelength', False)
+                            
+                            # Y-axis: frequency or wavelength
+                            if use_wavelength:
+                                y_label = "Wavelength"
+                                y_value = f"{view_coords.y():.1f} m"
+                            else:
+                                y_label = "Frequency"
+                                y_value = f"{view_coords.y():.1f} Hz"
+                            
+                            # X-axis: depends on pseudosection_use_source_x
+                            if use_source_x:
+                                # Match layout Y-axis label (source position or FFID)
+                                plot_type_y = getattr(self, 'plotTypeY', 'source_position')
+                                if plot_type_y == 'ffid':
+                                    x_label = "FFID"
+                                    x_value = f"{view_coords.x():.0f}"
+                                elif plot_type_y == 'source_position':
+                                    x_label = "Source Position"
+                                    x_value = f"{view_coords.x():.1f} m"
+                                else:
+                                    x_label = "X"
+                                    x_value = f"{view_coords.x():.2f}"
+                            else:
+                                # Window center: position or trace number depending on plotTypeX
+                                plot_type_x = getattr(self, 'plotTypeX', 'trace_position')
+                                if plot_type_x == 'trace_position':
+                                    x_label = "Window Center"
+                                    x_value = f"{view_coords.x():.1f} m"
+                                else:
+                                    # Trace number modes (shot_trace_number, file_trace_number, unique_trace_number)
+                                    x_label = "Window Center"
+                                    x_value = f"{view_coords.x():.1f}"
+                            
+                            # Try to find nearby pick and show phase velocity
+                            phase_vel_text = ""
+                            try:
+                                if self.dispersion_curves is not None:
+                                    show_interp = getattr(self, 'pseudosection_show_interpolated', False)
+                                    selected_mode = getattr(self, 'pseudosection_mode', 0)
+                                    
+                                    # Collect all pick points with their phase velocities
+                                    pick_x_coords = []
+                                    pick_y_coords = []
+                                    pick_velocities = []
+                                    
+                                    for shot_idx, shot_curves in enumerate(self.dispersion_curves):
+                                        if shot_curves is None or 'modes' not in shot_curves:
+                                            continue
+                                        if selected_mode not in shot_curves['modes']:
+                                            continue
+                                        mode_data = shot_curves['modes'][selected_mode]
+                                        
+                                        # Get frequencies and velocities
+                                        freqs = None
+                                        vels = None
+                                        
+                                        if show_interp and 'frequencies' in mode_data:
+                                            freqs = np.array(mode_data.get('frequencies', []))
+                                            vels = np.array(mode_data.get('velocities', []))
+                                        elif 'picked_points' in mode_data and mode_data['picked_points']:
+                                            points = mode_data['picked_points']
+                                            freqs = np.array([p[0] for p in points])
+                                            vels = np.array([p[1] for p in points])
+                                        
+                                        if freqs is not None and len(freqs) > 0:
+                                            # Determine X coordinate for this shot
+                                            if use_source_x:
+                                                plot_type_y = getattr(self, 'plotTypeY', 'source_position')
+                                                if plot_type_y == 'ffid' and hasattr(self, 'ffid') and shot_idx < len(self.ffid):
+                                                    try:
+                                                        x_coord = float(self.ffid[shot_idx])
+                                                    except Exception:
+                                                        continue
+                                                elif shot_idx < len(self.source_position):
+                                                    x_coord = self.source_position[shot_idx]
+                                                else:
+                                                    continue
+                                            else:
+                                                if shot_idx not in getattr(self, 'xmid_values', {}):
+                                                    continue
+                                                x_coord = self.xmid_values[shot_idx]
+                                            
+                                            # Add all points for this shot
+                                            for freq, vel in zip(freqs, vels):
+                                                if use_wavelength:
+                                                    wavelength = vel / freq if freq > 0 else 0
+                                                    pick_y_coords.append(wavelength)
+                                                else:
+                                                    pick_y_coords.append(freq)
+                                                pick_x_coords.append(x_coord)
+                                                pick_velocities.append(vel)
+                                    
+                                    # Find closest pick
+                                    if len(pick_x_coords) > 0:
+                                        pick_distances = []
+                                        for i in range(len(pick_x_coords)):
+                                            dx = pick_x_coords[i] - view_coords.x()
+                                            dy = pick_y_coords[i] - view_coords.y()
+                                            distance = (dx**2 + dy**2)**0.5
+                                            pick_distances.append(distance)
+                                        
+                                        min_distance = min(pick_distances)
+                                        
+                                        # Define tolerance based on view range (about 2% of the view range)
+                                        x_range = self.bottomViewBox.viewRange()[0]
+                                        y_range = self.bottomViewBox.viewRange()[1]
+                                        x_tolerance = abs(x_range[1] - x_range[0]) * 0.02
+                                        y_tolerance = abs(y_range[1] - y_range[0]) * 0.02
+                                        tolerance = (x_tolerance**2 + y_tolerance**2)**0.5
+                                        
+                                        if min_distance < tolerance:
+                                            closest_idx = pick_distances.index(min_distance)
+                                            phase_vel = pick_velocities[closest_idx]
+                                            phase_vel_text = f", Phase Velocity: {phase_vel:.1f} m/s"
+                            except Exception:
+                                pass
+                            
+                            self.coordinatesLabel.setText(f"{x_label}: {x_value}, {y_label}: {y_value}{phase_vel_text}")
                             
                         else:  # 'layout' plot
                             # Layout plot: show pick time if available, otherwise show coordinates
@@ -6309,6 +6702,10 @@ class MainWindow(QMainWindow):
     def initializeAttributes(self):
         # Initialize the attributes 
 
+        # Initialize core data structure lists (MUST be first, used by openFile)
+        self.fileNames = []
+        self.streams = []
+        
         self.currentFileName = None
         self.currentIndex = None
         self.streamIndex = None
@@ -6368,6 +6765,15 @@ class MainWindow(QMainWindow):
         # Dispersion-specific normalization settings (independent from spectrogram)
         self.dispersion_norm_per_trace = True
         self.dispersion_norm_per_freq = True
+
+        # Dispersion stacking parameters (used when stacking shots)
+        self.dispersion_stack_min_offset = 0.0   # Minimum offset to window edge (m)
+        self.dispersion_stack_max_offset = None  # Maximum offset to window edge (m); None = no limit
+        self.dispersion_stack_side = 'Both sides'  # Side preference: 'Both sides', 'Left only', 'Right only'
+        
+        # Dispersion display enhancement parameters
+        self.dispersion_enhance = False  # Enhance weak modes using 1/(1-x) transformation
+        self.dispersion_saturation = 1.0  # Saturation factor (0.5-1.5): 1.0=no change
         
         # Unified analytical view parameter defaults (same for top/bottom)
         self.fmin = None   # Default fmin (auto -> 0 for Spectrogram/Phase-Shift)
@@ -6414,6 +6820,7 @@ class MainWindow(QMainWindow):
         self.update_pick_flag = False
         self.update_file_flag = False
         self.pick_file = ""
+        self.geophone_mapping = None  # Maps (shot_idx, trace_idx) -> sgt_geophone_number for order matching
         self.refrac_manager = None
         self.output_format = 'SEGY'
         self.headers_modified = False  # Track if headers have been modified (includes trace edits)
@@ -6425,6 +6832,7 @@ class MainWindow(QMainWindow):
         self.pseudosection_colormap_str = 'plasma'  # Colormap for velocity encoding
         self.pseudosection_invert_y = True  # Default: Y-axis pointing downward
         self.pseudosection_mode = 0  # Selected mode for pseudo-section display (M0, M1, M2, ...)
+        self.pseudosection_use_source_x = False  # False = window center (trace pos), True = source/FFID
         
         # Dispersion curve picking data structures (per view: top/bottom)
         # Format: {view: {'picked_points': [], 'picked_point_items': [], 'curve_line': None, 'current_dispersion_data': None}}
@@ -7055,6 +7463,13 @@ class MainWindow(QMainWindow):
         freq_min = self.dispersionAutoPickFreqMinSpin.value()
         freq_max = self.dispersionAutoPickFreqMaxSpin.value()
         
+        # Get trace spacing for aliasing limit calculation
+        dx = None
+        if self.trace_position and self.currentIndex < len(self.trace_position):
+            trace_pos = self.trace_position[self.currentIndex]
+            if len(trace_pos) >= 2:
+                dx = np.mean(np.abs(np.diff(trace_pos)))
+        
         # Filter frequencies within range
         freq_mask = (frequencies >= freq_min) & (frequencies <= freq_max)
         
@@ -7070,12 +7485,32 @@ class MainWindow(QMainWindow):
         # Compute max per frequency (full velocity range) within frequency range
         picked_points = []
         picked_items = []
-        for f_idx, vel_idx in enumerate(np.argmax(FV, axis=1)):
+        for f_idx in range(len(frequencies)):
             freq = frequencies[f_idx]
             # Only pick if frequency is in range
             if not freq_mask[f_idx]:
                 continue
+            
+            # Get dispersion slice at this frequency
+            dispersion_slice = FV[f_idx, :]
+            
+            # Apply aliasing limit: only consider velocities above first-order aliasing boundary
+            # Formula: vi = f/(( f/v0) + (i/dx)), for i=1 the boundary is approximately v > f*dx
+            if dx is not None and dx > 0:
+                v_alias = freq * dx  # First-order aliasing boundary
+                aliasing_mask = velocities >= v_alias
+                if not aliasing_mask.any():
+                    # No valid velocities above aliasing limit, skip this frequency
+                    continue
+                # Mask out velocities below aliasing limit
+                masked_slice = np.where(aliasing_mask, dispersion_slice, -np.inf)
+            else:
+                masked_slice = dispersion_slice
+            
+            # Find maximum in the valid (non-aliased) region
+            vel_idx = np.argmax(masked_slice)
             vel = velocities[vel_idx]
+            
             picked_points.append((freq, vel))
             point_item = pqg.ScatterPlotItem(
                 x=[freq], y=[vel],
@@ -7093,9 +7528,28 @@ class MainWindow(QMainWindow):
             picked_items.append(point_item)
             plot_widget.addItem(point_item)
 
-        # Persist
+        # Persist to mode data
         mode_data['picked_points'] = picked_points
         mode_data['picked_point_items'] = picked_items
+        
+        # Store picked points to dispersion_curves for persistence across shot switches
+        if self.currentIndex is not None and self.currentIndex < len(self.dispersion_curves):
+            if self.dispersion_curves[self.currentIndex] is None:
+                self.dispersion_curves[self.currentIndex] = {'modes': {}}
+            if 'modes' not in self.dispersion_curves[self.currentIndex]:
+                self.dispersion_curves[self.currentIndex]['modes'] = {}
+            
+            self.dispersion_curves[self.currentIndex]['modes'][state['current_mode']] = {
+                'picked_points': picked_points.copy()
+            }
+        
+        # Sync current mode data to other view
+        other_view = 'bottom' if view == 'top' else 'top'
+        other_state = self.dispersion_picking_state[other_view]
+        self._ensure_mode_exists(other_view, state['current_mode'])
+        other_mode_data = other_state['modes'][state['current_mode']]
+        other_mode_data['picked_points'] = picked_points.copy()
+        other_mode_data['picked_point_items'] = [None] * len(picked_points)
     
     def _refreshDispersionPicksDisplay(self):
         """Refresh display of all modes' picks and curves on dispersion plots"""
@@ -7470,6 +7924,13 @@ class MainWindow(QMainWindow):
         is_auto_mode = self.dispersionSemiAutoCheckbox.isChecked()
         vel_window = getattr(self, 'dispersion_auto_vel_window', 0.0)
         
+        # Get trace spacing for aliasing limit
+        dx = None
+        if self.trace_position and self.currentIndex < len(self.trace_position):
+            trace_pos = self.trace_position[self.currentIndex]
+            if len(trace_pos) >= 2:
+                dx = np.mean(np.abs(np.diff(trace_pos)))
+        
         if is_auto_mode:
             # Auto mode: find maximum at the clicked frequency, within optional velocity window
             freq_idx = np.argmin(np.abs(frequencies - clicked_freq))
@@ -7478,15 +7939,27 @@ class MainWindow(QMainWindow):
             # Get the dispersion values at this frequency
             dispersion_slice = FV[freq_idx, :]
             
+            # Apply aliasing limit: exclude velocities below first-order aliasing boundary
+            # Formula: vi = f/((f/v0) + (i/dx)), for i=1 the boundary is approximately v > f*dx
+            aliasing_mask = np.ones(len(velocities), dtype=bool)
+            if dx is not None and dx > 0:
+                v_alias = actual_freq * dx  # First-order aliasing boundary
+                aliasing_mask = velocities >= v_alias
+            
             # Apply velocity window if specified (>0): search only around clicked velocity
             if vel_window > 0:
                 vel_mask = np.abs(velocities - clicked_velocity) <= vel_window
-                if vel_mask.any():
-                    masked_slice = np.where(vel_mask, dispersion_slice, -np.inf)
+                combined_mask = vel_mask & aliasing_mask
+                if combined_mask.any():
+                    masked_slice = np.where(combined_mask, dispersion_slice, -np.inf)
                 else:
                     masked_slice = dispersion_slice  # fallback to full range if window empty
             else:
-                masked_slice = dispersion_slice
+                # Just apply aliasing mask
+                if aliasing_mask.any():
+                    masked_slice = np.where(aliasing_mask, dispersion_slice, -np.inf)
+                else:
+                    masked_slice = dispersion_slice
 
             max_vel_idx = np.argmax(masked_slice)
             picked_velocity = velocities[max_vel_idx]
@@ -8116,12 +8589,17 @@ class MainWindow(QMainWindow):
         if view:
             self.interpolateDispersionCurve(view)
     
-    def loadDispersionCurvesFromPvc(self):
-        """Load dispersion curves from .pvc files and match to shots by Xmid"""
-        # Open file dialog to select .pvc files
-        file_paths, _ = QFileDialog.getOpenFileNames(
-            self, "Select .pvc Files", "", "PVC Files (*.pvc);;All Files (*)"
-        )
+    def loadDispersionCurvesFromPvc(self, file_paths=None):
+        """Load dispersion curves from .pvc files and match to shots by Xmid
+        
+        Args:
+            file_paths: Optional list of file paths. If None, opens file dialog.
+        """
+        # Open file dialog if no paths provided
+        if file_paths is None:
+            file_paths, _ = QFileDialog.getOpenFileNames(
+                self, "Select .pvc Files", "", "PVC Files (*.pvc);;All Files (*)"
+            )
         
         if not file_paths:
             return
@@ -8364,8 +8842,6 @@ class MainWindow(QMainWindow):
                     unmatch_label.setWordWrap(True)
                     unmatch_label.setStyleSheet("color: #ff6f00;")
                     content_layout.addWidget(unmatch_label)
-
-            # Debug info removed - was too verbose for normal operation
             
             content_layout.addStretch()
             scroll_area.setWidget(content_widget)
@@ -8633,6 +9109,22 @@ class MainWindow(QMainWindow):
     
     def _on_dispersion_live_interpolate_changed(self, state):
         """Handler for live interpolate checkbox state change"""
+        # Synchronize with pseudo-section interpolate checkboxes
+        is_checked = (state == Qt.Checked)
+        if hasattr(self, 'topPseudosectionInterpCheck'):
+            self.topPseudosectionInterpCheck.blockSignals(True)
+            self.topPseudosectionInterpCheck.setChecked(is_checked)
+            self.topPseudosectionInterpCheck.blockSignals(False)
+        if hasattr(self, 'bottomPseudosectionInterpCheck'):
+            self.bottomPseudosectionInterpCheck.blockSignals(True)
+            self.bottomPseudosectionInterpCheck.setChecked(is_checked)
+            self.bottomPseudosectionInterpCheck.blockSignals(False)
+        self.pseudosection_show_interpolated = is_checked
+        
+        # Interpolate for pseudo-section if enabling
+        if is_checked:
+            self._interpolateAllShotsForPseudoSection()
+        
         view = self._get_active_dispersion_view()
         if view:
             if state == Qt.Checked:
@@ -8684,6 +9176,86 @@ class MainWindow(QMainWindow):
                 if len(mode_data['picked_points']) >= 2:
                     self.interpolateDispersionCurve(view)
     
+    def onDispersionStackToggled(self, state):
+        """Toggle stacking of dispersion images from all shots in current window range"""
+        self.dispersion_stack_mode = bool(state)
+        # Keep both top/bottom checkboxes in sync
+        for attr in ("top_dispersionStackCheckbox", "bottom_dispersionStackCheckbox"):
+            cb = getattr(self, attr, None)
+            if cb is not None and cb.isChecked() != self.dispersion_stack_mode:
+                cb.blockSignals(True)
+                cb.setChecked(self.dispersion_stack_mode)
+                cb.blockSignals(False)
+        # Replot dispersion with stacking enabled/disabled
+        if getattr(self, 'bottomPlotType', None) == 'dispersion':
+            # Ensure we render into the bottom plot when it owns the dispersion view
+            self._plot_target_widget = self.bottomPlotWidget
+            self._plot_target_viewbox = self.bottomViewBox
+            self.plotDispersion()
+            self._plot_target_widget = None
+            self._plot_target_viewbox = None
+        if getattr(self, 'topPlotType', None) == 'dispersion':
+            # Ensure we render into the top plot when it owns the dispersion view
+            self._plot_target_widget = self.topPlotWidget
+            self._plot_target_viewbox = self.topViewBox
+            self.plotDispersion()
+            self._plot_target_widget = None
+            self._plot_target_viewbox = None
+
+    def onDispersionStackParamsClicked(self):
+        """Open a dialog to configure shot stacking parameters for dispersion."""
+        # Current parameter values
+        min_off = getattr(self, 'dispersion_stack_min_offset', 0.0)
+        max_off = getattr(self, 'dispersion_stack_max_offset', None)
+        side_pref = getattr(self, 'dispersion_stack_side', 'Both sides')
+
+        parameters = [
+            {
+                'label': 'Min offset from window edge (m)',
+                'initial_value': min_off,
+                'type': 'float'
+            },
+            {
+                'label': 'Max offset from window edge (m)',
+                'initial_value': '' if max_off is None else max_off,
+                'type': 'float_or_empty'
+            },
+            {
+                'label': 'Use shots from side',
+                'initial_value': side_pref,
+                'type': 'combo',
+                'values': ['Both sides', 'Left only', 'Right only']
+            }
+        ]
+
+        dialog = GenericParameterDialog(title="Stacking Parameters", parameters=parameters, add_checkbox=False, parent=self)
+        if dialog.exec_():
+            values = dialog.getValues()
+            # Update internal parameters
+            self.dispersion_stack_min_offset = values.get('Min offset from window edge (m)', 0.0) or 0.0
+            self.dispersion_stack_max_offset = values.get('Max offset from window edge (m)', None)
+            self.dispersion_stack_side = values.get('Use shots from side', 'Both sides') or 'Both sides'
+
+            # Replot dispersion in whichever view(s) currently show it
+            if getattr(self, 'bottomPlotType', None) == 'dispersion':
+                self._plot_target_widget = self.bottomPlotWidget
+                self._plot_target_viewbox = self.bottomViewBox
+                try:
+                    self.plotDispersion()
+                except Exception:
+                    pass
+                self._plot_target_widget = None
+                self._plot_target_viewbox = None
+            if getattr(self, 'topPlotType', None) == 'dispersion':
+                self._plot_target_widget = self.topPlotWidget
+                self._plot_target_viewbox = self.topViewBox
+                try:
+                    self.plotDispersion()
+                except Exception:
+                    pass
+                self._plot_target_widget = None
+                self._plot_target_viewbox = None
+    
     def _calculateDispersionErrors(self, view, mode_data=None):
         """Calculate Lorentzian errors for dispersion picks
         
@@ -9332,7 +9904,10 @@ class MainWindow(QMainWindow):
             flat_plot_data_x = [item for sublist in plot_data_x for item in sublist]
 
             # Access the appropriate attribute - flatten picks from ALL streams (like Layout View)
-            flat_plot_data_y = [item for sublist in self.picks for item in sublist]
+            if self.picks is not None:
+                flat_plot_data_y = [item for sublist in self.picks for item in sublist]
+            else:
+                flat_plot_data_y = []
 
             # Get unique traces and times from list of list of traces array that are not None
             traces = [trace for trace in flat_plot_data_x if trace is not None]
@@ -9806,6 +10381,8 @@ class MainWindow(QMainWindow):
                         self.plotSpectrogram()
                     elif self.topPlotType == "dispersion":
                         self.plotDispersion()
+                    elif self.topPlotType == "pseudosection":
+                        self.plotPseudoSection()
                     
                     # Reset target widget after plotting
                     self._plot_target_widget = None
@@ -9828,12 +10405,23 @@ class MainWindow(QMainWindow):
                         self.plotSpectrogram()
                     elif self.bottomPlotType == "dispersion":
                         self.plotDispersion()
+                    elif self.bottomPlotType == "pseudosection":
+                        self.plotPseudoSection()
                     
                     # Reset target widget after plotting
                     self._plot_target_widget = None
                     self._plot_target_viewbox = None
                 
-                # Update dispersion window info in status bar
+                # Update FFID/source in status bar for all views
+                if hasattr(self, 'ffid') and self.ffid and self.currentIndex < len(self.ffid):
+                    try:
+                        ffid_val = self.ffid[self.currentIndex]
+                        src_val = self.source_position[self.currentIndex] if self.source_position else 'N/A'
+                        self.ffidLabel.setText(f'FFID: {ffid_val} | Source at {src_val} m')
+                    except Exception:
+                        pass
+                
+                # Update dispersion window info in status bar
                 self.updateDispersionWindowInfo()
 
     def navigateToPreviousFile(self):
@@ -10051,10 +10639,6 @@ class MainWindow(QMainWindow):
                     # Optionally subtract the mean to center around zero
                     # data_matrix = data_matrix - np.mean(data_matrix)
                 
-                print(f"DEBUG: Matrix shape: {data_matrix.shape}")
-                print(f"DEBUG: Value range: {np.min(data_matrix)} to {np.max(data_matrix)}")
-                print(f"DEBUG: Data type: {data_matrix.dtype}")
-                
                 # Convert to ObsPy stream
                 stream = self.ascii_to_obspy_stream(data_matrix, params)
                 
@@ -16055,11 +16639,20 @@ class MainWindow(QMainWindow):
         self.tracePositionAction.setChecked(False)
         # Disable air wave checkbox when not plotting by position (but keep it checked)
         if hasattr(self, 'airWaveWiggleCheck'):
-            self.airWaveWiggleCheck.setEnabled(False)
+            try:
+                self.airWaveWiggleCheck.setEnabled(False)
+            except RuntimeError:
+                pass
         if hasattr(self, 'showAirWaveAction'):
-            self.showAirWaveAction.setEnabled(False)
+            try:
+                self.showAirWaveAction.setEnabled(False)
+            except RuntimeError:
+                pass
         if hasattr(self, 'seismoShowAirWaveCheck'):
-            self.seismoShowAirWaveCheck.setEnabled(False)
+            try:
+                self.seismoShowAirWaveCheck.setEnabled(False)
+            except RuntimeError:
+                pass
         self.mean_dg = 1
         self.x_label = 'Trace Number (Original Field Record)'
         if self.streams:
@@ -17316,6 +17909,16 @@ class MainWindow(QMainWindow):
         self.update_pick_flag = False
         self.update_file_flag = False
         
+        # Update status bar FFID/source when dispersion or pseudo-section is active (ensure it stays current when navigating shots)
+        if (self.bottomPlotType in ('pseudosection', 'dispersion') or 
+            self.topPlotType in ('pseudosection', 'dispersion')) and self.currentIndex is not None:
+            try:
+                ffid_val = self.ffid[self.currentIndex] if hasattr(self, 'ffid') and self.ffid else 'N/A'
+                src_val = self.source_position[self.currentIndex] if self.source_position else 'N/A'
+                self.ffidLabel.setText(f'FFID: {ffid_val} | Source at {src_val} m')
+            except Exception:
+                pass
+        
         # Draw/update trace extent indicator (only shown on seismogram when dispersion is active)
         self.drawTraceExtentIndicator()
 
@@ -17841,76 +18444,212 @@ class MainWindow(QMainWindow):
         first_trace = max(0, min(first_trace, n_traces - 1))
         last_trace = max(first_trace + 1, min(last_trace, n_traces - 1))  # Ensure at least 2 traces
         
-        # Select traces within the specified range
-        trace_indices = np.arange(first_trace, last_trace + 1)
-        offsets_all = np.array([self.offset[self.currentIndex][i] for i in trace_indices])
-        trace_pos_all = np.array([self.trace_position[self.currentIndex][i] for i in trace_indices])
-        source_pos = self.source_position[self.currentIndex]
-        
-        # Compute distances (absolute distance from source)
-        distances_all = np.abs(offsets_all)
-        
-        # Apply topography correction if enabled
-        if getattr(self, 'use_topography_correction', False):
-            # Get elevation data for selected traces and source
-            trace_elevations = np.array([self.trace_elevation[self.currentIndex][i] for i in trace_indices])
-            source_elevation = self.source_elevation[self.currentIndex]
+        # Check if stacking is enabled
+        use_stacking = getattr(self, 'dispersion_stack_mode', False)
+        
+        if use_stacking:
+            # Stack dispersion from all shots with traces in current window range
+            # Get common parameters
+            vmin = getattr(self, 'vmin', 10.0)
+            vmax = getattr(self, 'vmax', 1500.0)
+            dv = getattr(self, 'dv', 5.0)
+            dt_ref = self.sample_interval[self.currentIndex]
+            nyquist = 1.0 / (2 * dt_ref)
+            fmin_cfg = self.fmin if getattr(self, 'fmin', None) is not None else 0.0
+            fmax_default = min(100.0, nyquist)
+            fmax_cfg = self.fmax if getattr(self, 'fmax', None) is not None else fmax_default
+            fmin = max(0.0, min(fmin_cfg, nyquist))
+            fmax = max(0.0, min(fmax_cfg, nyquist))
+            
+            stacked_FV = None
+            fs_ref = None
+            vs_ref = None
+            shot_count = 0
+            
+            for shot_idx, stream_shot in enumerate(self.streams):
+                n_traces_shot = len(stream_shot)
+                if n_traces_shot <= first_trace:
+                    continue
+                
+                last_trace_actual = min(last_trace, n_traces_shot - 1)
+                trace_indices_shot = np.arange(first_trace, last_trace_actual + 1)
+                
+                # Exclude shots whose source lies inside the current trace window
+                if (self.trace_position and shot_idx < len(self.trace_position) and 
+                    self.source_position and shot_idx < len(self.source_position)):
+                    trace_positions_window = [self.trace_position[shot_idx][i] for i in trace_indices_shot]
+                    source_pos = self.source_position[shot_idx]
+                    window_min = min(trace_positions_window)
+                    window_max = max(trace_positions_window)
+                    
+                    # Skip this shot if source is inside the window
+                    if window_min <= source_pos <= window_max:
+                        continue
+
+                    # Apply side preference and offset constraints relative to window edges
+                    side_pref = getattr(self, 'dispersion_stack_side', 'Both sides')
+                    min_off = getattr(self, 'dispersion_stack_min_offset', 0.0) or 0.0
+                    max_off = getattr(self, 'dispersion_stack_max_offset', None)
+
+                    # Determine which side the shot is on and its edge offset
+                    if source_pos < window_min:
+                        shot_side = 'Left only'
+                        edge_offset = window_min - source_pos
+                    elif source_pos > window_max:
+                        shot_side = 'Right only'
+                        edge_offset = source_pos - window_max
+                    else:
+                        # Already excluded above; keep for safety
+                        continue
+
+                    # Enforce side preference
+                    if side_pref == 'Left only' and shot_side != 'Left only':
+                        continue
+                    if side_pref == 'Right only' and shot_side != 'Right only':
+                        continue
+
+                    # Enforce offset constraints
+                    if edge_offset < min_off:
+                        continue
+                    if (max_off is not None) and (edge_offset > max_off):
+                        continue
+                
+                try:
+                    offsets_all_shot = np.array([self.offset[shot_idx][i] for i in trace_indices_shot])
+                    distances_all_shot = np.abs(offsets_all_shot)
+                    
+                    if getattr(self, 'use_topography_correction', False):
+                        trace_elev = np.array([self.trace_elevation[shot_idx][i] for i in trace_indices_shot])
+                        source_elev = self.source_elevation[shot_idx]
+                        dz = source_elev - trace_elev
+                        distances_all_shot = np.sqrt(distances_all_shot**2 + dz**2)
+                    
+                    sorted_order = np.argsort(offsets_all_shot)
+                    distances_sorted = distances_all_shot[sorted_order]
+                    trace_indices_shot_sorted = trace_indices_shot[sorted_order]
+                    
+                    data_shot = np.array([stream_shot[i].data for i in trace_indices_shot_sorted])
+                    dt_shot = self.sample_interval[shot_idx]
+                    
+                    fs, vs, FV_shot = phase_shift(data_shot, dt_shot, distances_sorted, vmin, vmax, dv, fmax, fmin)
+                    
+                    eps = 1e-12
+                    # Discard amplitudes below aliasing boundary for this shot
+                    dx_alias = None
+                    if len(distances_sorted) >= 2:
+                        dx_alias = np.mean(np.abs(np.diff(distances_sorted)))
+                    if dx_alias and dx_alias > 0:
+                        v_alias = 2.0 * fs[:, None] * dx_alias
+                        alias_mask = vs[None, :] >= v_alias
+                        FV_shot = np.where(alias_mask, FV_shot, 0.0)
+
+                    if getattr(self, 'dispersion_norm_per_freq', False):
+                        max_per_f = np.maximum(np.max(FV_shot, axis=1, keepdims=True), eps)
+                        FV_shot = FV_shot / max_per_f
+                    
+                    if stacked_FV is None:
+                        stacked_FV = FV_shot.copy()
+                        fs_ref = fs
+                        vs_ref = vs
+                    else:
+                        stacked_FV += FV_shot
+                    
+                    shot_count += 1
+                except (IndexError, ValueError, KeyError):
+                    continue
             
-            # Calculate elevation differences
-            dz = trace_elevations - source_elevation
+            if stacked_FV is None or shot_count == 0:
+                QMessageBox.warning(self, "No Data", "No shots found in current window range.")
+                return
             
-            # Calculate slant distance: sqrt(horizontal_distance^2 + elevation_difference^2)
-            distances_all = np.sqrt(distances_all**2 + dz**2)
-        
-        # Apply topography correction if enabled
-        if getattr(self, 'use_topography_correction', False):
-            # Get elevation data for selected traces and source
-            trace_elevations = np.array([self.trace_elevation[self.currentIndex][i] for i in trace_indices])
-            source_elevation = self.source_elevation[self.currentIndex]
+            # Store the number of shots used in stacking for status bar display
+            self.dispersion_stack_shot_count = shot_count
             
-            # Calculate elevation differences
-            dz = trace_elevations - source_elevation
+            FV = stacked_FV / shot_count
+            fs = fs_ref
+            vs = vs_ref
+        else:
+            # Original single-shot logic
+            # Skip computation if source is within the current trace window
+            trace_indices = np.arange(first_trace, last_trace + 1)
+            trace_pos_all = np.array([self.trace_position[self.currentIndex][i] for i in trace_indices])
+            source_pos = self.source_position[self.currentIndex]
+            window_min = np.min(trace_pos_all)
+            window_max = np.max(trace_pos_all)
+            
+            if window_min <= source_pos <= window_max:
+                # Source is within window, skip computation silently
+                return
             
-            # Calculate slant distance: sqrt(horizontal_distance^2 + elevation_difference^2)
-            distances_all = np.sqrt(distances_all**2 + dz**2)
-        
-        # Sort traces by offset value (left to right spatially)
-        sorted_order = np.argsort(offsets_all)
-        trace_indices = trace_indices[sorted_order]
-        trace_pos_sorted = trace_pos_all[sorted_order]
-        offsets_sorted = offsets_all[sorted_order]
-        distances_sorted = distances_all[sorted_order]
-        
-        # Get data in sorted order
-        data = np.array([stream[i].data for i in trace_indices])
-        offsets = distances_sorted  # Pass distances (absolute) to phase_shift, not offsets
-
-        # Get parameters
-        dt = self.sample_interval[self.currentIndex]
-
-        # Parameters for phase-shift analysis (use UI values if provided)
-        vmin = getattr(self, 'vmin', 10.0)
-        vmax = getattr(self, 'vmax', 1500.0)
-        dv = getattr(self, 'dv', 5.0)
-        nyquist = 1.0 / (2 * dt)
-        # Use configured defaults; if None provided by UI, fall back to safe bounds
-        fmin_cfg = self.fmin if getattr(self, 'fmin', None) is not None else 0.0
-        fmax_default = min(100.0, nyquist)
-        fmax_cfg = self.fmax if getattr(self, 'fmax', None) is not None else fmax_default
-        # Clamp to [0, Nyquist] defensively
-        fmin = max(0.0, min(fmin_cfg, nyquist))
-        fmax = max(0.0, min(fmax_cfg, nyquist))
-
-        try:
+            offsets_all = np.array([self.offset[self.currentIndex][i] for i in trace_indices])
+            
+            # Compute distances (absolute distance from source)
+            distances_all = np.abs(offsets_all)
+            
+            # Apply topography correction if enabled
+            if getattr(self, 'use_topography_correction', False):
+                # Get elevation data for selected traces and source
+                trace_elevations = np.array([self.trace_elevation[self.currentIndex][i] for i in trace_indices])
+                source_elevation = self.source_elevation[self.currentIndex]
+                
+                # Calculate elevation differences
+                dz = trace_elevations - source_elevation
+                
+                # Calculate slant distance: sqrt(horizontal_distance^2 + elevation_difference^2)
+                distances_all = np.sqrt(distances_all**2 + dz**2)
+            
+            # Sort traces by offset value (left to right spatially)
+            sorted_order = np.argsort(offsets_all)
+            trace_indices = trace_indices[sorted_order]
+            trace_pos_sorted = trace_pos_all[sorted_order]
+            offsets_sorted = offsets_all[sorted_order]
+            distances_sorted = distances_all[sorted_order]
+            
+            # Get data in sorted order
+            data = np.array([stream[i].data for i in trace_indices])
+            offsets = distances_sorted  # Pass distances (absolute) to phase_shift, not offsets
+
+            # Get parameters
+            dt = self.sample_interval[self.currentIndex]
+
+            # Parameters for phase-shift analysis (use UI values if provided)
+            vmin = getattr(self, 'vmin', 10.0)
+            vmax = getattr(self, 'vmax', 1500.0)
+            dv = getattr(self, 'dv', 5.0)
+            nyquist = 1.0 / (2 * dt)
+            # Use configured defaults; if None provided by UI, fall back to safe bounds
+            fmin_cfg = self.fmin if getattr(self, 'fmin', None) is not None else 0.0
+            fmax_default = min(100.0, nyquist)
+            fmax_cfg = self.fmax if getattr(self, 'fmax', None) is not None else fmax_default
+            # Clamp to [0, Nyquist] defensively
+            fmin = max(0.0, min(fmin_cfg, nyquist))
+            fmax = max(0.0, min(fmax_cfg, nyquist))
             # Compute phase-shift transform
             fs, vs, FV = phase_shift(data, dt, offsets, vmin, vmax, dv, fmax, fmin)
 
+            # Store raw FV for potential inversion transformation
+            FV_raw = FV.copy()
+
+            # Discard amplitudes below aliasing boundary before normalization
+            # v_alias = 2 * f * dx ; zero out energy below that
+            dx_alias = None
+            if self.trace_position and self.currentIndex < len(self.trace_position):
+                trace_pos = self.trace_position[self.currentIndex]
+                if len(trace_pos) >= 2:
+                    dx_alias = np.mean(np.abs(np.diff(trace_pos)))
+            if dx_alias and dx_alias > 0:
+                v_alias = 2.0 * fs[:, None] * dx_alias  # shape (nfreq,1)
+                alias_mask = vs[None, :] >= v_alias
+                FV = np.where(alias_mask, FV, 0.0)
+
             # Normalize based on user selection (Dispersion only uses per-frequency normalization)
             eps = 1e-12
             if getattr(self, 'dispersion_norm_per_freq', False):
-                # Per-velocity normalization for Phase-Shift (normalize each velocity independently)
-                max_per_v = np.maximum(np.max(FV, axis=0, keepdims=True), eps)
-                FV = FV / max_per_v
+                # Per-frequency normalization for Phase-Shift (max of 1 at each frequency)
+                max_per_f = np.maximum(np.max(FV, axis=1, keepdims=True), eps)
+                FV = FV / max_per_f
+        
+        try:
 
             # Apply frequency and velocity limits (clamp to Nyquist for safety)
             fmin = getattr(self, 'fmin', None)
@@ -17944,9 +18683,57 @@ class MainWindow(QMainWindow):
             vs = vs[vmask]
             FV = FV[:, vmask]
 
+            # Apply display enhancement transformations
+            FV_display = FV.copy()
+            
+            # Apply enhancement transformation if enabled
+            # IMPORTANT: Work on raw unnormalized data for proper dynamic range
+            if getattr(self, 'dispersion_enhance', False):
+                # Use raw data for enhancement to avoid issues with normalized [0,1] range
+                FV_for_enhance = FV_raw.copy()
+                
+                # Apply enhancement formula: 1/(max-x) to amplify weak modes
+                max_val = np.max(FV_for_enhance)
+                epsilon = max_val * 0.01  # 1% of max to prevent division by zero
+                FV_display = 1.0 / (max_val - FV_for_enhance + epsilon)
+                
+                # Normalize to [0, 1] range
+                vmin, vmax = np.min(FV_display), np.max(FV_display)
+                if vmax > vmin:
+                    FV_display = (FV_display - vmin) / (vmax - vmin)
+                else:
+                    FV_display = np.zeros_like(FV_display)
+
             # Create image item with colormap (rotated: freq on x-axis, velocity on y-axis)
             colormap = getattr(self, 'dispersion_colormap_str', 'plasma')
-            image_item = createImageItem(FV.T, fs, vs, colormap=colormap)
+            image_item = createImageItem(FV_display.T, fs, vs, colormap=colormap)
+
+            # Apply MATLAB-like brighten to the colormap instead of data (beta in [-1,1])
+            saturation_factor = getattr(self, 'dispersion_saturation', 1.0)
+            beta = (saturation_factor - 1.0) / 0.5  # 1.0->0, 0.5->-1 (darken), 1.5->+1 (brighten)
+            beta = max(-1.0, min(1.0, beta))
+            if abs(beta) > 1e-6:
+                try:
+                    cmap_obj = image_item.getColorMap()
+                    if cmap_obj is None:
+                        cmap_obj = pqg.colormap.get(colormap, source='matplotlib')
+                    if cmap_obj is not None:
+                        lut = cmap_obj.getLookupTable(nPts=256, alpha=True)
+                        lut = lut.astype(float)
+                        if lut.max() > 1.0:
+                            lut = lut / 255.0
+                        tol = np.sqrt(np.finfo(float).eps)
+                        if beta > 0:
+                            gamma = 1.0 - min(1.0 - tol, beta)
+                        else:
+                            gamma = 1.0 / (1.0 + max(-1.0 + tol, beta))
+                        lut[:, :3] = np.clip(np.power(lut[:, :3], gamma), 0.0, 1.0)
+                        lut_out = (lut * 255).astype(np.ubyte)
+                        positions = np.linspace(0.0, 1.0, lut_out.shape[0])
+                        bright_cmap = pqg.ColorMap(positions, lut_out)
+                        image_item.setColorMap(bright_cmap)
+                except Exception:
+                    pass
 
             # Store image data and coordinates for amplitude lookup
             self.dispersionImageData = FV.T
@@ -18009,11 +18796,18 @@ class MainWindow(QMainWindow):
                 pass
             plot_widget.scene().sigMouseClicked.connect(lambda ev: self.onDispersionClick(ev, view_key))
             
+            # Add aliasing limit curve if enabled
+            if getattr(self, 'dispersion_show_aliasing_limit', False):
+                self._plotAliasingLimit(plot_widget, fs, vs)  # Spatial aliasing (below surface-wave energy)
+            
             # Update error bars if show errors is enabled
             self._updateDispersionErrorBars(view_key)
             
             # Update interpolated error lines if show interpolated errors is enabled
             self._updateDispersionInterpErrors(view_key)
+            
+            # Update status bar with dispersion window info and stacking info
+            self.updateDispersionWindowInfo()
 
         except ValueError as e:
             QMessageBox.warning(self, "Phase-Shift Error", 
@@ -18022,6 +18816,44 @@ class MainWindow(QMainWindow):
             QMessageBox.warning(self, "Computation Error", 
                               f"An error occurred:\n{str(e)}")
 
+    def _plotAliasingLimit(self, plot_widget, frequencies, velocities):
+        """Plot the spatial aliasing limits on the dispersion image.
+        
+        Energy below surface-wave caused by spatial undersampling.
+        
+        Spatial aliasing occurs when wavelength < 2*dx
+        Phase velocity v = f*lambda, so aliasing when v < f*2*dx
+        First-order aliasing boundary: v_alias = 2 * f * dx
+        """
+        try:
+            # Get trace spacing for the current shot
+            if not (self.trace_position and self.currentIndex < len(self.trace_position)):
+                return
+            
+            trace_pos = self.trace_position[self.currentIndex]
+            if len(trace_pos) < 2:
+                return
+            
+            # Calculate mean trace spacing
+            dx = np.mean(np.abs(np.diff(trace_pos)))
+            if dx <= 0:
+                return
+            
+            f_array = np.array(frequencies)
+            v_max = np.max(velocities)
+            v_min = np.min(velocities)
+            
+            # Plot first-order aliasing band only (wavelength < 2*dx)
+            v_alias_boundary = 2.0 * f_array * dx
+            v_alias_boundary = np.clip(v_alias_boundary, v_min, v_max)
+            pen = pqg.mkPen(color=(255, 0, 0, 200), width=2, style=Qt.DashLine)
+            curve = pqg.PlotCurveItem(f_array, v_alias_boundary, pen=pen)
+            plot_widget.addItem(curve)
+            
+        except Exception as e:
+            # Silently skip if aliasing limit cannot be computed
+            pass
+
     def plotPseudoSection(self):
         """Plot pseudo-section: phase velocity as 2D image (xmid vs frequency/wavelength)"""
         plot_widget, viewbox = self._getBottomPlotWidgets()
@@ -18033,24 +18865,82 @@ class MainWindow(QMainWindow):
         self._safelyclearPlot(plot_widget)
         self.removeLegend()
         self.removeColorBar()
+
+        # Update status bar with current FFID and source info so it stays fresh when pseudo-section is active
+        if self.currentIndex is not None:
+            try:
+                ffid_val = self.ffid[self.currentIndex] if hasattr(self, 'ffid') and self.ffid else 'N/A'
+                src_val = self.source_position[self.currentIndex] if self.source_position else 'N/A'
+                self.ffidLabel.setText(f'FFID: {ffid_val} | Source at {src_val} m')
+            except Exception:
+                pass
         
         # Collect all shots with dispersion picks
-        xmid_list = []  # list of (shot_idx, xmid)
+        xcoord_list = []  # list of (shot_idx, x_coord)
         shot_freqs = []  # list of frequency arrays per shot
         shot_vels = []   # list of velocity arrays per shot
         
         use_wavelength = getattr(self, 'pseudosection_use_wavelength', False)
         show_interp = getattr(self, 'pseudosection_show_interpolated', False)
         selected_mode = getattr(self, 'pseudosection_mode', 0)
+        use_source_x = getattr(self, 'pseudosection_use_source_x', False)
         
         for shot_idx, shot_curves in enumerate(self.dispersion_curves):
             if shot_curves is None or 'modes' not in shot_curves:
                 continue
             
-            # Get xmid for this shot
-            if shot_idx not in self.xmid_values:
-                continue
-            xmid = self.xmid_values[shot_idx]
+            # Determine X coordinate for this shot
+            if use_source_x:
+                x_coord = None
+                # Check plotTypeY to determine whether to use FFID or source position
+                plot_type_y = getattr(self, 'plotTypeY', 'source_position')
+                if plot_type_y == 'ffid' and hasattr(self, 'ffid') and shot_idx < len(self.ffid):
+                    # Use FFID
+                    try:
+                        x_coord = float(self.ffid[shot_idx])
+                    except Exception:
+                        x_coord = None
+                elif shot_idx < len(self.source_position):
+                    # Use source position
+                    x_coord = self.source_position[shot_idx]
+                elif hasattr(self, 'ffid') and shot_idx < len(self.ffid):
+                    # Fallback to FFID if source position not available
+                    try:
+                        x_coord = float(self.ffid[shot_idx])
+                    except Exception:
+                        x_coord = None
+                if x_coord is None and shot_idx in getattr(self, 'xmid_values', {}):
+                    x_coord = self.xmid_values[shot_idx]
+            else:
+                if shot_idx not in self.xmid_values:
+                    continue
+                xmid_pos = self.xmid_values[shot_idx]  # Window center position in meters
+                
+                # Determine if we're using trace numbers or positions
+                plot_type_x = getattr(self, 'plotTypeX', 'trace_position')
+                if plot_type_x == 'trace_position':
+                    # Use window center position directly
+                    x_coord = xmid_pos
+                else:
+                    # Convert window center position to theoretical trace number
+                    # Interpolate from trace positions to trace numbers for this shot
+                    if shot_idx < len(self.plotTypeDict.get(plot_type_x, [])) and shot_idx < len(self.trace_position):
+                        trace_nums = self.plotTypeDict[plot_type_x][shot_idx]
+                        trace_positions = self.trace_position[shot_idx]
+                        if len(trace_nums) > 0 and len(trace_positions) > 0:
+                            # Interpolate to find trace number at window center position
+                            from scipy.interpolate import interp1d
+                            try:
+                                f = interp1d(trace_positions, trace_nums, kind='linear', 
+                                           bounds_error=False, fill_value='extrapolate')
+                                x_coord = float(f(xmid_pos))
+                            except Exception:
+                                # Fallback to position if interpolation fails
+                                x_coord = xmid_pos
+                        else:
+                            x_coord = xmid_pos
+                    else:
+                        x_coord = xmid_pos
             
             # Collect selected mode picks
             if selected_mode not in shot_curves['modes']:
@@ -18071,22 +18961,33 @@ class MainWindow(QMainWindow):
                 freqs = np.array([p[0] for p in points])
                 vels = np.array([p[1] for p in points])
             
-            if freqs is not None and len(freqs) > 0:
-                xmid_list.append((shot_idx, xmid))
+            if freqs is not None and len(freqs) > 0 and x_coord is not None:
+                xcoord_list.append((shot_idx, x_coord))
                 shot_freqs.append(freqs)
                 shot_vels.append(vels)
         
-        if not xmid_list:
+        if not xcoord_list:
+            # Set labels even when no data - use same logic as main plotting
+            if use_source_x:
+                x_label = getattr(self, 'y_label', 'Source Position (m)')
+            else:
+                plot_type_x = getattr(self, 'plotTypeX', 'trace_position')
+                if plot_type_x == 'trace_position':
+                    x_label = 'Window center (m)'
+                else:
+                    # Trace number modes
+                    x_label = 'Window center (trace no)'
             plot_widget.setLabel('left', 'Frequency (Hz)' if not use_wavelength else 'Wavelength (m)')
-            plot_widget.setLabel('bottom', 'Position (m)')
+            plot_widget.setLabel('top', x_label)
+            plot_widget.setLabel('bottom', '')
             return
         
-        # Sort by xmid
-        sorted_idx = np.argsort([x[1] for x in xmid_list])
-        xmid_list = [xmid_list[i] for i in sorted_idx]
+        # Sort by X coordinate
+        sorted_idx = np.argsort([x[1] for x in xcoord_list])
+        xcoord_list = [xcoord_list[i] for i in sorted_idx]
         shot_freqs = [shot_freqs[i] for i in sorted_idx]
         shot_vels = [shot_vels[i] for i in sorted_idx]
-        xmids = np.array([x[1] for x in xmid_list])
+        xcoords = np.array([x[1] for x in xcoord_list])
         
         # Create 2D grid: freq/λ vs xmid
         # For simplicity, create a scatter plot with colormap encoding velocity
@@ -18095,9 +18996,9 @@ class MainWindow(QMainWindow):
         plot_data_vel = []
         
         for i, (freqs, vels) in enumerate(zip(shot_freqs, shot_vels)):
-            xmid = xmids[i]
+            x_val = xcoords[i]
             for freq, vel in zip(freqs, vels):
-                plot_data_x.append(xmid)
+                plot_data_x.append(x_val)
                 if use_wavelength:
                     # λ = v / f
                     wavelength = vel / freq if freq > 0 else 0
@@ -18133,33 +19034,99 @@ class MainWindow(QMainWindow):
                                       size=6, pen=None, brush=brush_list)
         plot_widget.addItem(scatter)
         
-        # Add vertical red lines around the current shot's xmid
-        if self.currentIndex is not None and self.currentIndex in self.xmid_values:
-            current_xmid = self.xmid_values[self.currentIndex]
-            
-            # Calculate mean spacing between shots
-            if len(xmids) > 1:
-                mean_dxmid = np.mean(np.abs(np.diff(xmids)))
-            else:
-                mean_dxmid = self.mean_dg  # fallback to trace spacing
-            
-            # Y-axis range for the vertical lines
-            y_min_line, y_max_line = plot_data_y.min(), plot_data_y.max()
-            
-            # Draw two vertical lines at xmid ± mean_dxmid/2
-            x_line_1 = current_xmid - mean_dxmid/2
-            x_line_2 = current_xmid + mean_dxmid/2
-            y_line = [y_min_line, y_max_line]
-            
-            line1 = pqg.PlotDataItem([x_line_1, x_line_1], y_line, pen=pqg.mkPen('r', width=2))
-            line2 = pqg.PlotDataItem([x_line_2, x_line_2], y_line, pen=pqg.mkPen('r', width=2))
-            plot_widget.addItem(line1)
-            plot_widget.addItem(line2)
+        # Add vertical red lines around the current shot's x position
+        if self.currentIndex is not None:
+            current_x = None
+            if use_source_x:
+                # Match the x-axis choice: use FFID when plotTypeY is ffid, else source position
+                plot_type_y = getattr(self, 'plotTypeY', 'source_position')
+                if plot_type_y == 'ffid' and hasattr(self, 'ffid') and self.currentIndex < len(self.ffid):
+                    try:
+                        current_x = float(self.ffid[self.currentIndex])
+                    except Exception:
+                        current_x = None
+                elif self.currentIndex < len(self.source_position):
+                    current_x = self.source_position[self.currentIndex]
+                elif hasattr(self, 'ffid') and self.currentIndex < len(self.ffid):
+                    try:
+                        current_x = float(self.ffid[self.currentIndex])
+                    except Exception:
+                        current_x = None
+                if current_x is None and self.currentIndex in getattr(self, 'xmid_values', {}):
+                    current_x = self.xmid_values[self.currentIndex]
+            elif self.currentIndex in self.xmid_values:
+                # Use window center - convert to trace number if needed
+                xmid_pos = self.xmid_values[self.currentIndex]
+                plot_type_x = getattr(self, 'plotTypeX', 'trace_position')
+                if plot_type_x == 'trace_position':
+                    current_x = xmid_pos
+                else:
+                    # Convert window center position to theoretical trace number
+                    if self.currentIndex < len(self.plotTypeDict.get(plot_type_x, [])) and self.currentIndex < len(self.trace_position):
+                        trace_nums = self.plotTypeDict[plot_type_x][self.currentIndex]
+                        trace_positions = self.trace_position[self.currentIndex]
+                        if len(trace_nums) > 0 and len(trace_positions) > 0:
+                            from scipy.interpolate import interp1d
+                            try:
+                                f = interp1d(trace_positions, trace_nums, kind='linear', 
+                                           bounds_error=False, fill_value='extrapolate')
+                                current_x = float(f(xmid_pos))
+                            except Exception:
+                                current_x = xmid_pos
+                        else:
+                            current_x = xmid_pos
+                    else:
+                        current_x = xmid_pos
+            
+            if current_x is not None:
+                # Calculate spacing between guide lines based on axis mode
+                if use_source_x:
+                    plot_type_y = getattr(self, 'plotTypeY', 'source_position')
+                    # Use 1 for FFID mode, otherwise calculate from actual source spacing
+                    if plot_type_y == 'ffid':
+                        mean_dx = 1.0
+                    elif plot_type_y == 'source_position' and len(self.source_position) > 1:
+                        # Use actual spacing between all source positions from the data
+                        mean_dx = np.mean(np.abs(np.diff(self.source_position)))
+                    else:
+                        mean_dx = getattr(self, 'mean_dg', 1.0)
+                else:
+                    plot_type_x = getattr(self, 'plotTypeX', 'trace_position')
+                    # Use mean_dg for trace positions, 1 for trace number/ffid modes
+                    # Don't refine - window centers (xmid) can overlap between shots
+                    mean_dx = getattr(self, 'mean_dg', 1.0) if plot_type_x == 'trace_position' else 1.0
+                
+                # Y-axis range for the vertical lines
+                y_min_line, y_max_line = plot_data_y.min(), plot_data_y.max()
+                
+                # Draw two vertical lines at x ± mean_dx/2
+                x_line_1 = current_x - mean_dx/2
+                x_line_2 = current_x + mean_dx/2
+                y_line = [y_min_line, y_max_line]
+                
+                line1 = pqg.PlotDataItem([x_line_1, x_line_1], y_line, pen=pqg.mkPen('r', width=2))
+                line2 = pqg.PlotDataItem([x_line_2, x_line_2], y_line, pen=pqg.mkPen('r', width=2))
+                plot_widget.addItem(line1)
+                plot_widget.addItem(line2)
         
         # Set axis labels
         y_label = 'Wavelength (m)' if use_wavelength else 'Frequency (Hz)'
+        # Determine X-axis label based on checkbox and current plot type
+        if use_source_x:
+            # Use the same label as layout view's Y-axis (depends on plotTypeY)
+            x_label = getattr(self, 'y_label', 'Source Position (m)')
+        else:
+            # When not using source position, we're using window centers (xmid)
+            plot_type_x = getattr(self, 'plotTypeX', 'trace_position')
+            if plot_type_x == 'trace_position':
+                # Window center as position in meters
+                x_label = 'Window center (m)'
+            else:
+                # Window center as theoretical trace number
+                x_label = 'Window center (trace no)'
         plot_widget.setLabel('left', y_label)
-        plot_widget.setLabel('bottom', 'Position (m)')
+        plot_widget.setLabel('top', x_label)
+        plot_widget.setLabel('bottom', '')
 
         # Create colormap and colorbar (mirror layout view behavior)
         try:
@@ -18177,43 +19144,72 @@ class MainWindow(QMainWindow):
         plot_widget.plotItem.layout.addItem(self.colorbar_title_label, 2, 6)
 
         plot_widget.showAxis('left')
-        plot_widget.showAxis('bottom')
         plot_widget.showAxis('top')
         plot_widget.showAxis('right')
+        plot_widget.showAxis('bottom')
         plot_widget.getAxis('right').setStyle(showValues=False)
+        plot_widget.getAxis('bottom').setLabel('')
+        plot_widget.getAxis('top').setStyle(showValues=True)
         
         # Apply Y-axis invert setting
         invert_y = getattr(self, 'pseudosection_invert_y', True)
         viewbox.invertY(invert_y)
         
-        # Set limits - use same x-axis range as layout view for consistency
+        # Set limits
         if len(plot_data_x) > 0:
-            # Get layout view x-axis range (all trace positions across all shots)
-            self.updatePlotTypeDict()
-            plot_data_x_layout = self.plotTypeDict.get(self.plotTypeX, [])
-            flat_plot_data_x = [item for sublist in plot_data_x_layout for item in sublist]
-            traces = [trace for trace in flat_plot_data_x if trace is not None]
-            
             # Y-axis uses data from pseudo-section
             y_min, y_max = plot_data_y.min(), plot_data_y.max()
             y_margin = (y_max - y_min) * 0.05 if y_max > y_min else 1.0
             
-            # X-axis matches layout view range
-            if traces:
-                x_min_layout = min(traces) - self.mean_dg
-                x_max_layout = max(traces) + self.mean_dg
-                viewbox.setLimits(xMin=x_min_layout, xMax=x_max_layout,
-                                yMin=y_min-y_margin, yMax=y_max+y_margin)
-                viewbox.setXRange(x_min_layout, x_max_layout, padding=0)
-                viewbox.setYRange(y_min-y_margin, y_max+y_margin, padding=0)
-            else:
-                # Fallback to data-based range if layout info unavailable
-                x_min, x_max = plot_data_x.min(), plot_data_x.max()
+            # X-axis range depends on checkbox state
+            if use_source_x:
+                # Use full range of source position / FFID coordinates (all shots, not just those with picks)
+                plot_type_y = getattr(self, 'plotTypeY', 'source_position')
+                if plot_type_y == 'ffid' and hasattr(self, 'ffid') and self.ffid:
+                    # Use FFID range
+                    try:
+                        ffid_values = [float(f) for f in self.ffid if f is not None]
+                        if ffid_values:
+                            x_min, x_max = min(ffid_values), max(ffid_values)
+                        else:
+                            x_min, x_max = xcoords.min(), xcoords.max()
+                    except (ValueError, TypeError):
+                        x_min, x_max = xcoords.min(), xcoords.max()
+                elif self.source_position:
+                    # Use source position range
+                    x_min, x_max = min(self.source_position), max(self.source_position)
+                else:
+                    # Fallback to picked shots only
+                    x_min, x_max = xcoords.min(), xcoords.max()
+                
                 x_margin = (x_max - x_min) * 0.05 if x_max > x_min else 1.0
                 viewbox.setLimits(xMin=x_min-x_margin, xMax=x_max+x_margin,
                                 yMin=y_min-y_margin, yMax=y_max+y_margin)
                 viewbox.setXRange(x_min-x_margin, x_max+x_margin, padding=0)
                 viewbox.setYRange(y_min-y_margin, y_max+y_margin, padding=0)
+            else:
+                # X-axis matches layout view range (window centers based on plotTypeX)
+                self.updatePlotTypeDict()
+                plot_data_x_layout = self.plotTypeDict.get(self.plotTypeX, [])
+                flat_plot_data_x = [item for sublist in plot_data_x_layout for item in sublist]
+                traces = [trace for trace in flat_plot_data_x if trace is not None]
+                
+                if traces:
+                    x_min_layout = min(traces) - self.mean_dg
+                    x_max_layout = max(traces) + self.mean_dg
+                    viewbox.setLimits(xMin=x_min_layout, xMax=x_max_layout,
+                                    yMin=y_min-y_margin, yMax=y_max+y_margin)
+                    viewbox.setXRange(x_min_layout, x_max_layout, padding=0)
+                    viewbox.setYRange(y_min-y_margin, y_max+y_margin, padding=0)
+                else:
+                    # Fallback to data-based range if layout info unavailable
+                    x_min, x_max = plot_data_x.min(), plot_data_x.max()
+                    x_margin = (x_max - x_min) * 0.05 if x_max > x_min else 1.0
+                    viewbox.setLimits(xMin=x_min-x_margin, xMax=x_max+x_margin,
+                                    yMin=y_min-y_margin, yMax=y_max+y_margin)
+                    viewbox.setXRange(x_min-x_margin, x_max+x_margin, padding=0)
+                    viewbox.setYRange(y_min-y_margin, y_max+y_margin, padding=0)
+
 
     def onPseudoSectionFreqLambdaToggled(self, state):
         """Toggle between frequency and wavelength display"""
@@ -18235,6 +19231,51 @@ class MainWindow(QMainWindow):
     def onPseudoSectionInterpToggled(self, state):
         """Toggle between picked and interpolated curve display"""
         self.pseudosection_show_interpolated = bool(state)
+        
+        # Synchronize with dispersion view interpolate checkbox
+        if hasattr(self, 'dispersionLiveInterpolateCheckbox'):
+            self.dispersionLiveInterpolateCheckbox.blockSignals(True)
+            self.dispersionLiveInterpolateCheckbox.setChecked(bool(state))
+            self.dispersionLiveInterpolateCheckbox.blockSignals(False)
+        
+        # If enabling interpolation, interpolate all shots for pseudo-section
+        if bool(state):
+            self._interpolateAllShotsForPseudoSection()
+            
+            # Also trigger dispersion interpolation for active view
+            view = self._get_active_dispersion_view()
+            if view:
+                if self.dispersionShowAllModesCheckbox.isChecked():
+                    self.interpolateAllDispersionCurves(view)
+                else:
+                    mode_data = self._get_current_mode_data(view)
+                    if len(mode_data['picked_points']) >= 2:
+                        self.interpolateDispersionCurve(view)
+        else:
+            # Remove interpolated curves from dispersion view when disabling
+            view = self._get_active_dispersion_view()
+            if view:
+                plot_widget = self.plotWidget if view == 'top' else self.bottomPlotWidget
+                state_dict = self.dispersion_picking_state[view]
+                
+                for mode_num, mode_data in state_dict['modes'].items():
+                    if mode_data['curve_line'] is not None:
+                        try:
+                            plot_widget.removeItem(mode_data['curve_line'])
+                        except:
+                            pass
+                        mode_data['curve_line'] = None
+                    if mode_data['interp_error_fill'] is not None:
+                        try:
+                            items = mode_data['interp_error_fill'] if isinstance(mode_data['interp_error_fill'], list) else [mode_data['interp_error_fill']]
+                            for item in items:
+                                if item is not None:
+                                    plot_widget.removeItem(item)
+                        except:
+                            pass
+                        mode_data['interp_error_fill'] = None
+                    mode_data['curve_data'] = None
+        
         # Replot whichever view is showing pseudo-section
         if getattr(self, 'bottomPlotType', None) == "pseudosection":
             self._plot_target_widget = self.bottomPlotWidget
@@ -18283,6 +19324,89 @@ class MainWindow(QMainWindow):
             self._plot_target_widget = None
             self._plot_target_viewbox = None
 
+    def onPseudoSectionUseSourceXToggled(self, state):
+        """Toggle use of source position/FFID for pseudo-section X-axis"""
+        self.pseudosection_use_source_x = bool(state)
+        if getattr(self, 'bottomPlotType', None) == "pseudosection":
+            self._plot_target_widget = self.bottomPlotWidget
+            self._plot_target_viewbox = self.bottomViewBox
+            self.plotPseudoSection()
+            self._plot_target_widget = None
+            self._plot_target_viewbox = None
+        if getattr(self, 'topPlotType', None) == "pseudosection":
+            self._plot_target_widget = self.plotWidget
+            self._plot_target_viewbox = self.viewBox
+            self.plotPseudoSection()
+            self._plot_target_widget = None
+            self._plot_target_viewbox = None
+    
+    def _interpolateAllShotsForPseudoSection(self):
+        """Interpolate dispersion curves for all shots that have picks.
+        This is used when toggling interpolation in pseudo-section view."""
+        if not self.dispersion_curves:
+            return
+        
+        # Get interpolation method from combo box
+        method_text = self.dispersionInterpMethodCombo.currentText()
+        min_points_required = {
+            "Linear": 2,
+            "Quadratic": 3,
+            "Cubic": 4,
+            "Spline": 4
+        }
+        min_points = min_points_required.get(method_text, 2)
+        
+        # Process each shot
+        for shot_idx, shot_curves in enumerate(self.dispersion_curves):
+            if shot_curves is None or 'modes' not in shot_curves:
+                continue
+            
+            # Process each mode in this shot
+            for mode_num, mode_data in shot_curves['modes'].items():
+                if 'picked_points' not in mode_data or len(mode_data['picked_points']) < min_points:
+                    continue
+                
+                try:
+                    # Sort points by frequency
+                    sorted_points = sorted(mode_data['picked_points'])
+                    frequencies = np.array([p[0] for p in sorted_points])
+                    velocities = np.array([p[1] for p in sorted_points])
+                    
+                    # Create interpolated curve
+                    freq_min, freq_max = frequencies[0], frequencies[-1]
+                    # Use a reasonable frequency step (10 Hz or 1/100th of range)
+                    freq_range = freq_max - freq_min
+                    freq_step = min(10.0, freq_range / 100.0) if freq_range > 0 else 1.0
+                    interp_frequencies = np.arange(freq_min, freq_max + freq_step/2, freq_step/2)
+                    
+                    method_map = {
+                        "Cubic": "cubic",
+                        "Linear": "linear",
+                        "Quadratic": "quadratic",
+                        "Spline": "cubic"
+                    }
+                    kind = method_map.get(method_text, "cubic")
+                    
+                    # Interpolate using selected method
+                    from scipy.interpolate import interp1d, UnivariateSpline
+                    
+                    if method_text == "Spline":
+                        spline = UnivariateSpline(frequencies, velocities, s=len(frequencies)*0.1, k=3)
+                        interp_velocities = spline(interp_frequencies)
+                    else:
+                        interp_func = interp1d(frequencies, velocities, kind=kind,
+                                             bounds_error=False, fill_value='extrapolate')
+                        interp_velocities = interp_func(interp_frequencies)
+                    
+                    # Store interpolated curve in dispersion_curves
+                    mode_data['frequencies'] = interp_frequencies.tolist()
+                    mode_data['velocities'] = interp_velocities.tolist()
+                    mode_data['interpolated'] = True
+                    
+                except Exception:
+                    # Skip this mode if interpolation fails
+                    continue
+
     #######################################
     # Topo functions
     #######################################
@@ -18640,7 +19764,7 @@ class MainWindow(QMainWindow):
     def handleFreehandPick(self, drag_path, view="top"):
         """
         Called when a Ctrl+left mouse drag finishes (freehand pick).
-        Adds picks along the drag path.
+        Adds picks along the drag path - picks ALL crossed traces (like dispersion).
         
         Args:
             drag_path: List of points from the drag operation
@@ -18668,20 +19792,75 @@ class MainWindow(QMainWindow):
         else:
             viewBox = self.viewBox
         
-        trace_indices = []
+        # Convert drag path to view coordinates
+        path_coords = []
         for pt in drag_path:
             mousePoint = viewBox.mapSceneToView(pt)
-            x = mousePoint.x()
-            y = mousePoint.y()
+            path_coords.append((mousePoint.x(), mousePoint.y()))
+        
+        if len(path_coords) < 2:
+            return
+        
+        # Get trace position range covered by the drag
+        x_positions = [coord[0] for coord in path_coords]
+        min_x = min(x_positions)
+        max_x = max(x_positions)
+        
+        # Get all trace positions for current file
+        plot_data_x = self.plotTypeDict.get(self.plotTypeX, [])
+        if not plot_data_x or self.currentIndex >= len(plot_data_x):
+            return
+        
+        trace_positions = np.array(plot_data_x[self.currentIndex])
+        
+        # Find all traces that fall within the crossed range
+        trace_mask = (trace_positions >= min_x) & (trace_positions <= max_x)
+        crossed_trace_indices = np.where(trace_mask)[0]
+        
+        if len(crossed_trace_indices) == 0:
+            return
+        
+        # Sort path once for interpolation
+        sorted_path = sorted(path_coords, key=lambda c: c[0])
+        
+        # Map trace_idx -> time (dedup per trace index)
+        trace_to_time = {}
+        for trace_idx in crossed_trace_indices:
+            trace_x = trace_positions[trace_idx]
             
-            # Store trace index
-            plot_data_x = self.plotTypeDict.get(self.plotTypeX, [])
-            x_distance = np.array(plot_data_x[self.currentIndex]) - x
-            trace_idx = np.argmin(np.abs(x_distance))
-            trace_indices.append(trace_idx)
+            # Find time at this trace by linear interpolation through drag path
+            time_value = None
+            for i in range(len(sorted_path) - 1):
+                x1, t1 = sorted_path[i]
+                x2, t2 = sorted_path[i + 1]
+                
+                if x1 <= trace_x <= x2:
+                    # Linear interpolation
+                    if x2 != x1:
+                        s = (trace_x - x1) / (x2 - x1)
+                        time_value = t1 + s * (t2 - t1)
+                    else:
+                        time_value = t1
+                    break
             
-            # Add pick at coordinates
-            self._add_pick_at(x, y)
+            # If trace is outside the path range, use nearest endpoint
+            if time_value is None:
+                if trace_x < sorted_path[0][0]:
+                    time_value = sorted_path[0][1]
+                else:
+                    time_value = sorted_path[-1][1]
+            
+            trace_to_time[trace_idx] = time_value
+        
+        # Add picks for all crossed traces
+        picked_traces = []
+        for trace_idx in sorted(trace_to_time.keys()):
+            time_value = trace_to_time[trace_idx]
+            trace_x = trace_positions[trace_idx]
+            
+            # Add pick at this trace/time
+            self._add_pick_at(trace_x, time_value)
+            picked_traces.append(trace_idx)
         
         self.update_pick_flag = True
         self.picks_modified = True  # Mark picks as modified
@@ -18690,25 +19869,25 @@ class MainWindow(QMainWindow):
         if view == "bottom":
             # Picking in bottom seismogram - update bottom
             self._plot_target_widget = self.bottomPlotWidget
-            for trace_idx in trace_indices:
+            for trace_idx in picked_traces:
                 self._update_seismo_pick_display(trace_idx)
             self._plot_target_widget = None
             # Also update top seismogram if it's showing one
             if self.topPlotType == "seismogram":
                 self._plot_target_widget = self.plotWidget
-                for trace_idx in trace_indices:
+                for trace_idx in picked_traces:
                     self._update_seismo_pick_display(trace_idx)
                 self._plot_target_widget = None
         else:  # view == "top"
             # Picking in top seismogram - update top
             self._plot_target_widget = self.plotWidget
-            for trace_idx in trace_indices:
+            for trace_idx in picked_traces:
                 self._update_seismo_pick_display(trace_idx)
             self._plot_target_widget = None
             # Also update bottom seismogram if it's showing one
             if self.bottomPlotType == "seismogram":
                 self._plot_target_widget = self.bottomPlotWidget
-                for trace_idx in trace_indices:
+                for trace_idx in picked_traces:
                     self._update_seismo_pick_display(trace_idx)
                 self._plot_target_widget = None
         
@@ -19240,7 +20419,8 @@ class MainWindow(QMainWindow):
                 self.source_position,
                 self.source_elevation,
                 self.picks,
-                self.error
+                self.error,
+                geophone_mapping=self.geophone_mapping
             )
             
             self.picks_modified = False  # Reset flag after successful save
@@ -19290,6 +20470,7 @@ class MainWindow(QMainWindow):
             matched_sgt_picks: set of (source_index, geophone_index) tuples that have been matched
         Returns tuple: (number of picks matched, number of sources with picks, max pick time)
         """
+        
         picks_matched = 0
         skipped_already_assigned = 0
         skipped_no_trace_found = 0
@@ -19305,7 +20486,7 @@ class MainWindow(QMainWindow):
         plot_data_x = self.plotTypeDict.get(self.plotTypeX, [])
         
         # Create progress dialog for alternative matching
-        mode_label = {"exact_x": "Exact X", "nearest_x": "Nearest X", "nearest_xz": "Nearest XZ"}
+        mode_label = {"exact_x": "Exact X", "nearest_x": "Nearest X", "nearest_xz": "Nearest XZ", "match_order": "Order Matching"}
         progress = QProgressDialog(f"Alternative matching ({mode_label.get(matching_mode, matching_mode)})...", "Cancel", 0, len(self.fileNames), self)
         progress.setWindowTitle("Alternative Pick Matching")
         progress.setMinimumDuration(0)
@@ -19314,7 +20495,81 @@ class MainWindow(QMainWindow):
         progress.show()
         QApplication.processEvents()
         
-        # Loop over all shots/sources
+        # For order-based matching, create mappings from actual data and SGT data
+        source_order_map = None
+        trace_order_maps = None
+        
+        if matching_mode == "match_order":
+            # Get all unique positions from headers (sources + traces)
+            unique_header_positions = set()
+            
+            for i in range(len(self.fileNames)):
+                if self.source_position[i] is not None:
+                    unique_header_positions.add(self.source_position[i])
+            
+            for shot_idx in range(len(self.fileNames)):
+                if self.trace_position[shot_idx] is not None:
+                    for trace_pos in self.trace_position[shot_idx]:
+                        unique_header_positions.add(trace_pos)
+            
+            sorted_header_positions = sorted(list(unique_header_positions))
+            
+            # Get all station positions from SGT file
+            sgt_station_positions = []
+            for idx, sgt_station in enumerate(uploaded_stations):
+                sgt_x = sgt_station[0]
+                sgt_station_positions.append((sgt_x, idx + 1))
+            
+            sgt_station_positions.sort(key=lambda x: x[0])
+            sorted_sgt_positions = [pos[0] for pos in sgt_station_positions]
+            
+            # Create position-to-index mapping for headers
+            header_pos_map = {}
+            
+            for shot_idx in range(len(self.fileNames)):
+                if self.source_position[shot_idx] is not None:
+                    pos = self.source_position[shot_idx]
+                    if pos not in header_pos_map:
+                        header_pos_map[pos] = {'sources': [], 'traces': []}
+                    header_pos_map[pos]['sources'].append(shot_idx)
+            
+            for shot_idx in range(len(self.fileNames)):
+                if self.trace_position[shot_idx] is not None:
+                    for trace_idx, trace_pos in enumerate(self.trace_position[shot_idx]):
+                        if trace_pos not in header_pos_map:
+                            header_pos_map[trace_pos] = {'sources': [], 'traces': []}
+                        header_pos_map[trace_pos]['traces'].append((shot_idx, trace_idx))
+            
+            # Create position-to-station-index mapping for SGT
+            sgt_pos_to_stations = {}
+            for sgt_x, station_idx_1based in sgt_station_positions:
+                if sgt_x not in sgt_pos_to_stations:
+                    sgt_pos_to_stations[sgt_x] = []
+                sgt_pos_to_stations[sgt_x].append(station_idx_1based)
+            
+            # Match positions by sorted order
+            source_order_map = {}
+            trace_order_maps = {i: {} for i in range(len(self.fileNames))}
+            
+            for order_idx in range(min(len(sorted_header_positions), len(sorted_sgt_positions))):
+                header_pos = sorted_header_positions[order_idx]
+                sgt_pos = sorted_sgt_positions[order_idx]
+                
+                header_data = header_pos_map.get(header_pos, {'sources': [], 'traces': []})
+                sgt_stations = sgt_pos_to_stations.get(sgt_pos, [])
+                
+                # Map header sources to first SGT station at this order position
+                if header_data['sources'] and sgt_stations:
+                    for shot_idx in header_data['sources']:
+                        source_order_map[shot_idx] = sgt_stations[0]
+                
+                # Map header traces to SGT station(s) at this order position
+                if header_data['traces'] and sgt_stations:
+                    for shot_idx, trace_idx in header_data['traces']:
+                        if shot_idx not in trace_order_maps:
+                            trace_order_maps[shot_idx] = {}
+                        trace_order_maps[shot_idx][trace_idx] = sgt_stations[0]
+        
         for i in range(len(self.fileNames)):
             # Update progress
             progress.setValue(i)
@@ -19332,7 +20587,11 @@ class MainWindow(QMainWindow):
             # Find matching source in SGT file based on mode
             source_index_in_sgt = None
             
-            if matching_mode == "exact_x":
+            if matching_mode == "match_order":
+                # Match by order - use the pre-computed mapping
+                if source_order_map is not None and i in source_order_map:
+                    source_index_in_sgt = source_order_map[i]
+            elif matching_mode == "exact_x":
                 # Exact match by X only
                 min_source_x_dist = float('inf')
                 best_sgt_idx = None
@@ -19408,7 +20667,16 @@ class MainWindow(QMainWindow):
                     # Find matching trace based on mode
                     trace_index_in_shot = None
                     
-                    if matching_mode == "exact_x":
+                    if matching_mode == "match_order":
+                        # Match by order - use the pre-computed mapping
+                        # We need to find which trace corresponds to this SGT geophone
+                        if trace_order_maps is not None and i in trace_order_maps:
+                            # reverse lookup: find the header trace index that maps to sgt_geophone_number
+                            for header_trace_idx, sgt_geo_idx in trace_order_maps[i].items():
+                                if sgt_geo_idx == sgt_geophone_number:
+                                    trace_index_in_shot = header_trace_idx
+                                    break
+                    elif matching_mode == "exact_x":
                         # Exact match by X only
                         min_trace_x_dist = float('inf')
                         best_trace_x = None
@@ -19423,12 +20691,7 @@ class MainWindow(QMainWindow):
                             if x_dist <= tol_x:
                                 trace_index_in_shot = trace_idx
                                 break
-                        if trace_index_in_shot is None and verbose:
-                            print(
-                                f"    Trace X-only exact: SGT geophone X={geophone_x:.3f}, Z={(geophone_z if geophone_z is not None else float('nan')):.3f}; "
-                                f"nearest trace X={(best_trace_x if best_trace_x is not None else float('nan')):.3f}, Z={(best_trace_z if best_trace_z is not None else float('nan')):.3f}; "
-                                f"deltaX={min_trace_x_dist:.4f} m (tol={tol_x} m)"
-                            )
+                        pass
                     else:
                         # Nearest neighbor matching
                         min_dist = float('inf')
@@ -19474,11 +20737,19 @@ class MainWindow(QMainWindow):
                         self.picks[i][trace_index_in_shot] = pick_time
                         self.error[i][trace_index_in_shot] = error
                         
+                        # Store geophone mapping for order matching
+                        if matching_mode == "match_order":
+                            if self.geophone_mapping is None:
+                                self.geophone_mapping = {}
+                            self.geophone_mapping[(i, trace_index_in_shot)] = sgt_geophone_number
+                        
                         # Track this SGT pick as successfully matched
                         matched_sgt_picks.add((source_index_in_sgt, sgt_geophone_number))
                         
                         if not was_overwritten:
                             picks_matched += 1
+                            if verbose and matching_mode == "match_order":
+                                print(f"[ORDER MATCHING] ✓ Matched pick: Shot {i}, SGT Source {source_index_in_sgt}, Geophone {sgt_geophone_number} -> Trace {trace_index_in_shot}, Time={pick_time:.4f}s")
                         
                         # Track this source as having picks and update max pick time
                         sources_with_picks.add(i)
@@ -19489,48 +20760,20 @@ class MainWindow(QMainWindow):
                             print(f"    Matched pick: Shot {i+1}, SGT geophone #{sgt_geophone_number} (X={geophone_x:.2f}) -> Trace {trace_index_in_shot}, Time={pick_time:.3f}s")
                     else:
                         skipped_no_trace_found += 1
-                        if verbose:
-                            print(f"    NO MATCH: Shot {i+1}, SGT geophone #{sgt_geophone_number} (X={geophone_x:.2f}) - could not find trace")
-        
-        # Print summary (only when verbose)
-        if verbose:
-            total_attempts = picks_matched + skipped_already_assigned + skipped_no_trace_found
-            print(f"\nMatching summary ({matching_mode}):")
-            print(f"  ✓ Successfully matched: {picks_matched} picks for {len(sources_with_picks)} sources")
-            if skipped_already_assigned > 0:
-                print(f"  ⊗ Skipped (trace already has pick): {skipped_already_assigned}")
-            if skipped_no_trace_found > 0:
-                print(f"  ✗ Skipped (no matching trace found): {skipped_no_trace_found}")
-            if overwritten_count > 0:
-                print(f"  ↻ Overwritten existing picks: {overwritten_count}")
-
-        # Global diagnostics for exact X-only when few or no matches
-        if verbose and matching_mode == "exact_x" and picks_matched == 0:
-            try:
-                sgt_xs = [st[0] for st in uploaded_stations]
-                header_xs = []
-                for arr in self.trace_position:
-                    if arr is not None:
-                        header_xs.extend(list(arr))
-                if len(sgt_xs) > 0 and len(header_xs) > 0:
-                    # Compute nearest header X for each SGT X
-                    import math
-                    nearest_dxs = []
-                    # Use a simple O(N*M) for diagnostics; fast enough for typical sizes
-                    for sx in sgt_xs:
-                        md = min(abs(hx - sx) for hx in header_xs)
-                        nearest_dxs.append(md)
-                    within_tol = sum(1 for d in nearest_dxs if d <= tol_x)
-                    min_dx = min(nearest_dxs)
-                    max_dx = max(nearest_dxs)
-                    med_dx = sorted(nearest_dxs)[len(nearest_dxs)//2]
-                    print("  Exact-X diagnostics across all stations/traces:")
-                    print(f"    Stations: {len(sgt_xs)}, Traces: {len(header_xs)}")
-                    print(f"    Nearest deltaX stats: min={min_dx:.4f} m, median={med_dx:.4f} m, max={max_dx:.4f} m, within_tol({tol_x} m)={within_tol}")
-            except Exception as e:
-                if verbose:
-                    print(f"  Diagnostics error: {e}")
         
+        # Show final summary dialog for order matching
+        if matching_mode == "match_order":
+            summary_text = f"""Order-Based Pick Matching Summary
+
+Source mapping entries: {len(source_order_map) if source_order_map else 0}
+Trace mapping entries: {len(trace_order_maps) if trace_order_maps else 0}
+
+Total SGT picks processed: {len(uploaded_picks)}
+Successfully matched: {picks_matched}
+Failed to match: {skipped_no_trace_found}"""
+            
+            QMessageBox.information(None, "Matching Complete", summary_text)
+
         # Close progress dialog
         progress.setValue(len(self.fileNames))
         progress.close()
@@ -19719,10 +20962,10 @@ class MainWindow(QMainWindow):
                                 if 'err' in best_fields:
                                     err_ind = best_fields.index('err')
                                 if verbose:
-                                    print(f"[DEBUG] Detected pick columns order: {best_fields} -> indices s={s_ind}, g={g_ind}, t={t_ind}, err={err_ind}")
+                                    print(f"Detected pick columns order: {best_fields} -> indices s={s_ind}, g={g_ind}, t={t_ind}, err={err_ind}")
                             except Exception as e:
                                 if verbose:
-                                    print(f"[DEBUG] Failed to apply header order, using defaults. Error: {e}")
+                                    print(f"Failed to apply header order, using defaults. Error: {e}")
 
                     # Read source index, trace index, pick time, pick error
                     uploaded_picks = []
@@ -19766,7 +21009,7 @@ class MainWindow(QMainWindow):
                                 else:
                                     print(f"  s={s_idx:4d}, g={g_idx:4d} -> INVALID geophone index (outside stations list)")
                         except Exception as e:
-                            print(f"[DEBUG] Failed to print SGT geometry/picks: {e}")
+                            pass
 
                 if self.currentFileName is not None:
                     # SGT files can be organized by shot order or by station order
@@ -20062,6 +21305,7 @@ class MainWindow(QMainWindow):
                         btn_exact_x = msg.addButton("Exact match by X only", QMessageBox.YesRole)
                         btn_nearest_x = msg.addButton("Nearest match by X only", QMessageBox.YesRole)
                         btn_nearest_xz = msg.addButton("Nearest match by X and Z", QMessageBox.YesRole)
+                        btn_match_order = msg.addButton("Match by source/geophone order", QMessageBox.YesRole)
                         btn_accept = msg.addButton("Accept as is", QMessageBox.AcceptRole)
                         btn_cancel = msg.addButton("Cancel", QMessageBox.RejectRole)
                         
@@ -20086,10 +21330,14 @@ class MainWindow(QMainWindow):
                                 matching_mode = "nearest_x"
                                 if verbose:
                                     print("\nAttempting nearest neighbor matching by X only...")
-                            else:  # btn_nearest_xz
+                            elif clicked_button == btn_nearest_xz:
                                 matching_mode = "nearest_xz"
                                 if verbose:
                                     print("\nAttempting nearest neighbor matching by X and Z...")
+                            else:  # btn_match_order
+                                matching_mode = "match_order"
+                                if verbose:
+                                    print("\nAttempting order-based matching of source/geophone positions...")
                             
                             # Perform the selected matching
                             picks_matched_this_round, sources_matched_this_round, max_time_this_round = self._match_sgt_picks_alternative(
@@ -20112,8 +21360,8 @@ class MainWindow(QMainWindow):
                                 n_sources_total = len(sources_with_matched_picks)
                                 
                                 if verbose:
-                                    print(f"[DEBUG] matched_sgt_picks has {len(matched_sgt_picks)} entries")
-                                    print(f"[DEBUG] prev_n_picks_total={prev_n_picks_total}, n_picks_total={n_picks_total}")
+                                    print(f"matched_sgt_picks has {len(matched_sgt_picks)} entries")
+                                    print(f"prev_n_picks_total={prev_n_picks_total}, n_picks_total={n_picks_total}")
                                 
                                 if max_time_this_round > max_picked_time:
                                     max_picked_time = max_time_this_round