pyckster 26.1.1__tar.gz → 26.1.2__tar.gz

{pyckster-26.1.1 → pyckster-26.1.2}/CHANGES.md

@@ -1,3 +1,5 @@
+v26.1.2, Jan. 2026 -- Batch dispersion windowing, minor fixes
+
 v26.1.1, Jan. 2026 -- Code cleanup, minor bug fixes and improvements, add dispersion picking feature
 
 v25.12.4, Dec. 2025 -- Minor dependency fix

{pyckster-26.1.1/pyckster.egg-info → pyckster-26.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyckster
-Version: 26.1.1
+Version: 26.1.2
 Summary: A PyQt5-based GUI for picking seismic traveltimes
 Home-page: https://gitlab.in2p3.fr/metis-geophysics/pyckster
 Author: Sylvain Pasquet

{pyckster-26.1.1 → pyckster-26.1.2}/pyckster/__init__.py

@@ -15,7 +15,7 @@ except ImportError:
     pass  # matplotlib not available, that's fine
 
 # Define version and metadata in one place
-__version__ = "26.1.1"
+__version__ = "26.1.2"
 __author__ = "Sylvain Pasquet"
 __email__ = "sylvain.pasquet@sorbonne-universite.fr"
 __license__ = "GPLv3"

{pyckster-26.1.1 → pyckster-26.1.2}/pyckster/core.py

@@ -709,9 +709,9 @@ class GenericParameterDialog(QDialog):
                 combo = QComboBox(self)
                 # Fill the combo box with the provided choices (expect the parameter to include a key 'values')
                 for choice in param.get('values', []):
-                    combo.addItem(f"'{choice}'")
+                    combo.addItem(choice)
                 # Set current value if provided
-                combo.setCurrentText(f"'{initial_value}'")
+                combo.setCurrentText(initial_value)
                 self.lineEdits[label_text] = (combo, param_type)
                 self.layout.addLayout(self.createFormItem(label_text, combo))
             elif param_type == 'slider':
@@ -851,9 +851,6 @@ class GenericParameterDialog(QDialog):
             elif param_type == 'combo':
                 # For dropdown lists, get the current text
                 value = lineEdit.currentText()
-                # Optionally remove surrounding quotes if present
-                if value.startswith("'") and value.endswith("'"):
-                    value = value[1:-1]
                 values[label] = value
             elif param_type == 'slider':
                 # For sliders, get the scaled value
@@ -3587,29 +3584,42 @@ class MainWindow(QMainWindow):
         
         # Analytical views: Normalization toggles (Spectrogram, Dispersion)
         if view_type in ("Spectrogram", "Dispersion"):
-            norm_per_trace_attr = 'norm_per_trace'
-            norm_per_freq_attr = 'norm_per_freq'
-            norm_per_trace_handler = 'onNormPerTraceChanged'
-            norm_per_freq_handler = 'onNormPerFreqChanged'
-            
-            norm_per_trace_check = QCheckBox()
-            norm_per_trace_check.setChecked(bool(getattr(self, norm_per_trace_attr, True)))
-            norm_per_trace_check.toggled.connect(getattr(self, norm_per_trace_handler))
+            # Use view-specific normalization attributes
+            view_prefix = view_type.lower()
             
             if view_type == "Spectrogram":
+                # Spectrogram: both per-trace and per-freq normalization options
+                norm_per_trace_attr = f'{view_prefix}_norm_per_trace'
+                norm_per_freq_attr = f'{view_prefix}_norm_per_freq'
+                norm_per_trace_handler = f'onNormPerTraceChanged_{view_type}'
+                norm_per_freq_handler = f'onNormPerFreqChanged_{view_type}'
+                
+                norm_per_trace_check = QCheckBox()
+                norm_per_trace_check.setChecked(bool(getattr(self, norm_per_trace_attr, True)))
+                norm_per_trace_check.toggled.connect(getattr(self, norm_per_trace_handler))
                 norm_per_trace_check.setText("Norm. per trace")
+                
                 norm_per_freq_check = QCheckBox()
                 norm_per_freq_check.setChecked(bool(getattr(self, norm_per_freq_attr, False)))
                 norm_per_freq_check.toggled.connect(getattr(self, norm_per_freq_handler))
                 norm_per_freq_check.setText("Norm. per freq")
+                
                 layout.addWidget(norm_per_trace_check)
                 layout.addWidget(norm_per_freq_check)
-                setattr(self, 'normPerTraceCheck', norm_per_trace_check)
-                setattr(self, 'normPerFreqCheck', norm_per_freq_check)
+                setattr(self, f'{prefix}NormPerTraceCheck_spectrogram', norm_per_trace_check)
+                setattr(self, f'{prefix}NormPerFreqCheck_spectrogram', norm_per_freq_check)
             else:
-                norm_per_trace_check.setText("Norm.")
-                layout.addWidget(norm_per_trace_check)
-                setattr(self, 'normPerTraceCheck', norm_per_trace_check)
+                # Dispersion: only per-freq normalization option
+                norm_per_freq_attr = f'{view_prefix}_norm_per_freq'
+                norm_per_freq_handler = f'onNormPerFreqChanged_{view_type}'
+                
+                norm_per_freq_check = QCheckBox()
+                norm_per_freq_check.setChecked(bool(getattr(self, norm_per_freq_attr, False)))
+                norm_per_freq_check.toggled.connect(getattr(self, norm_per_freq_handler))
+                norm_per_freq_check.setText("Norm.")
+                
+                layout.addWidget(norm_per_freq_check)
+                setattr(self, f'{prefix}NormPerFreqCheck_dispersion', norm_per_freq_check)
             
             # Topography correction checkbox (Dispersion only)
             if view_type == "Dispersion":
@@ -3619,6 +3629,14 @@ class MainWindow(QMainWindow):
                 layout.addWidget(use_topo_check)
                 setattr(self, 'useTopographyCheck', use_topo_check)
             
+            # Permute axes button (Spectrogram only)
+            if view_type == "Spectrogram":
+                permute_button = QPushButton("Permute axes")
+                permute_button.setToolTip("Swap frequency and trace axes")
+                permute_button.clicked.connect(self.onSpectrogramPermuteAxes)
+                layout.addWidget(permute_button)
+                setattr(self, 'spectrogramPermuteButton', permute_button)
+            
             add_separator()
 
         # Frequency controls (Spectrogram, Dispersion)
@@ -3636,7 +3654,9 @@ class MainWindow(QMainWindow):
             fmin_spin.setMaximumWidth(70)
             fmin_spin.valueChanged.connect(getattr(self, fmin_handler))
             layout.addWidget(fmin_spin)
+            # Store both generic and view-specific names
             setattr(self, 'fminSpin', fmin_spin)
+            setattr(self, f'{prefix}_fminSpin', fmin_spin)
             
             fmax_spin = QDoubleSpinBox()
             fmax_spin.setRange(0.0, 1e4)
@@ -3647,7 +3667,9 @@ class MainWindow(QMainWindow):
             fmax_spin.setMaximumWidth(70)
             fmax_spin.valueChanged.connect(getattr(self, fmax_handler))
             layout.addWidget(fmax_spin)
+            # Store both generic and view-specific names
             setattr(self, 'fmaxSpin', fmax_spin)
+            setattr(self, f'{prefix}_fmaxSpin', fmax_spin)
             
             add_separator()
 
@@ -3692,7 +3714,21 @@ class MainWindow(QMainWindow):
             add_separator()
             
             # Trace selection for phase-shift using range slider
-            layout.addWidget(QLabel("Trace range:"))
+            trace_range_container = QHBoxLayout()
+            trace_range_label = QLabel("Trace range:")
+            trace_range_container.addWidget(trace_range_label)
+            
+            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()
+            
+            # Add the horizontal layout as a widget to the main layout
+            trace_range_widget = QWidget()
+            trace_range_widget.setLayout(trace_range_container)
+            layout.addWidget(trace_range_widget)
+            
             trace_range_slider = RangeSlider()
             # Store which view this slider controls
             trace_range_slider.controlled_view = prefix  # "top" or "bottom"
@@ -3770,45 +3806,50 @@ class MainWindow(QMainWindow):
         if hasattr(self, 'topDynamicControlsLayout'):
             self._clear_layout(self.topDynamicControlsLayout)
 
-    def onNormPerTraceChanged(self, state):
-        """Handle per-trace normalization toggle (unified for all views/positions)"""
-        self.norm_per_trace = bool(state)
+    def onNormPerTraceChanged_Spectrogram(self, state):
+        """Handle per-trace normalization toggle for Spectrogram view"""
+        self.spectrogram_norm_per_trace = bool(state)
         if not (hasattr(self, 'currentIndex') and self.currentIndex is not None and self.streams):
             return
-        # Replot both top and bottom if they use this setting
-        if hasattr(self, 'topPlotType'):
-            if self.topPlotType == "spectrogram":
-                self._plot_target_widget = self.plotWidget
-                self._plot_target_viewbox = self.viewBox
-                self.plotSpectrogram()
-                self._plot_target_widget = None
-                self._plot_target_viewbox = None
-            elif self.topPlotType == "dispersion":
-                self._plot_target_widget = self.plotWidget
-                self._plot_target_viewbox = self.viewBox
-                self.plotDispersion()
-                self._plot_target_widget = None
-                self._plot_target_viewbox = None
-        if hasattr(self, 'bottomPlotType'):
-            if self.bottomPlotType == "spectrogram":
-                self._plot_target_widget = self.bottomPlotWidget
-                self._plot_target_viewbox = self.bottomViewBox
-                self.plotSpectrogram()
-                self._plot_target_widget = None
-                self._plot_target_viewbox = None
-            elif self.bottomPlotType == "dispersion":
-                self._plot_target_widget = self.bottomPlotWidget
-                self._plot_target_viewbox = self.bottomViewBox
-                self.plotDispersion()
-                self._plot_target_widget = None
-                self._plot_target_viewbox = None
+        # Replot both top and bottom if they use spectrogram
+        if hasattr(self, 'topPlotType') and self.topPlotType == "spectrogram":
+            self._plot_target_widget = self.plotWidget
+            self._plot_target_viewbox = self.viewBox
+            self.plotSpectrogram()
+            self._plot_target_widget = None
+            self._plot_target_viewbox = None
+        if hasattr(self, 'bottomPlotType') and self.bottomPlotType == "spectrogram":
+            self._plot_target_widget = self.bottomPlotWidget
+            self._plot_target_viewbox = self.bottomViewBox
+            self.plotSpectrogram()
+            self._plot_target_widget = None
+            self._plot_target_viewbox = None
 
-    def onNormPerFreqChanged(self, state):
-        """Handle per-freq normalization toggle (unified for Spectrogram)"""
-        self.norm_per_freq = bool(state)
+    def onNormPerTraceChanged_Dispersion(self, state):
+        """Handle per-trace normalization toggle for Dispersion view"""
+        self.dispersion_norm_per_trace = bool(state)
+        if not (hasattr(self, 'currentIndex') and self.currentIndex is not None and self.streams):
+            return
+        # Replot both top and bottom if they use dispersion
+        if hasattr(self, 'topPlotType') and self.topPlotType == "dispersion":
+            self._plot_target_widget = self.plotWidget
+            self._plot_target_viewbox = self.viewBox
+            self.plotDispersion()
+            self._plot_target_widget = None
+            self._plot_target_viewbox = None
+        if hasattr(self, 'bottomPlotType') and self.bottomPlotType == "dispersion":
+            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 onNormPerFreqChanged_Spectrogram(self, state):
+        """Handle per-freq normalization toggle for Spectrogram view"""
+        self.spectrogram_norm_per_freq = bool(state)
         if not (hasattr(self, 'currentIndex') and self.currentIndex is not None and self.streams):
             return
-        # Replot both top and bottom if they use this setting
+        # Replot both top and bottom if they use spectrogram
         if hasattr(self, 'topPlotType') and self.topPlotType == "spectrogram":
             self._plot_target_widget = self.plotWidget
             self._plot_target_viewbox = self.viewBox
@@ -3821,7 +3862,39 @@ class MainWindow(QMainWindow):
             self.plotSpectrogram()
             self._plot_target_widget = None
             self._plot_target_viewbox = None
-    
+
+    def onNormPerFreqChanged_Dispersion(self, state):
+        """Handle per-freq normalization toggle for Dispersion view"""
+        self.dispersion_norm_per_freq = bool(state)
+        if not (hasattr(self, 'currentIndex') and self.currentIndex is not None and self.streams):
+            return
+        # Replot both top and bottom if they use dispersion
+        if hasattr(self, 'topPlotType') and self.topPlotType == "dispersion":
+            self._plot_target_widget = self.plotWidget
+            self._plot_target_viewbox = self.viewBox
+            self.plotDispersion()
+            self._plot_target_widget = None
+            self._plot_target_viewbox = None
+        if hasattr(self, 'bottomPlotType') and self.bottomPlotType == "dispersion":
+            self._plot_target_widget = self.bottomPlotWidget
+            self._plot_target_viewbox = self.bottomViewBox
+            self.plotDispersion()
+            self._plot_target_widget = None
+            self._plot_target_viewbox = None
+
+    # Deprecated methods kept for backward compatibility
+    def onNormPerTraceChanged(self, state):
+        """Deprecated: use view-specific handlers instead"""
+        self.norm_per_trace = bool(state)
+        # Delegate to spectrogram handler for backward compatibility
+        self.onNormPerTraceChanged_Spectrogram(state)
+
+    def onNormPerFreqChanged(self, state):
+        """Deprecated: use view-specific handlers instead"""
+        self.norm_per_freq = bool(state)
+        # Delegate to spectrogram handler for backward compatibility
+        self.onNormPerFreqChanged_Spectrogram(state)
+
     def onUseTopographyChanged(self, state):
         """Handle topography correction checkbox toggle for phase-shift analysis"""
         self.use_topography_correction = bool(state)
@@ -3831,50 +3904,406 @@ class MainWindow(QMainWindow):
         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
+        
+        # Replot both top and bottom if they use spectrogram
+        if hasattr(self, 'topPlotType') and self.topPlotType == "spectrogram":
+            self._plot_target_widget = self.plotWidget
+            self._plot_target_viewbox = self.viewBox
+            self.plotSpectrogram()
+            self._plot_target_widget = None
+            self._plot_target_viewbox = None
+        if hasattr(self, 'bottomPlotType') and self.bottomPlotType == "spectrogram":
+            self._plot_target_widget = self.bottomPlotWidget
+            self._plot_target_viewbox = self.bottomViewBox
+            self.plotSpectrogram()
+            self._plot_target_widget = None
+            self._plot_target_viewbox = None
+
+    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
+        )
+        
+        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)
+            
+            # Apply batch windowing to all shots
+            self._applyBatchWindowingToAllShots(window_length, window_side, offset_from_shot, prefer_side)
+
+    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"""
+        if not self.streams:
+            QMessageBox.warning(self, "No Data", "No data loaded.")
+            return
+        
+        try:
+            # Initialize batch windowing memory if not exists
+            if not hasattr(self, 'batch_windowing_params'):
+                self.batch_windowing_params = {}
+            
+            # Store parameters
+            self.batch_windowing_params['window_length'] = window_length
+            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
+            
+            # Apply to each shot
+            for shot_idx, stream in enumerate(self.streams):
+                n_traces = len(stream)
+                
+                # Get shot position and trace positions
+                if shot_idx >= len(self.source_position) or shot_idx >= len(self.trace_position):
+                    continue
+                
+                shot_pos = self.source_position[shot_idx]
+                trace_positions = np.array(self.trace_position[shot_idx])
+                
+                # 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
+                
+                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:
+                                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:
+                                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
+                        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:
+                                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))
+                            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:
+                                    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))
+                        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:
+                                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))
+                            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) > 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)
+                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))
+                
+                # 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,
+                    'last': last_trace,
+                    'n_traces': n_traces
+                }
+                self.trace_range_memory[file_key]['bottom'] = {
+                    'first': first_trace,
+                    'last': last_trace,
+                    'n_traces': n_traces
+                }
+            
+            # Update the current shot's range slider and attributes
+            if self.currentIndex is not None and self.currentIndex < len(self.streams):
+                file_key = self.currentIndex
+                
+                if file_key in self.trace_range_memory and 'bottom' in self.trace_range_memory[file_key]:
+                    stored_range = self.trace_range_memory[file_key]['bottom']
+                    first_trace = stored_range['first']
+                    last_trace = stored_range['last']
+                    n_traces = stored_range['n_traces']
+                    
+                    # Update view-specific attributes
+                    self.bottom_first_trace = first_trace
+                    self.bottom_last_trace = last_trace
+                    self.top_first_trace = first_trace
+                    self.top_last_trace = last_trace
+                    
+                    # Update the slider widget with error handling
+                    try:
+                        if hasattr(self, 'bottom_traceRangeSlider') and self.bottom_traceRangeSlider is not None:
+                            # Check if widget is still valid (not deleted)
+                            try:
+                                self.bottom_traceRangeSlider.setRange(first_trace, last_trace, n_traces - 1)
+                            except RuntimeError:
+                                # Widget was deleted, skip update
+                                pass
+                    except Exception:
+                        pass
+                    
+                    try:
+                        if hasattr(self, 'top_traceRangeSlider') and self.top_traceRangeSlider is not None:
+                            # Check if widget is still valid (not deleted)
+                            try:
+                                self.top_traceRangeSlider.setRange(first_trace, last_trace, n_traces - 1)
+                            except RuntimeError:
+                                # Widget was deleted, skip update
+                                pass
+                    except Exception:
+                        pass
+                    
+                    # Redraw dispersion if active
+                    if hasattr(self, 'bottomPlotType') and self.bottomPlotType == "dispersion":
+                        self._plot_target_widget = self.bottomPlotWidget
+                        self._plot_target_viewbox = self.bottomViewBox
+                        self.drawTraceExtentIndicator()
+                        self.plotDispersion()
+                        self._plot_target_widget = None
+                        self._plot_target_viewbox = None
+                    elif hasattr(self, 'topPlotType') and self.topPlotType == "dispersion":
+                        self._plot_target_widget = self.topPlotWidget
+                        self._plot_target_viewbox = self.topViewBox
+                        self.drawTraceExtentIndicator()
+                        self.plotDispersion()
+                        self._plot_target_widget = None
+                        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}")
+        
+        except Exception as e:
+            QMessageBox.critical(self, "Error", f"Failed to apply batch windowing: {str(e)}")
+
     def onFreqRangeChanged(self, _=None):
         """Handle frequency range change (fmin/fmax) - unified"""
         # Guard against calls when no file is loaded
         if not (hasattr(self, 'currentIndex') and self.currentIndex is not None and self.streams):
             return
         
+        # Detect which spinbox sent the signal
+        sender_spin = self.sender()
+        
         # Get current values from spinboxes
         try:
-            fmin_val = self.fminSpin.value()
-            fmax_val = self.fmaxSpin.value()
+            # Use the sender spinbox value if available, otherwise use the generic one
+            if sender_spin and hasattr(sender_spin, 'value'):
+                # Sender is one of the spinboxes, but we still need both fmin and fmax
+                # Find the corresponding pair (if sender is fmin spinbox, get both fmin and fmax)
+                fmin_val = None
+                fmax_val = None
+                
+                # Check which spinbox sent the signal
+                for prefix in ['top', 'bottom']:
+                    fmin_attr = f'{prefix}_fminSpin'
+                    fmax_attr = f'{prefix}_fmaxSpin'
+                    
+                    if hasattr(self, fmin_attr) and getattr(self, fmin_attr) is sender_spin:
+                        # Sender is the fmin spinbox for this prefix
+                        fmin_val = sender_spin.value()
+                        if hasattr(self, fmax_attr):
+                            fmax_val = getattr(self, fmax_attr).value()
+                        break
+                    elif hasattr(self, fmax_attr) and getattr(self, fmax_attr) is sender_spin:
+                        # Sender is the fmax spinbox for this prefix
+                        fmax_val = sender_spin.value()
+                        if hasattr(self, fmin_attr):
+                            fmin_val = getattr(self, fmin_attr).value()
+                        break
+                
+                # Fallback if sender not identified
+                if fmin_val is None or fmax_val is None:
+                    fmin_val = self.fminSpin.value()
+                    fmax_val = self.fmaxSpin.value()
+            else:
+                fmin_val = self.fminSpin.value()
+                fmax_val = self.fmaxSpin.value()
         except (RuntimeError, AttributeError):
             return
         
-        # Compute Nyquist for current file if available
-        nyquist = None
-        try:
-            if self.currentIndex is not None:
-                dt = self.sample_interval[self.currentIndex]
-                if dt and dt > 0:
-                    nyquist = 1.0 / (2.0 * dt)
-        except Exception:
-            nyquist = None
-        
-        if nyquist is not None:
-            # Clamp to [0, nyquist]
-            fmin_val = max(0.0, min(fmin_val, nyquist))
-            fmax_val = max(0.0, min(fmax_val, nyquist))
-            try:
-                self.fminSpin.blockSignals(True)
-                self.fmaxSpin.blockSignals(True)
-                self.fminSpin.setValue(fmin_val)
-                self.fmaxSpin.setValue(fmax_val)
-            finally:
-                self.fminSpin.blockSignals(False)
-                self.fmaxSpin.blockSignals(False)
-        
+        # Store the raw values (allow user to set any frequency)
         self.fmin = fmin_val if fmin_val > 0 else None
         self.fmax = fmax_val if fmax_val > 0 else None
         
-        # Guard against invalid ranges
+        # Guard against invalid ranges (fmin >= fmax is only checked for actual values)
         if (self.fmin is not None and self.fmax is not None and self.fmin >= self.fmax):
             return
         
-        # Replot both top and bottom
+        # Sync all view-specific spinboxes to the same value (except the sender)
+        for prefix in ['top', 'bottom']:
+            fmin_attr = f'{prefix}_fminSpin'
+            fmax_attr = f'{prefix}_fmaxSpin'
+            if hasattr(self, fmin_attr):
+                try:
+                    spin = getattr(self, fmin_attr)
+                    if spin is not None and spin is not sender_spin and spin.value() != fmin_val:
+                        spin.blockSignals(True)
+                        spin.setValue(fmin_val)
+                        spin.blockSignals(False)
+                except RuntimeError:
+                    pass
+            if hasattr(self, fmax_attr):
+                try:
+                    spin = getattr(self, fmax_attr)
+                    if spin is not None and spin is not sender_spin and spin.value() != fmax_val:
+                        spin.blockSignals(True)
+                        spin.setValue(fmax_val)
+                        spin.blockSignals(False)
+                except RuntimeError:
+                    pass
+        
+        # Always replot if this is a dispersion or spectrogram view
+        # The plotting functions will handle Nyquist clamping for their specific data
         if hasattr(self, 'topPlotType'):
             if self.topPlotType == "spectrogram":
                 self._plot_target_widget = self.plotWidget
@@ -3978,10 +4407,10 @@ class MainWindow(QMainWindow):
         
         # Update the trace extent indicator and replot only for top view
         if hasattr(self, 'topPlotType') and self.topPlotType == "dispersion":
-            self.drawTraceExtentIndicator()
             # Set target to top widget for this plot
             self._plot_target_widget = self.topPlotWidget
             self._plot_target_viewbox = self.topViewBox
+            self.drawTraceExtentIndicator()
             self.plotDispersion()
             self._plot_target_widget = None
             self._plot_target_viewbox = None
@@ -4030,6 +4459,9 @@ class MainWindow(QMainWindow):
         
         # Update the trace extent indicator and replot only for bottom view
         if hasattr(self, 'bottomPlotType') and self.bottomPlotType == "dispersion":
+            # Set target to bottom widget for this plot
+            self._plot_target_widget = self.bottomPlotWidget
+            self._plot_target_viewbox = self.bottomViewBox
             self.drawTraceExtentIndicator()
             self.plotDispersion()
 
@@ -4124,33 +4556,42 @@ class MainWindow(QMainWindow):
         # Update the trace extent indicator and replot only for the controlled view
         if controlled_view == "top":
             if hasattr(self, 'topPlotType') and self.topPlotType == "dispersion":
-                if not suppress_indicator_redraw:
-                    self.drawTraceExtentIndicator()
                 # Set target to top widget for this plot
                 self._plot_target_widget = self.topPlotWidget
                 self._plot_target_viewbox = self.topViewBox
+                if not suppress_indicator_redraw:
+                    self.drawTraceExtentIndicator()
                 self.plotDispersion()
                 self._plot_target_widget = None
                 self._plot_target_viewbox = None
         elif controlled_view == "bottom":
             if hasattr(self, 'bottomPlotType') and self.bottomPlotType == "dispersion":
+                # Set target to bottom widget for this plot
+                self._plot_target_widget = self.bottomPlotWidget
+                self._plot_target_viewbox = self.bottomViewBox
                 if not suppress_indicator_redraw:
                     self.drawTraceExtentIndicator()
                 self.plotDispersion()
+                self._plot_target_widget = None
+                self._plot_target_viewbox = None
         else:
             # Fallback: update both if we're not sure
             if hasattr(self, 'topPlotType') and self.topPlotType == "dispersion":
-                if not suppress_indicator_redraw:
-                    self.drawTraceExtentIndicator()
                 self._plot_target_widget = self.topPlotWidget
                 self._plot_target_viewbox = self.topViewBox
+                if not suppress_indicator_redraw:
+                    self.drawTraceExtentIndicator()
                 self.plotDispersion()
                 self._plot_target_widget = None
                 self._plot_target_viewbox = None
             if hasattr(self, 'bottomPlotType') and self.bottomPlotType == "dispersion":
+                self._plot_target_widget = self.bottomPlotWidget
+                self._plot_target_viewbox = self.bottomViewBox
                 if not suppress_indicator_redraw:
                     self.drawTraceExtentIndicator()
                 self.plotDispersion()
+                self._plot_target_widget = None
+                self._plot_target_viewbox = None
 
     def updateDispersionWindowInfo(self):
         """Update the status bar with dispersion window center and width information"""
@@ -5749,9 +6190,16 @@ class MainWindow(QMainWindow):
         self.spectrogram_colormap_str = 'plasma'
         self.dispersion_colormap_str = 'plasma'
         
-        # Unified analytical view normalization settings (same for top/bottom)
-        self.norm_per_trace = True  # Per-trace (Spectrogram), per-f (Phase-Shift)
-        self.norm_per_freq = False  # Per-freq (Spectrogram), per-v (Phase-Shift)
+        # Spectrogram axis permutation (freq on x or y axis)
+        self.spectrogram_freq_on_y = True  # True: freq on y-axis, False: freq on x-axis
+        
+        # Spectrogram-specific normalization settings (independent from dispersion)
+        self.spectrogram_norm_per_trace = True
+        self.spectrogram_norm_per_freq = False
+        
+        # Dispersion-specific normalization settings (independent from spectrogram)
+        self.dispersion_norm_per_trace = True
+        self.dispersion_norm_per_freq = True
         
         # Unified analytical view parameter defaults (same for top/bottom)
         self.fmin = None   # Default fmin (auto -> 0 for Spectrogram/Phase-Shift)
@@ -16351,11 +16799,11 @@ class MainWindow(QMainWindow):
 
         # Normalize FFT data based on user selection
         eps = 1e-12
-        if getattr(self, 'norm_per_trace', True):
+        if getattr(self, 'spectrogram_norm_per_trace', True):
             # Per-trace normalization for spectrogram
             max_per_trace = np.maximum(np.max(fft_data, axis=1, keepdims=True), eps)
             fft_data = fft_data / max_per_trace
-        if getattr(self, 'norm_per_freq', False):
+        if getattr(self, 'spectrogram_norm_per_freq', False):
             # Per-frequency normalization
             max_per_freq = np.maximum(np.max(fft_data, axis=0, keepdims=True), eps)
             fft_data = fft_data / max_per_freq
@@ -16382,21 +16830,43 @@ class MainWindow(QMainWindow):
             freqs = freqs[fmask]
             fft_data = fft_data[:, fmask]
 
+        # Check if axes should be permuted
+        freq_on_y = getattr(self, 'spectrogram_freq_on_y', True)
+        
         # Create image item with colormap
         colormap = getattr(self, 'spectrogram_colormap_str', 'plasma')
-        image_item = createImageItem(fft_data.T, x, freqs, colormap=colormap)
-
-        # Store image data and coordinates for amplitude lookup
-        self.spectrogramImageData = fft_data.T
-        self.spectrogramImageX = x
-        self.spectrogramImageFreqs = freqs
+        
+        if freq_on_y:
+            # Original: frequency on y-axis, traces on x-axis
+            image_item = createImageItem(fft_data.T, x, freqs, colormap=colormap)
+            # Store image data and coordinates for amplitude lookup
+            self.spectrogramImageData = fft_data.T
+            self.spectrogramImageX = x
+            self.spectrogramImageFreqs = freqs
+            
+            # Set axis labels
+            x_label = self.x_label
+            y_label = 'Frequency (Hz)'
+            invert_y = True  # Frequency increases downward
+        else:
+            # Permuted: traces on y-axis, frequency on x-axis
+            image_item = createImageItem(fft_data, freqs, x, colormap=colormap)
+            # Store image data and coordinates for amplitude lookup
+            self.spectrogramImageData = fft_data
+            self.spectrogramImageX = freqs
+            self.spectrogramImageFreqs = x
+            
+            # Set axis labels
+            x_label = 'Frequency (Hz)'
+            y_label = self.x_label
+            invert_y = False  # Traces increase downward normally
 
         # Add image to plot
         plot_widget.addItem(image_item)
 
         # Set axis labels
-        plot_widget.setLabel('left', 'Frequency (Hz)')
-        plot_widget.setLabel('top', self.x_label)
+        plot_widget.setLabel('left', y_label)
+        plot_widget.setLabel('top', x_label)
         plot_widget.setLabel('bottom', '')
         plot_widget.showAxis('top')
         plot_widget.showAxis('bottom')
@@ -16405,16 +16875,31 @@ class MainWindow(QMainWindow):
         plot_widget.getAxis('right').setStyle(showValues=False)
         plot_widget.getAxis('right').setLabel('')
 
-        # Ensure Y-axis is inverted (frequency increases downward)
-        if not viewbox.state.get('invertY', False):
-            viewbox.invertY(True)
+        # Invert Y-axis if needed
+        if invert_y:
+            if not viewbox.state.get('invertY', False):
+                viewbox.invertY(True)
+        else:
+            if viewbox.state.get('invertY', False):
+                viewbox.invertY(False)
 
         # Set explicit ranges for consistent tick label placement and prevent zooming out beyond data range
+        if freq_on_y:
+            x_range_min = min(x) - self.mean_dg
+            x_range_max = max(x) + self.mean_dg
+            y_range_min = min(freqs)
+            y_range_max = max(freqs)
+        else:
+            x_range_min = min(freqs)
+            x_range_max = max(freqs)
+            y_range_min = min(x)
+            y_range_max = max(x)
+        
         if len(x) > 0 and len(freqs) > 0:
-            viewbox.setLimits(xMin=min(x) - self.mean_dg, xMax=max(x) + self.mean_dg, 
-                                        yMin=min(freqs), yMax=max(freqs))
-            viewbox.setXRange(min(x) - self.mean_dg, max(x) + self.mean_dg, padding=0)
-            viewbox.setYRange(min(freqs), max(freqs), padding=0)
+            viewbox.setLimits(xMin=x_range_min, xMax=x_range_max, 
+                            yMin=y_range_min, yMax=y_range_max)
+            viewbox.setXRange(x_range_min, x_range_max, padding=0)
+            viewbox.setYRange(y_range_min, y_range_max, padding=0)
         else:
             viewbox.setLimits(xMin=None, xMax=None, yMin=None, yMax=None)
 
@@ -16540,13 +17025,9 @@ class MainWindow(QMainWindow):
             # Compute phase-shift transform
             fs, vs, FV = phase_shift(data, dt, offsets, vmin, vmax, dv, fmax, fmin)
 
-            # Normalize based on user selection
+            # Normalize based on user selection (Dispersion only uses per-frequency normalization)
             eps = 1e-12
-            if getattr(self, 'norm_per_trace', True):
-                # Per-frequency normalization for Phase-Shift (normalize each frequency independently)
-                max_per_freq = np.maximum(np.max(FV, axis=1, keepdims=True), eps)
-                FV = FV / max_per_freq
-            if getattr(self, 'norm_per_freq', False):
+            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

{pyckster-26.1.1 → pyckster-26.1.2/pyckster.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyckster
-Version: 26.1.1
+Version: 26.1.2
 Summary: A PyQt5-based GUI for picking seismic traveltimes
 Home-page: https://gitlab.in2p3.fr/metis-geophysics/pyckster
 Author: Sylvain Pasquet