pyckster 26.1.6__py3-none-any.whl → 26.2.2__py3-none-any.whl

pyckster/core.py

@@ -80,10 +80,13 @@ from .obspy_utils import (
     remove_trace,
     move_trace,
     mute_trace,
+    zero_pad_trace,
     swap_header_format,
     merge_streams,
     get_max_decimals,
-    assisted_picking
+    assisted_picking,
+    export_shot_to_ascii,
+    import_shot_from_ascii
 )
 
 from .auto_picking import adaptive_picker
@@ -874,7 +877,7 @@ class TraceSelector(QDialog):
             self.layout.addWidget(self.createFormItem("Trace Position (m):", self.tracePositionLineEdit))
             
             # If trace_positions provided, initialize with the first trace position
-            if trace_positions and len(trace_positions) > 0:
+            if trace_positions is not None and len(trace_positions) > 0:
                 self.tracePositionLineEdit.setText(str(trace_positions[0]))
 
         # Add a checkbox to apply the changes to all shots
@@ -978,6 +981,50 @@ class HeaderDialog(QDialog):
         # Resize the columns to fit the contents
         self.table_widget.resizeColumnsToContents()
 
+
+class OverallHeaderDialog(QDialog):
+    """Dialog to display overall headers for all files in a single table"""
+    def __init__(self, files, headers, file_data, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Overall Header Fields")
+        self.setGeometry(100, 100, 1200, 600)
+        
+        layout = QVBoxLayout(self)
+        
+        # Create a QTableWidget
+        self.table_widget = QTableWidget()
+        self.table_widget.setRowCount(len(files))
+        self.table_widget.setColumnCount(len(headers) + 1)  # +1 for file name column
+        
+        # Set headers: File name + all other headers
+        all_headers = ["File Name"] + headers
+        self.table_widget.setHorizontalHeaderLabels(all_headers)
+        
+        # Populate the table
+        for row, file in enumerate(files):
+            # File name in first column
+            self.table_widget.setItem(row, 0, QTableWidgetItem(file))
+            
+            # Data for each header
+            for col, header in enumerate(headers):
+                value = file_data[file].get(header, ['N/A'])[0]  # Get first element from list
+                self.table_widget.setItem(row, col + 1, QTableWidgetItem(str(value)))
+        
+        # Resize the columns to fit the contents
+        self.table_widget.resizeColumnsToContents()
+        
+        # Make the table scrollable
+        scroll_area = QScrollArea()
+        scroll_area.setWidgetResizable(True)
+        scroll_area.setWidget(self.table_widget)
+        
+        layout.addWidget(scroll_area)
+        
+        # OK button
+        self.okButton = QPushButton("OK")
+        self.okButton.clicked.connect(self.accept)
+        layout.addWidget(self.okButton)
+
 #######################################
 # Cross-correlation Dialog Classes
 #######################################
@@ -1249,6 +1296,184 @@ def find_icon_path():
 # Auto Pick Dialog
 #######################################
 
+class AcquisitionParametersDialog(QDialog):
+    """Dialog to display acquisition parameters summary"""
+    def __init__(self, params, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Acquisition Parameters")
+        self.setMinimumWidth(500)
+        self.setMinimumHeight(400)
+        self.resize(600, 500)  # Set initial size
+        
+        # Enable resizing and maximize button
+        self.setWindowFlags(Qt.Window | Qt.WindowMaximizeButtonHint | Qt.WindowCloseButtonHint)
+        
+        layout = QVBoxLayout(self)
+        
+        # Create a QTextEdit to display the parameters
+        self.textEdit = QTextEdit()
+        self.textEdit.setReadOnly(True)
+        self.textEdit.setFont(QFont("Courier", 10))
+        
+        # Format the parameters text
+        text = self.formatParameters(params)
+        self.textEdit.setPlainText(text)
+        
+        layout.addWidget(self.textEdit)
+        
+        # Add OK button
+        buttonBox = QDialogButtonBox(QDialogButtonBox.Ok)
+        buttonBox.accepted.connect(self.accept)
+        layout.addWidget(buttonBox)
+    
+    def formatParameters(self, params):
+        """Format the parameters into a readable text"""
+        lines = []
+        lines.append("=" * 60)
+        lines.append("ACQUISITION PARAMETERS SUMMARY")
+        lines.append("=" * 60)
+        lines.append("")
+        
+        if 'error' in params:
+            lines.append(f"Error: {params['error']}")
+            return "\n".join(lines)
+        
+        # Determine decimal precision for positions based on actual data
+        # Check all position values to find the needed precision
+        all_position_values = []
+        for key in ['first_trace_pos', 'last_trace_pos', 'first_shot_pos', 'last_shot_pos', 
+                    'trace_spacing', 'source_spacing', 'total_trace_extent', 'total_source_extent',
+                    'min_offset', 'max_offset']:
+            if params.get(key) is not None:
+                all_position_values.append(params[key])
+        
+        # Determine needed decimal places (check for up to 3 decimals)
+        decimal_places = 2  # default
+        for val in all_position_values:
+            # Convert to string and check decimal places
+            val_str = f"{val:.6f}".rstrip('0').rstrip('.')
+            if '.' in val_str:
+                decimals = len(val_str.split('.')[1])
+                decimal_places = max(decimal_places, min(decimals, 3))  # cap at 3
+        
+        # Helper function to format values with adaptive precision
+        def fmt_val(val):
+            if val is None:
+                return "N/A"
+            return f"{val:.{decimal_places}f}"
+        
+        # Roll-along detection FIRST
+        lines.append("ACQUISITION TYPE:")
+        lines.append("-" * 60)
+        if params.get('roll_along_detected'):
+            lines.append(f"  Roll-along acquisition:    YES")
+            if params.get('roll_along_segments') is not None:
+                lines.append(f"  Number of segments:        {params['roll_along_segments']}")
+        else:
+            lines.append(f"  Roll-along acquisition:     NO (single deployment)")
+        
+        # Shot positioning
+        if params.get('shot_positioning'):
+            lines.append(f"  Shot positioning:          {params['shot_positioning']}")
+        
+        # Number of source/geophone pairs
+        if params.get('n_traces') is not None and params.get('n_shots') is not None:
+            total_traces = params['n_traces'] * params['n_shots']
+            lines.append(f"  Source/geophone pair:      {total_traces}")
+        lines.append("")
+        
+        # Geophones/Traces section
+        lines.append("GEOPHONES/TRACES:")
+        lines.append("-" * 60)
+        if params.get('total_unique_traces') is not None:
+            lines.append(f"  Total number of traces:    {params['total_unique_traces']}")
+        else:
+            lines.append(f"  Number of traces/shot:     {params.get('n_traces', 'N/A')}")
+        
+        # Show missing geophones if detected
+        if params.get('n_missing_traces', 0) > 0:
+            lines.append(f"  Missing geophones:         {params['n_missing_traces']} geophone(s) missing")
+        
+        lines.append(f"  Geophone spacing:          {fmt_val(params.get('trace_spacing'))} m")
+        lines.append(f"  Total geophone extent:     {fmt_val(params.get('total_trace_extent'))} m")
+        lines.append(f"  First geophone position:   {fmt_val(params.get('first_trace_pos'))} m")
+        lines.append(f"  Last geophone position:    {fmt_val(params.get('last_trace_pos'))} m")
+        
+        # Show details of missing geophones if any
+        if params.get('missing_traces'):
+            lines.append("  Missing geophone positions:")
+            missing_list = params['missing_traces'][:10]  # Show first 10
+            for pos in missing_list:
+                lines.append(f"    - {fmt_val(pos)} m")
+            if len(params['missing_traces']) > 10:
+                lines.append(f"    ... and {len(params['missing_traces']) - 10} more")
+        
+        # Add roll-along segment details if available
+        if params.get('roll_along_detected') and params.get('roll_along_segment_details'):
+            lines.append("")
+            lines.append("  Roll-along segment details:")
+            for i, seg_detail in enumerate(params['roll_along_segment_details'], 1):
+                lines.append(f"    Segment {i}: {seg_detail}")
+        lines.append("")
+        
+        # Sources/Shots section
+        lines.append("SOURCES/SHOTS:")
+        lines.append("-" * 60)
+        lines.append(f"  Total number of shots:   {params.get('n_shots', 'N/A')}")
+        
+        # Show missing sources if detected
+        if params.get('n_missing_sources', 0) > 0:
+            lines.append(f"  Missing sources:         {params['n_missing_sources']} source(s) missing")
+        
+        spacing_label = "  Source spacing (median): " if params.get('roll_along_detected') else "  Source spacing:          "
+        lines.append(f"{spacing_label}{fmt_val(params.get('source_spacing'))} m")
+        lines.append(f"  Total source extent:     {fmt_val(params.get('total_source_extent'))} m")
+        lines.append(f"  First shot position:     {fmt_val(params.get('first_shot_pos'))} m")
+        lines.append(f"  Last shot position:      {fmt_val(params.get('last_shot_pos'))} m")
+        
+        min_offset = abs(params['min_offset']) if params.get('min_offset') is not None else None
+        max_offset = abs(params['max_offset']) if params.get('max_offset') is not None else None
+        lines.append(f"  Minimum offset:          {fmt_val(min_offset)} m")
+        lines.append(f"  Maximum offset:          {fmt_val(max_offset)} m")
+        
+        # Show details of missing sources if any
+        if params.get('missing_sources'):
+            lines.append("  Missing source positions:")
+            missing_list = params['missing_sources'][:10]  # Show first 10
+            for pos in missing_list:
+                lines.append(f"    - {fmt_val(pos)} m")
+            if len(params['missing_sources']) > 10:
+                lines.append(f"    ... and {len(params['missing_sources']) - 10} more")
+        
+        # Add roll-along shot segment details if available
+        if params.get('roll_along_detected') and params.get('roll_along_shot_segment_details'):
+            lines.append("")
+            lines.append("  Roll-along segment details:")
+            for i, seg_detail in enumerate(params['roll_along_shot_segment_details'], 1):
+                lines.append(f"    Segment {i}: {seg_detail}")
+        lines.append("")
+        
+        # Timing section
+        lines.append("TIMING:")
+        lines.append("-" * 60)
+        if params.get('sample_interval') is not None:
+            lines.append(f"  Sampling interval:       {params['sample_interval']*1000:.3f} ms")
+        else:
+            lines.append(f"  Sampling interval:       N/A")
+        if params.get('record_length') is not None:
+            lines.append(f"  Recording time:          {params['record_length']*1000:.2f} ms")
+        else:
+            lines.append(f"  Recording time:          N/A")
+        if params.get('delay') is not None:
+            lines.append(f"  Delay time:              {params['delay']*1000:.3f} ms")
+        else:
+            lines.append(f"  Delay time:              N/A")
+        lines.append("")
+        lines.append("=" * 60)
+        
+        return "\n".join(lines)
+
+
 class AutoPickDialog(QDialog):
     """Dialog for entering frequency range for auto pick operation"""
     def __init__(self, parent=None, fmin_default=0.0, fmax_default=200.0):
@@ -1493,6 +1718,12 @@ class MainWindow(QMainWindow):
         self.fileListWidget.setMinimumWidth(50)  # Set minimum width
         leftLayout.addWidget(self.fileListWidget)
 
+        # Add Acquisition parameters button
+        self.acqParamsButton = QPushButton("Acquisition parameters")
+        self.acqParamsButton.clicked.connect(self.showAcquisitionParameters)
+        self.acqParamsButton.setToolTip("Show acquisition parameters summary")
+        leftLayout.addWidget(self.acqParamsButton)
+
         # Add separator line
         separator = QFrame()
         separator.setFrameShape(QFrame.HLine)
@@ -2034,6 +2265,11 @@ class MainWindow(QMainWindow):
         self.importAsciiAction = QAction('Import ASCII matrix...', self)
         self.fileMenu.addAction(self.importAsciiAction)
         self.importAsciiAction.triggered.connect(self.importAsciiMatrix)
+
+        # Create QAction for importing ASCII archive
+        self.importAsciiArchiveAction = QAction('Import ASCII archive...', self)
+        self.fileMenu.addAction(self.importAsciiArchiveAction)
+        self.importAsciiArchiveAction.triggered.connect(self.importAsciiArchive)
         
         # Add separator
         self.fileMenu.addSeparator()
@@ -2059,6 +2295,11 @@ class MainWindow(QMainWindow):
         self.saveSingleFileSubMenu.addAction(self.saveSingleFileSuAction)
         self.saveSingleFileSuAction.triggered.connect(self.saveSingleFileSU)
 
+        # Create QAction for saving current file as ASCII
+        self.saveSingleFileAsciiAction = QAction('as ASCII files (archive)', self)
+        self.saveSingleFileSubMenu.addAction(self.saveSingleFileAsciiAction)
+        self.saveSingleFileAsciiAction.triggered.connect(self.saveSingleFileASCII)
+
         # Create a submenu for saving all files
         self.saveFileSubMenu = self.fileMenu.addMenu('Save all shots')
 
@@ -2082,6 +2323,11 @@ class MainWindow(QMainWindow):
         self.saveFileSubMenu.addAction(self.saveAllFilesSingleSuAction)
         self.saveAllFilesSingleSuAction.triggered.connect(self.saveAllFilesSingleSU)
 
+        # Create QAction for saving all files as ASCII
+        self.saveAllFilesAsciiAction = QAction('as ASCII files (archives)', self)
+        self.saveFileSubMenu.addAction(self.saveAllFilesAsciiAction)
+        self.saveAllFilesAsciiAction.triggered.connect(self.saveAllFilesASCII)
+
         # Add separator
         self.fileMenu.addSeparator()
 
@@ -2108,11 +2354,16 @@ class MainWindow(QMainWindow):
         self.showHeadersSubMenu.addAction(self.showRawHeadersAction)
         self.showRawHeadersAction.triggered.connect(self.showRawHeaders)
 
-        # Create QAction for showing clean headers
-        self.showSelectedHeadersAction = QAction('Show clean headers', self)
+        # Create QAction for showing clean shot headers
+        self.showSelectedHeadersAction = QAction('Show clean shot headers', self)
         self.showHeadersSubMenu.addAction(self.showSelectedHeadersAction)
         self.showSelectedHeadersAction.triggered.connect(self.showHeaders)
 
+        # Create QAction for showing clean overall headers
+        self.showOverallHeadersAction = QAction('Show clean overall headers', self)
+        self.showHeadersSubMenu.addAction(self.showOverallHeadersAction)
+        self.showOverallHeadersAction.triggered.connect(self.showOverallHeaders)
+
         # Add separator
         self.headerMenu.addSeparator()
 
@@ -2149,6 +2400,11 @@ class MainWindow(QMainWindow):
         self.editTraceSubMenu.addAction(self.insertMutedTracesAction)
         self.insertMutedTracesAction.triggered.connect(self.insertMutedTraces)
 
+        # Create a QAction for zero padding traces
+        self.zeroPadTraceAction = QAction('Zero pad traces', self)
+        self.editTraceSubMenu.addAction(self.zeroPadTraceAction)
+        self.zeroPadTraceAction.triggered.connect(self.zeroPadTrace)
+
         # Create a submenu for batch editing traces
         self.batchEditTraceSubMenu = self.headerMenu.addMenu('Batch edit traces')
 
@@ -2182,6 +2438,11 @@ class MainWindow(QMainWindow):
         self.batchEditTraceSubMenu.addAction(self.batchInsertMutedTracesAction)
         self.batchInsertMutedTracesAction.triggered.connect(self.batchInsertMutedTraces)
 
+        # Create a QAction for batch zero padding traces
+        self.batchZeroPadTracesAction = QAction('Batch zero pad traces', self)
+        self.batchEditTraceSubMenu.addAction(self.batchZeroPadTracesAction)
+        self.batchZeroPadTracesAction.triggered.connect(self.batchZeroPadTraces)
+
         # Add separator
         self.headerMenu.addSeparator()
 
@@ -3862,6 +4123,11 @@ class MainWindow(QMainWindow):
         """Clear all dynamic controls from top widget"""
         if hasattr(self, 'topDynamicControlsLayout'):
             self._clear_layout(self.topDynamicControlsLayout)
+    
+    def _clearBottomDynamicControls(self):
+        """Clear all dynamic controls from bottom widget"""
+        if hasattr(self, 'bottomDynamicControlsLayout'):
+            self._clear_layout(self.bottomDynamicControlsLayout)
 
     def onNormPerTraceChanged_Spectrogram(self, state):
         """Handle per-trace normalization toggle for Spectrogram view"""
@@ -5067,27 +5333,6 @@ class MainWindow(QMainWindow):
             # Update title to show on correct plot widget based on current view types
             self.updateTitle()
     
-    def onTimesColormapChanged(self, colormap_name):
-        """Handle times colormap change (legacy colormap dropdown)"""
-        # Update the view-specific colormap based on current bottom view (unified)
-        if hasattr(self, 'bottomViewComboBox'):
-            view_type = self.bottomViewComboBox.currentText()
-            plot_type_to_view = {"Traveltimes": "layout_view", "Layout": "layout_view", "Topography": "topography", 
-                                "Spectrogram": "spectrogram", "Dispersion": "dispersion", "Seismogram": "seismogram"}
-            view_key = plot_type_to_view.get(view_type, "layout_view")
-            setattr(self, f'{view_key}_colormap_str', colormap_name)
-        
-        # Keep legacy colormap_str for backward compatibility
-        self.colormap_str = colormap_name
-        self.colormap = pqg.colormap.get(self.colormap_str, source='matplotlib')
-        
-        # Show source info in status bar
-        if self.streams and self.currentIndex is not None:
-            self.ffidLabel.setText(f'FFID: {self.ffid[self.currentIndex]} | Source at {self.source_position[self.currentIndex]} m')
-        # Refresh the plot for current bottom view
-        if hasattr(self, 'bottomViewComboBox'):
-            self.updatePlots()
-
     def onBottomNormChanged(self, state):
         """Handle normalization checkbox toggle for bottom analytical views"""
         # Store normalization state as boolean
@@ -5795,8 +6040,8 @@ class MainWindow(QMainWindow):
                     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'):
+                    # Check for pick files: .sgt, .lst, .vs
+                    if file_path.lower().endswith(('.sgt', '.lst', '.vs')):
                         accepted = True
                         break
                     # Check for dispersion picks: .pvc
@@ -5829,7 +6074,7 @@ class MainWindow(QMainWindow):
                 if file_path.lower().endswith(('.su', '.segy', '.sgy', '.sg2', '.dat', '.seg2')):
                     seismic_files.append(file_path)
                 # Traveltime pick files
-                elif file_path.lower().endswith('.sgt'):
+                elif file_path.lower().endswith(('.sgt', '.lst', '.vs')):
                     pick_files.append(file_path)
                 # Dispersion pick files
                 elif file_path.lower().endswith('.pvc'):
@@ -6553,6 +6798,8 @@ class MainWindow(QMainWindow):
         self._batch_loading = False  # Flag to prevent plotting during batch loading
         self.plotTypeX = 'file_trace_number'  # Plot type for X axis
         self.plotTypeY = 'ffid'  # Plot type for Y axis
+        self.x_label = 'Trace Number (All Streams)'  # Initialize X axis label
+        self.y_label = 'FFID'  # Initialize Y axis label
         self.t_label = 'Time (s)'
         self.relativeError = 0.05
         self.absoluteError = 0
@@ -7117,6 +7364,299 @@ class MainWindow(QMainWindow):
 
         self.updatePlotTypeDict()
 
+    def showAcquisitionParameters(self):
+        """Display a dialog with acquisition parameters summary"""
+        if not self.streams or len(self.streams) == 0:
+            QMessageBox.information(self, "No Data", "No seismic files loaded.")
+            return
+        
+        # Calculate parameters from all loaded streams
+        params = self.calculateAcquisitionParameters()
+        
+        # Show the dialog
+        dialog = AcquisitionParametersDialog(params, self)
+        dialog.exec_()
+    
+    def calculateAcquisitionParameters(self):
+        """Calculate acquisition parameters from loaded data"""
+        params = {}
+        
+        try:
+            # Number of shots
+            params['n_shots'] = len(self.streams)
+            
+            # Get parameters from current or first file
+            idx = self.currentIndex if self.currentIndex is not None else 0
+            
+            if idx >= len(self.streams):
+                params['error'] = "Invalid file index"
+                return params
+            
+            # Number of traces (from current/first shot)
+            params['n_traces'] = len(self.streams[idx])
+            
+            # Collect all unique trace positions across all shots for total extent
+            all_trace_positions = set()
+            if hasattr(self, 'trace_position') and len(self.trace_position) > 0:
+                for trace_pos_list in self.trace_position:
+                    if trace_pos_list is not None:
+                        all_trace_positions.update(trace_pos_list)
+            
+            # Total unique traces and overall extent
+            if len(all_trace_positions) > 0:
+                params['total_unique_traces'] = len(all_trace_positions)
+                params['total_trace_extent'] = max(all_trace_positions) - min(all_trace_positions)
+                params['first_trace_pos'] = min(all_trace_positions)
+                params['last_trace_pos'] = max(all_trace_positions)
+            else:
+                params['total_unique_traces'] = None
+                params['total_trace_extent'] = None
+                params['first_trace_pos'] = None
+                params['last_trace_pos'] = None
+            
+            # Trace spacing (from current/first shot)
+            if hasattr(self, 'trace_position') and idx < len(self.trace_position):
+                trace_pos = self.trace_position[idx]
+                if trace_pos is not None and len(trace_pos) > 1:
+                    # Calculate spacing using median for robustness
+                    spacings = [trace_pos[i+1] - trace_pos[i] for i in range(len(trace_pos)-1)]
+                    params['trace_spacing'] = np.median(spacings)
+                elif trace_pos is not None and len(trace_pos) == 1:
+                    params['trace_spacing'] = None
+                else:
+                    params['trace_spacing'] = None
+            else:
+                params['trace_spacing'] = None
+            
+            # Detect missing traces
+            params['missing_traces'] = None
+            params['n_missing_traces'] = 0
+            if len(all_trace_positions) > 1 and params.get('trace_spacing') is not None:
+                sorted_positions = sorted(all_trace_positions)
+                expected_spacing = params['trace_spacing']
+                tolerance = expected_spacing * 0.3  # 30% tolerance
+                missing_positions = []
+                
+                for i in range(len(sorted_positions) - 1):
+                    gap = sorted_positions[i+1] - sorted_positions[i]
+                    if gap > expected_spacing + tolerance:
+                        # Gap detected - calculate how many traces are missing
+                        n_missing = round(gap / expected_spacing) - 1
+                        if n_missing > 0:
+                            # Calculate approximate positions of missing traces
+                            for j in range(1, n_missing + 1):
+                                missing_pos = sorted_positions[i] + j * expected_spacing
+                                missing_positions.append(missing_pos)
+                
+                if missing_positions:
+                    params['missing_traces'] = missing_positions
+                    params['n_missing_traces'] = len(missing_positions)
+            
+            # Source spacing and extent
+            if hasattr(self, 'source_position') and len(self.source_position) > 1:
+                source_positions = self.source_position
+                if len(source_positions) > 1:
+                    # Calculate spacing using MEDIAN to handle roll-along gaps
+                    spacings = [source_positions[i+1] - source_positions[i] for i in range(len(source_positions)-1)]
+                    params['source_spacing'] = np.median(np.abs(spacings))
+                    # Total extent from all shots
+                    params['total_source_extent'] = max(source_positions) - min(source_positions)
+                    params['first_shot_pos'] = min(source_positions)
+                    params['last_shot_pos'] = max(source_positions)
+                else:
+                    params['source_spacing'] = None
+                    params['total_source_extent'] = None
+                    params['first_shot_pos'] = source_positions[0] if len(source_positions) > 0 else None
+                    params['last_shot_pos'] = source_positions[0] if len(source_positions) > 0 else None
+            else:
+                params['source_spacing'] = None
+                params['total_source_extent'] = None
+                params['first_shot_pos'] = None
+                params['last_shot_pos'] = None
+            
+            # Detect missing sources/shots
+            params['missing_sources'] = None
+            params['n_missing_sources'] = 0
+            if (hasattr(self, 'source_position') and len(self.source_position) > 1 and 
+                params.get('source_spacing') is not None):
+                sorted_positions = sorted(self.source_position)
+                expected_spacing = params['source_spacing']
+                tolerance = expected_spacing * 0.3  # 30% tolerance
+                missing_positions = []
+                
+                for i in range(len(sorted_positions) - 1):
+                    gap = sorted_positions[i+1] - sorted_positions[i]
+                    if gap > expected_spacing + tolerance:
+                        # Gap detected - calculate how many sources are missing
+                        n_missing = round(gap / expected_spacing) - 1
+                        if n_missing > 0:
+                            # Calculate approximate positions of missing sources
+                            for j in range(1, n_missing + 1):
+                                missing_pos = sorted_positions[i] + j * expected_spacing
+                                missing_positions.append(missing_pos)
+                
+                if missing_positions:
+                    params['missing_sources'] = missing_positions
+                    params['n_missing_sources'] = len(missing_positions)
+            
+            # Detect shot positioning relative to traces
+            params['shot_positioning'] = None
+            if (hasattr(self, 'source_position') and hasattr(self, 'trace_position') and 
+                len(self.source_position) > 0 and len(self.trace_position) > 0):
+                try:
+                    # Collect all unique trace positions across all shots
+                    all_trace_positions = set()
+                    for trace_pos_list in self.trace_position:
+                        if trace_pos_list is not None:
+                            all_trace_positions.update(trace_pos_list)
+                    
+                    # Check each source position against trace positions
+                    tolerance = 0.1  # 10 cm tolerance for considering positions equal
+                    at_trace_count = 0
+                    between_trace_count = 0
+                    
+                    for src_pos in self.source_position:
+                        is_at_trace = any(abs(src_pos - trace_pos) < tolerance for trace_pos in all_trace_positions)
+                        if is_at_trace:
+                            at_trace_count += 1
+                        else:
+                            between_trace_count += 1
+                    
+                    # Determine positioning type
+                    if at_trace_count > 0 and between_trace_count == 0:
+                        params['shot_positioning'] = "At trace positions"
+                    elif between_trace_count > 0 and at_trace_count == 0:
+                        params['shot_positioning'] = "Between traces"
+                    elif at_trace_count > 0 and between_trace_count > 0:
+                        params['shot_positioning'] = f"Mixed ({at_trace_count} at traces, {between_trace_count} between)"
+                    else:
+                        params['shot_positioning'] = "Unknown"
+                except Exception:
+                    params['shot_positioning'] = "Unknown"
+            
+            # Min/Max offset
+            if hasattr(self, 'offset') and len(self.offset) > 0:
+                all_offsets = []
+                for offset_list in self.offset:
+                    if offset_list is not None and len(offset_list) > 0:
+                        all_offsets.extend(offset_list)
+                if len(all_offsets) > 0:
+                    # Use absolute values for offset ranges
+                    abs_offsets = [abs(offset) for offset in all_offsets]
+                    params['min_offset'] = min(abs_offsets)
+                    params['max_offset'] = max(abs_offsets)
+                else:
+                    params['min_offset'] = None
+                    params['max_offset'] = None
+            else:
+                params['min_offset'] = None
+                params['max_offset'] = None
+            
+            # Roll-along detection
+            params['roll_along_detected'] = False
+            params['roll_along_segments'] = None
+            params['roll_along_segment_details'] = None
+            params['roll_along_shot_segment_details'] = None
+            
+            if (hasattr(self, 'source_position') and hasattr(self, 'trace_position') and 
+                len(self.source_position) > 1 and len(self.trace_position) > 1):
+                try:
+                    # Detect roll-along by checking if trace positions change while
+                    # some shots might be at similar positions
+                    # Group shots by similar trace array positions
+                    segments = []
+                    current_segment = [0]
+                    
+                    for i in range(1, len(self.trace_position)):
+                        if self.trace_position[i] is not None and self.trace_position[i-1] is not None:
+                            # Check if trace positions have changed significantly
+                            prev_min = min(self.trace_position[i-1])
+                            prev_max = max(self.trace_position[i-1])
+                            curr_min = min(self.trace_position[i])
+                            curr_max = max(self.trace_position[i])
+                            
+                            # If the trace array has shifted (different min/max positions)
+                            # This indicates a new segment in roll-along
+                            if abs(curr_min - prev_min) > 0.1 or abs(curr_max - prev_max) > 0.1:
+                                segments.append(current_segment)
+                                current_segment = [i]
+                            else:
+                                current_segment.append(i)
+                        else:
+                            current_segment.append(i)
+                    
+                    # Add last segment
+                    if current_segment:
+                        segments.append(current_segment)
+                    
+                    # Roll-along is detected if we have multiple segments
+                    if len(segments) > 1:
+                        params['roll_along_detected'] = True
+                        params['roll_along_segments'] = len(segments)
+                        
+                        # Get detailed info for each segment (traces)
+                        segment_details = []
+                        for seg_idx, segment in enumerate(segments):
+                            # Get trace positions for this segment
+                            seg_trace_pos = self.trace_position[segment[0]]
+                            if seg_trace_pos is not None:
+                                seg_unique_traces = set()
+                                for shot_idx in segment:
+                                    if self.trace_position[shot_idx] is not None:
+                                        seg_unique_traces.update(self.trace_position[shot_idx])
+                                
+                                seg_min = min(seg_unique_traces)
+                                seg_max = max(seg_unique_traces)
+                                seg_extent = seg_max - seg_min
+                                seg_n_traces = len(seg_unique_traces)
+                                
+                                detail = f"{seg_n_traces} traces, {seg_min:.0f} to {seg_max:.0f} m (extent: {seg_extent:.0f} m)"
+                                segment_details.append(detail)
+                        
+                        params['roll_along_segment_details'] = segment_details
+                        
+                        # Get detailed info for each segment (shots)
+                        shot_segment_details = []
+                        for seg_idx, segment in enumerate(segments):
+                            # Get shot positions for this segment
+                            seg_shot_positions = [self.source_position[i] for i in segment if i < len(self.source_position)]
+                            if seg_shot_positions:
+                                seg_min_shot = min(seg_shot_positions)
+                                seg_max_shot = max(seg_shot_positions)
+                                seg_extent_shot = seg_max_shot - seg_min_shot
+                                seg_n_shots = len(seg_shot_positions)
+                                
+                                detail = f"{seg_n_shots} shots, {seg_min_shot:.0f} to {seg_max_shot:.0f} m (extent: {seg_extent_shot:.0f} m)"
+                                shot_segment_details.append(detail)
+                        
+                        params['roll_along_shot_segment_details'] = shot_segment_details
+                except Exception:
+                    # If roll-along detection fails, just mark as not detected
+                    pass
+            
+            # Sampling interval
+            if hasattr(self, 'sample_interval') and idx < len(self.sample_interval):
+                params['sample_interval'] = self.sample_interval[idx]
+            else:
+                params['sample_interval'] = None
+            
+            # Recording time
+            if hasattr(self, 'record_length') and idx < len(self.record_length):
+                params['record_length'] = self.record_length[idx]
+            else:
+                params['record_length'] = None
+            
+            # Delay time
+            if hasattr(self, 'delay') and idx < len(self.delay):
+                params['delay'] = self.delay[idx]
+            else:
+                params['delay'] = None
+                
+        except Exception as e:
+            params['error'] = f"Error calculating parameters: {str(e)}"
+        
+        return params
+
     def clearMemory(self):
         # Clear memory (reset the application)
 
@@ -9761,15 +10301,68 @@ class MainWindow(QMainWindow):
     
     def _on_dispersion_interp_method_changed(self, index):
         """Handler for interpolation method change"""
+        # Get method-specific minimum points requirement
+        method_names = ["Cubic", "Linear", "Quadratic", "Spline"]
+        method_text = method_names[index] if index < len(method_names) else "Cubic"
+        min_points_required = {
+            "Linear": 2, "Quadratic": 3, "Cubic": 4, "Spline": 4
+        }
+        min_points = min_points_required.get(method_text, 2)
+        
         view = self._get_active_dispersion_view()
-        if view and self.dispersionLiveInterpolateCheckbox.isChecked():
-            # Re-interpolate with new method if live mode is on
+        if view:
+            # Get plot widget for removing items
+            plot_widget = self.plotWidget if view == 'top' else self.bottomPlotWidget
+            
+            # Handle all modes or just current mode
             if self.dispersionShowAllModesCheckbox.isChecked():
-                self.interpolateAllDispersionCurves(view)
+                # Process all modes
+                state = self.dispersion_picking_state[view]
+                for mode_num, mode_data in state['modes'].items():
+                    if len(mode_data['picked_points']) < min_points:
+                        # Not enough points for new method - remove curve
+                        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.get('interp_error_fill') is not None:
+                            try:
+                                plot_widget.removeItem(mode_data['interp_error_fill'])
+                            except:
+                                pass
+                            mode_data['interp_error_fill'] = None
+                        mode_data['curve_data'] = None
+                
+                # Re-interpolate all modes that have enough points
+                if self.dispersionLiveInterpolateCheckbox.isChecked():
+                    self.interpolateAllDispersionCurves(view)
             else:
+                # Process current mode only
                 mode_data = self._get_current_mode_data(view)
-                if len(mode_data['picked_points']) >= 2:
+                if len(mode_data['picked_points']) < min_points:
+                    # Not enough points for new method - remove curve
+                    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.get('interp_error_fill') is not None:
+                        try:
+                            plot_widget.removeItem(mode_data['interp_error_fill'])
+                        except:
+                            pass
+                        mode_data['interp_error_fill'] = None
+                    mode_data['curve_data'] = None
+                elif self.dispersionLiveInterpolateCheckbox.isChecked():
+                    # Re-interpolate with new method if live mode is on and enough points
                     self.interpolateDispersionCurve(view)
+            
+            # Refresh display to update all views
+            self._refreshDispersionPicksDisplay()
+            self._updatePseudoSectionIfVisible()
     
     def onShowSingleStacksToggled(self, state=None):
         """Toggle display of single stacks viewer"""
@@ -10923,6 +11516,21 @@ class MainWindow(QMainWindow):
                             self.offset[self.currentIndex] = [i * 1.0 for i in range(num_traces)]  # Default 1m spacing
                             self.updatePlotTypeDict()
                 
+                # Ensure time array is initialized
+                if (self.currentIndex < len(self.time) and 
+                    self.time[self.currentIndex] is None and
+                    self.currentIndex < len(self.streams) and 
+                    self.streams[self.currentIndex]):
+                    # Initialize time array from stream
+                    stream = self.streams[self.currentIndex]
+                    if len(stream) > 0:
+                        dt = stream[0].stats.delta
+                        n_samples = stream[0].stats.npts
+                        self.time[self.currentIndex] = np.arange(n_samples) * dt
+                        self.n_sample[self.currentIndex] = n_samples
+                        self.sample_interval[self.currentIndex] = dt
+                        self.record_length[self.currentIndex] = self.time[self.currentIndex][-1]
+                
                 # Restore trace ranges from memory if available
                 self._restoreTraceRangesFromMemory()
                 
@@ -11014,9 +11622,9 @@ class MainWindow(QMainWindow):
     class AsciiImportDialog(QDialog):
         def __init__(self, parent=None):
             super().__init__(parent)
-            self.setWindowTitle("ASCII Matrix Import Parameters")
+            self.setWindowTitle("Import ASCII Matrix")
             self.setModal(True)
-            self.resize(400, 500)
+            self.resize(450, 250)
             
             layout = QVBoxLayout(self)
             
@@ -11026,88 +11634,55 @@ class MainWindow(QMainWindow):
             
             self.file_path_edit = QLineEdit()
             self.file_path_edit.setReadOnly(True)
+            self.file_path_edit.setPlaceholderText("No files selected")
             browse_button = QPushButton("Browse...")
             browse_button.clicked.connect(self.browse_file)
             
             file_row = QHBoxLayout()
             file_row.addWidget(self.file_path_edit)
             file_row.addWidget(browse_button)
-            file_layout.addRow("ASCII File:", file_row)
+            file_layout.addRow("ASCII File(s):", file_row)
             
-            layout.addWidget(file_group)
+            # Store selected file paths
+            self.selected_files = []
             
-            # Time parameters
-            time_group = QGroupBox("Time Parameters")
-            time_layout = QFormLayout(time_group)
+            layout.addWidget(file_group)
             
-            self.first_time_edit = QDoubleSpinBox()
-            self.first_time_edit.setRange(-999999, 999999)
-            self.first_time_edit.setDecimals(6)
-            self.first_time_edit.setValue(0.0)
-            self.first_time_edit.setSuffix(" s")
-            self.first_time_edit.setToolTip("First time sample (time of first row)")
-            time_layout.addRow("First time:", self.first_time_edit)
+            # Data parameters
+            data_group = QGroupBox("Data Parameters")
+            data_layout = QFormLayout(data_group)
             
             self.time_sampling_edit = QDoubleSpinBox()
             self.time_sampling_edit.setRange(0.000001, 1.0)
             self.time_sampling_edit.setDecimals(6)
-            self.time_sampling_edit.setValue(0.001)
+            self.time_sampling_edit.setValue(0.00025)
             self.time_sampling_edit.setSuffix(" s")
             self.time_sampling_edit.setToolTip("Time sampling interval (dt)")
-            time_layout.addRow("Time sampling (dt):", self.time_sampling_edit)
-            
-            layout.addWidget(time_group)
-            
-            # Trace parameters
-            trace_group = QGroupBox("Trace Parameters")
-            trace_layout = QFormLayout(trace_group)
-            
-            self.first_trace_edit = QDoubleSpinBox()
-            self.first_trace_edit.setRange(-999999, 999999)
-            self.first_trace_edit.setDecimals(2)
-            self.first_trace_edit.setValue(0.0)
-            self.first_trace_edit.setSuffix(" m")
-            self.first_trace_edit.setToolTip("Position of first trace (first column)")
-            trace_layout.addRow("First trace position:", self.first_trace_edit)
-            
-            self.trace_sampling_edit = QDoubleSpinBox()
-            self.trace_sampling_edit.setRange(0.01, 1000.0)
-            self.trace_sampling_edit.setDecimals(2)
-            self.trace_sampling_edit.setValue(1.0)
-            self.trace_sampling_edit.setSuffix(" m")
-            self.trace_sampling_edit.setToolTip("Distance between traces")
-            trace_layout.addRow("Trace spacing:", self.trace_sampling_edit)
-            
-            layout.addWidget(trace_group)
-            
-            # Shot parameters
-            shot_group = QGroupBox("Shot Parameters")
-            shot_layout = QFormLayout(shot_group)
-            
-            self.shot_position_edit = QDoubleSpinBox()
-            self.shot_position_edit.setRange(-999999, 999999)
-            self.shot_position_edit.setDecimals(2)
-            self.shot_position_edit.setValue(0.0)
-            self.shot_position_edit.setSuffix(" m")
-            self.shot_position_edit.setToolTip("Position of the seismic shot/source")
-            shot_layout.addRow("Shot position:", self.shot_position_edit)
-            
-            layout.addWidget(shot_group)
-            
-            # Data format options
-            format_group = QGroupBox("Data Format Options")
-            format_layout = QFormLayout(format_group)
+            data_layout.addRow("Time sampling (dt):", self.time_sampling_edit)
+            
+            self.skip_header_edit = QSpinBox()
+            self.skip_header_edit.setRange(0, 1000)
+            self.skip_header_edit.setValue(0)
+            self.skip_header_edit.setToolTip("Number of header lines to skip in the ASCII file")
+            data_layout.addRow("Skip header lines:", self.skip_header_edit)
             
             self.delimiter_edit = QLineEdit()
             self.delimiter_edit.setText("auto")
-            self.delimiter_edit.setToolTip("Column delimiter ('auto', 'tab', 'space', ',' or custom)")
-            format_layout.addRow("Column delimiter:", self.delimiter_edit)
+            self.delimiter_edit.setToolTip("Column delimiter ('auto', 'tab', 'space', ',', or custom character)")
+            data_layout.addRow("Column delimiter:", self.delimiter_edit)
             
             self.transpose_check = QCheckBox()
-            self.transpose_check.setToolTip("Check if traces are in rows instead of columns")
-            format_layout.addRow("Transpose matrix:", self.transpose_check)
+            self.transpose_check.setChecked(False)
+            self.transpose_check.setToolTip("Check if traces are organized row-wise (default: traces in columns)")
+            data_layout.addRow("Traces in rows:", self.transpose_check)
+            
+            layout.addWidget(data_group)
             
-            layout.addWidget(format_group)
+            # Info label
+            info_label = QLabel("Note: All positions and elevations will be set to 0. Time starts at 0.")
+            info_label.setWordWrap(True)
+            info_label.setStyleSheet("color: gray; font-style: italic;")
+            layout.addWidget(info_label)
             
             # Dialog buttons
             buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
@@ -11116,12 +11691,16 @@ class MainWindow(QMainWindow):
             layout.addWidget(buttons)
             
         def browse_file(self):
-            file_path, _ = QFileDialog.getOpenFileName(
-                self, "Select ASCII Matrix File", "", 
+            file_paths, _ = QFileDialog.getOpenFileNames(
+                self, "Select ASCII Matrix File(s)", "", 
                 "Text files (*.txt *.dat *.asc *.csv);;All files (*)"
             )
-            if file_path:
-                self.file_path_edit.setText(file_path)
+            if file_paths:
+                self.selected_files = file_paths
+                if len(file_paths) == 1:
+                    self.file_path_edit.setText(file_paths[0])
+                else:
+                    self.file_path_edit.setText(f"{len(file_paths)} files selected")
         
         def get_parameters(self):
             delimiter = self.delimiter_edit.text().strip()
@@ -11133,12 +11712,9 @@ class MainWindow(QMainWindow):
                 delimiter = ' '
             
             return {
-                'file_path': self.file_path_edit.text(),
-                'first_time': self.first_time_edit.value(),
+                'file_paths': self.selected_files,
                 'time_sampling': self.time_sampling_edit.value(),
-                'first_trace': self.first_trace_edit.value(),
-                'trace_spacing': self.trace_sampling_edit.value(),
-                'shot_position': self.shot_position_edit.value(),
+                'skip_header': self.skip_header_edit.value(),
                 'delimiter': delimiter,
                 'transpose': self.transpose_check.isChecked()
             }
@@ -11154,129 +11730,149 @@ class MainWindow(QMainWindow):
                 QMessageBox.critical(self, "Error", "Parameters are None - dialog error")
                 return
             
-            if not params['file_path']:
-                QMessageBox.warning(self, "Warning", "Please select an ASCII file to import.")
+            if not params['file_paths']:
+                QMessageBox.warning(self, "Warning", "Please select at least one ASCII file to import.")
                 return
             
-            try:
-                # Load the ASCII matrix
-                QApplication.processEvents()
-                
-                # Determine delimiter automatically if needed
-                delimiter = params['delimiter']
-                if delimiter is None:
-                    # Try to auto-detect delimiter
-                    with open(params['file_path'], 'r') as f:
-                        first_line = f.readline().strip()
-                        if '\t' in first_line:
-                            delimiter = '\t'
-                        elif ',' in first_line:
-                            delimiter = ','
-                        else:
-                            delimiter = None  # Let numpy handle it
-                
-                # Load the data
-                try:
-                    data_matrix = np.loadtxt(params['file_path'], delimiter=delimiter)
-                except ValueError:
-                    # Try with different delimiters
-                    for delim in [None, ',', '\t', ' ']:
-                        try:
-                            data_matrix = np.loadtxt(params['file_path'], delimiter=delim)
-                            break
-                        except ValueError:
-                            continue
-                    else:
-                        raise ValueError("Could not parse the ASCII file with any standard delimiter")
-                
-                # Transpose if requested
-                if params['transpose']:
-                    data_matrix = data_matrix.T
-                
-                # Validate the data matrix
-                if data_matrix.size == 0:
-                    raise ValueError("The loaded matrix is empty")
-                
-                # Check for problematic values
-                if np.any(np.isnan(data_matrix)):
-                    raise ValueError("The matrix contains NaN values")
-                if np.any(np.isinf(data_matrix)):
-                    raise ValueError("The matrix contains infinite values")
-                
-                # Convert to ObsPy stream
-                stream = self.ascii_to_obspy_stream(data_matrix, params)
-                
-                # Add to file list and load
-                file_name = os.path.basename(params['file_path'])
-                display_name = f"{file_name} (ASCII import)"
-                
-                # Create a temporary file info structure
-                file_info = {
-                    'fileName': params['file_path'],
-                    'displayName': display_name,
-                    'stream': stream,
-                    'isAsciiImport': True
-                }
-                
-                # Add to the file lists
-                self.fileNames.append(params['file_path'])
-                self.streams.append(stream)
-                
-                # Extend all other lists to match the new length
+            # Process each file
+            successful_imports = 0
+            failed_imports = []
+            
+            for file_path in params['file_paths']:
                 try:
-                    for attr in self.attributes_to_initialize:
-                        if attr not in ['fileNames', 'streams']:  # These are already added
-                            attr_list = getattr(self, attr)
-                            if attr_list is None:
-                                print(f"Warning: {attr} is None, initializing as empty list")
-                                setattr(self, attr, [])
+                    # Load the ASCII matrix
+                    QApplication.processEvents()
+                    
+                    # Determine delimiter automatically if needed
+                    delimiter = params['delimiter']
+                    if delimiter is None:
+                        # Try to auto-detect delimiter by reading first data line
+                        with open(file_path, 'r') as f:
+                            # Skip header lines
+                            for _ in range(params['skip_header']):
+                                f.readline()
+                            first_data_line = f.readline().strip()
+                            if '\t' in first_data_line:
+                                delimiter = '\t'
+                            elif ',' in first_data_line:
+                                delimiter = ','
+                            else:
+                                delimiter = None  # Let numpy handle it
+                    
+                    # Load the data with skiprows parameter
+                    try:
+                        data_matrix = np.loadtxt(file_path, delimiter=delimiter, skiprows=params['skip_header'])
+                    except ValueError:
+                        # Try with different delimiters
+                        for delim in [None, ',', '\t', ' ']:
+                            try:
+                                data_matrix = np.loadtxt(file_path, delimiter=delim, skiprows=params['skip_header'])
+                                break
+                            except ValueError:
+                                continue
+                        else:
+                            raise ValueError("Could not parse the ASCII file with any standard delimiter")
+                    
+                    # Transpose if traces are in rows
+                    if params['transpose']:
+                        data_matrix = data_matrix.T
+                    
+                    # Ensure data is 2D (rows=time, columns=traces)
+                    if data_matrix.ndim == 1:
+                        data_matrix = data_matrix.reshape(-1, 1)
+                    
+                    # Validate the data matrix
+                    if data_matrix.size == 0:
+                        raise ValueError("The loaded matrix is empty")
+                    
+                    # Check for problematic values
+                    if np.any(np.isnan(data_matrix)):
+                        raise ValueError("The matrix contains NaN values")
+                    if np.any(np.isinf(data_matrix)):
+                        raise ValueError("The matrix contains infinite values")
+                    
+                    # Convert to ObsPy stream
+                    stream = self.ascii_to_obspy_stream(data_matrix, params)
+                    
+                    # Add to file list and load
+                    file_name = os.path.basename(file_path)
+                    display_name = f"{file_name} (ASCII import)"
+                    
+                    # Add to the file lists
+                    self.fileNames.append(file_path)
+                    self.streams.append(stream)
+                    
+                    # Extend all other lists to match the new length
+                    try:
+                        for attr in self.attributes_to_initialize:
+                            if attr not in ['fileNames', 'streams']:  # These are already added
                                 attr_list = getattr(self, attr)
-                            attr_list.append(None)  # Initialize with None, will be set in loadStream()
+                                if attr_list is None:
+                                    print(f"Warning: {attr} is None, initializing as empty list")
+                                    setattr(self, attr, [])
+                                    attr_list = getattr(self, attr)
+                                attr_list.append(None)  # Initialize with None, will be set in loadStream()
+                    except Exception as e:
+                        print(f"Error in list extension: {e}")
+                        print(f"attributes_to_initialize: {self.attributes_to_initialize}")
+                        raise
+                    
+                    self.fileListWidget.addItem(display_name)
+                    
+                    # Get the index for this file
+                    file_index = len(self.streams) - 1
+                    
+                    # Set up the stream properly like loadStream() does
+                    self.input_format[file_index] = check_format(self.streams[file_index])
+                    
+                    # For ASCII data, set up basic plotting parameters manually
+                    num_traces = len(self.streams[file_index])
+                    
+                    # Set up basic parameters for ASCII data (all positions default to 0)
+                    self.shot_trace_number[file_index] = list(range(1, num_traces + 1))
+                    self.file_trace_number[file_index] = np.arange(1, num_traces + 1)
+                    self.trace_position[file_index] = list(range(num_traces))  # 0-based indexing for trace positions
+                    self.source_position[file_index] = 0.0  # Default source position
+                    self.offset[file_index] = [i * 1.0 for i in range(num_traces)]  # Default 1m spacing
+                    self.trace_elevation[file_index] = [0.0] * num_traces  # Default elevation
+                    self.source_elevation[file_index] = 0.0  # Default source elevation
+                    
+                    # Set up time parameters
+                    self.n_sample[file_index] = len(self.streams[file_index][0].data)
+                    self.sample_interval[file_index] = params['time_sampling']
+                    self.delay[file_index] = 0.0
+                    self.time[file_index] = np.arange(self.n_sample[file_index]) * self.sample_interval[file_index]
+                    self.record_length[file_index] = self.time[file_index][-1]
+                    self.ffid[file_index] = 1  # Default FFID
+                    
+                    successful_imports += 1
+                    
                 except Exception as e:
-                    print(f"Error in list extension: {e}")
-                    print(f"attributes_to_initialize: {self.attributes_to_initialize}")
-                    raise
-                
-                self.fileListWidget.addItem(display_name)
-                
-                # Select the new file
+                    failed_imports.append((os.path.basename(file_path), str(e)))
+            
+            # After processing all files, update UI and show results
+            if successful_imports > 0:
+                # Select the last imported file
                 self.currentIndex = len(self.streams) - 1
                 self.fileListWidget.setCurrentRow(self.currentIndex)
                 
-                # Set up the stream properly like loadStream() does
-                self.input_format[self.currentIndex] = check_format(self.streams[self.currentIndex])
-                
-                # For ASCII data, set up basic plotting parameters manually
-                # since SEGY headers don't exist
-                num_traces = len(self.streams[self.currentIndex])
-                
-                # Set up basic parameters for ASCII data
-                self.shot_trace_number[self.currentIndex] = list(range(1, num_traces + 1))
-                self.file_trace_number[self.currentIndex] = np.arange(1, num_traces + 1)
-                self.trace_position[self.currentIndex] = list(range(num_traces))  # 0-based indexing for trace positions
-                self.source_position[self.currentIndex] = 0.0  # Default source position
-                self.offset[self.currentIndex] = [i * params.get('trace_spacing', 1.0) for i in range(num_traces)]
-                self.trace_elevation[self.currentIndex] = [0.0] * num_traces  # Default elevation
-                self.source_elevation[self.currentIndex] = 0.0  # Default source elevation
-                
-                # Set up time parameters
-                self.n_sample[self.currentIndex] = len(self.streams[self.currentIndex][0].data)
-                self.sample_interval[self.currentIndex] = params.get('time_sampling', 0.001)  # Use correct key
-                self.delay[self.currentIndex] = 0.0
-                self.time[self.currentIndex] = np.arange(self.n_sample[self.currentIndex]) * self.sample_interval[self.currentIndex]
-                self.record_length[self.currentIndex] = self.time[self.currentIndex][-1]
-                self.ffid[self.currentIndex] = 1  # Default FFID
-                
                 # Update the plot type dictionary
                 self.updatePlotTypeDict()
                 
-                # Plot the new data
+                # Plot the data
                 self.updatePlots()
-                
-                QMessageBox.information(self, "Import Successful", f"ASCII matrix imported successfully: {data_matrix.shape[1]} traces, {data_matrix.shape[0]} time samples")
-
-            except Exception as e:
-                QMessageBox.critical(self, "Error", f"Failed to import ASCII matrix:\n{str(e)}")
+            
+            # Show import summary
+            if failed_imports:
+                error_msg = f"Successfully imported {successful_imports} file(s).\n\nFailed imports ({len(failed_imports)}):\n"
+                for fname, error in failed_imports[:5]:  # Show first 5 errors
+                    error_msg += f"\n• {fname}: {error}"
+                if len(failed_imports) > 5:
+                    error_msg += f"\n\n... and {len(failed_imports) - 5} more"
+                QMessageBox.warning(self, "Import Complete with Errors", error_msg)
+            else:
+                QMessageBox.information(self, "Import Successful", 
+                    f"Successfully imported {successful_imports} ASCII file(s)")
     
     def ascii_to_obspy_stream(self, data_matrix, params):
         """Convert ASCII matrix to ObsPy Stream object"""
@@ -11289,14 +11885,8 @@ class MainWindow(QMainWindow):
         # Create ObsPy Stream
         stream = Stream()
         
-        # Calculate time vector
-        times = np.arange(n_times) * params['time_sampling'] + params['first_time']
-        
         # Create a trace for each column
         for i in range(n_traces):
-            # Calculate trace position
-            trace_position = params['first_trace'] + i * params['trace_spacing']
-            
             # Create trace data
             trace_data = data_matrix[:, i]
             
@@ -11304,33 +11894,244 @@ class MainWindow(QMainWindow):
             stats = Stats()
             stats.sampling_rate = 1.0 / params['time_sampling']
             stats.npts = n_times
-            stats.starttime = UTCDateTime(0) + params['first_time']  # Relative time
+            stats.starttime = UTCDateTime(0)  # Start time at 0
             stats.delta = params['time_sampling']
             
-            # Set trace headers (using SEGY-like conventions)
-            stats.segy = {}
-            stats.segy.trace_header = {}
-            stats.segy.trace_header.trace_sequence_number_within_line = i + 1
-            stats.segy.trace_header.trace_sequence_number_within_segy_file = i + 1
-            stats.segy.trace_header.original_field_record_number = 1
-            stats.segy.trace_header.trace_number_within_the_original_field_record = i + 1
-            stats.segy.trace_header.source_coordinate_x = int(params['shot_position'] * 1000)  # Convert to mm
-            stats.segy.trace_header.group_coordinate_x = int(trace_position * 1000)  # Convert to mm
-            stats.segy.trace_header.coordinate_units = 2  # Meters
-            stats.segy.trace_header.number_of_samples_in_this_trace = n_times
-            stats.segy.trace_header.sample_interval_in_microseconds = int(params['time_sampling'] * 1e6)
+            # Set trace headers (using SEGY-like conventions, all positions at 0)
+            stats.segy = {}
+            stats.segy.trace_header = {}
+            stats.segy.trace_header.trace_sequence_number_within_line = i + 1
+            stats.segy.trace_header.trace_sequence_number_within_segy_file = i + 1
+            stats.segy.trace_header.original_field_record_number = 1
+            stats.segy.trace_header.trace_number_within_the_original_field_record = i + 1
+            stats.segy.trace_header.source_coordinate_x = 0  # Source at 0
+            stats.segy.trace_header.group_coordinate_x = i  # Trace position from 0 to ntrace-1
+            stats.segy.trace_header.coordinate_units = 2  # Meters
+            stats.segy.trace_header.number_of_samples_in_this_trace = n_times
+            stats.segy.trace_header.sample_interval_in_microseconds = int(params['time_sampling'] * 1e6)
+            
+            # Create channel naming
+            stats.network = "XX"
+            stats.station = f"T{i+1:03d}"
+            stats.location = ""
+            stats.channel = "SHZ"  # Assume vertical seismometer
+            
+            # Create the trace
+            trace = Trace(data=trace_data, header=stats)
+            stream.append(trace)
+        
+        return stream
+
+    def importAsciiArchive(self):
+        """Import shot data from ASCII archive (.tar.gz or .zip)"""
+        # Open file dialog to select archives (multiple selection enabled)
+        archive_paths, _ = QFileDialog.getOpenFileNames(
+            self, "Import ASCII Archive(s)", "",
+            "All archives (*.tar.gz *.tgz *.zip);;All files (*)"
+        )
+        
+        if not archive_paths:
+            return
+        
+        # Reset auto-increment flag for this import session
+        self._auto_increment_ffid = False
+        
+        successful_imports = 0
+        failed_imports = []
+        
+        for archive_path in archive_paths:
+            try:
+                QApplication.setOverrideCursor(Qt.WaitCursor)
+                
+                # Import the archive
+                stream, metadata = import_shot_from_ascii(archive_path)
+                
+                # Extract shot number
+                shot_number = int(metadata.get('shot_number', 1))
+                
+                # Check for duplicate FFID
+                if shot_number in self.ffid:
+                    QApplication.restoreOverrideCursor()
+                    
+                    # Check if user has already chosen "Yes to All" for this loading session
+                    if not self._auto_increment_ffid:
+                        # Prompt user to choose to load the file with incrementing FFID
+                        msg = QMessageBox()
+                        msg.setIcon(QMessageBox.Warning)
+                        msg.setText(f'FFID {shot_number} already loaded. Do you want to load the file with incrementing FFID?')
+                        msg.setWindowTitle("FFID already loaded")
+                        
+                        # Add custom buttons: Yes, Yes to All, No
+                        btn_yes = msg.addButton("Yes", QMessageBox.YesRole)
+                        btn_yes_all = msg.addButton("Yes to All", QMessageBox.YesRole)
+                        btn_no = msg.addButton("No", QMessageBox.NoRole)
+                        
+                        msg.setDefaultButton(btn_yes)
+                        msg.exec_()
+                        clicked = msg.clickedButton()
+                        
+                        if clicked == btn_yes_all:
+                            # Set flag to auto-increment for all remaining files
+                            self._auto_increment_ffid = True
+                            response = QMessageBox.Yes
+                        elif clicked == btn_yes:
+                            response = QMessageBox.Yes
+                        else:  # btn_no
+                            response = QMessageBox.No
+                    else:
+                        # User already chose "Yes to All", auto-increment
+                        response = QMessageBox.Yes
+                    
+                    if response == QMessageBox.Yes:
+                        # Increment FFID until we find an unused one
+                        while shot_number in self.ffid:
+                            shot_number += 1
+                        # Update metadata
+                        metadata['shot_number'] = shot_number
+                    else:
+                        # User declined FFID increment, skip this archive
+                        continue
+                    
+                    QApplication.setOverrideCursor(Qt.WaitCursor)
+                
+                # Add to file lists
+                file_name = os.path.basename(archive_path)
+                display_name = f"{file_name} (ASCII import)"
+                
+                self.fileNames.append(archive_path)
+                self.streams.append(stream)
+                
+                # Extend all other lists to match the new length
+                for attr in self.attributes_to_initialize:
+                    if attr not in ['fileNames', 'streams']:
+                        attr_list = getattr(self, attr)
+                        if attr_list is None:
+                            setattr(self, attr, [])
+                            attr_list = getattr(self, attr)
+                        attr_list.append(None)
+                
+                self.fileListWidget.addItem(display_name)
+                
+                # Get the index for this file
+                file_index = len(self.streams) - 1
+                
+                # Set up the stream properly
+                self.input_format[file_index] = check_format(stream)
+                
+                # Extract parameters from metadata (shot_number may have been incremented earlier)
+                num_traces = int(metadata.get('n_traces', len(stream)))
+                n_samples = int(metadata.get('n_samples', len(stream[0].data)))
+                dt = float(metadata.get('sampling_interval', stream[0].stats.delta))
+                shot_number = int(metadata.get('shot_number', 1))  # Use potentially incremented value
+                
+                # Set up time parameters FIRST (before extracting trace info)
+                self.n_sample[file_index] = n_samples
+                self.sample_interval[file_index] = dt
+                self.delay[file_index] = 0.0
+                self.time[file_index] = np.arange(n_samples) * dt
+                self.record_length[file_index] = self.time[file_index][-1]
+                self.ffid[file_index] = shot_number
+                
+                # Set up trace parameters
+                self.shot_trace_number[file_index] = list(range(1, num_traces + 1))
+                self.file_trace_number[file_index] = np.arange(1, num_traces + 1)
+                
+                # Extract positions from stream headers
+                trace_positions = []
+                trace_elevations = []
+                input_format = self.input_format[file_index]
+                
+                for tr in stream:
+                    try:
+                        coord_scalar = tr.stats[input_format].trace_header.scalar_to_be_applied_to_all_coordinates
+                        if coord_scalar < 0:
+                            coord_scalar = -1.0 / coord_scalar
+                        elif coord_scalar == 0:
+                            coord_scalar = 1.0
+                    except (AttributeError, KeyError):
+                        coord_scalar = 1.0
+                    
+                    try:
+                        elev_scalar = tr.stats[input_format].trace_header.scalar_to_be_applied_to_all_elevations_and_depths
+                        if elev_scalar < 0:
+                            elev_scalar = -1.0 / elev_scalar
+                        elif elev_scalar == 0:
+                            elev_scalar = 1.0
+                    except (AttributeError, KeyError):
+                        elev_scalar = coord_scalar
+                    
+                    try:
+                        pos = tr.stats[input_format].trace_header.group_coordinate_x * coord_scalar
+                    except (AttributeError, KeyError):
+                        pos = 0.0
+                    trace_positions.append(pos)
+                    
+                    try:
+                        elev = tr.stats[input_format].trace_header.receiver_group_elevation * elev_scalar
+                    except (AttributeError, KeyError):
+                        elev = 0.0
+                    trace_elevations.append(elev)
+                
+                self.trace_position[file_index] = trace_positions
+                self.trace_elevation[file_index] = trace_elevations
+                
+                # Set source position
+                source_x = float(metadata.get('source_x', 0.0))
+                source_z = float(metadata.get('source_z', 0.0))
+                self.source_position[file_index] = source_x
+                self.source_elevation[file_index] = source_z
+                
+                # Calculate offsets
+                self.offset[file_index] = [pos - source_x for pos in trace_positions]
+                
+                # Initialize picks and error arrays
+                self.picks[file_index] = [None] * num_traces
+                self.error[file_index] = [None] * num_traces
+                self.pickSeismoItems[file_index] = [None] * num_traces
+                self.pickLayoutItems[file_index] = [None] * num_traces
+                self.airWaveItems[file_index] = [None] * num_traces
+                self.dispersion_curves[file_index] = {}
+                
+                successful_imports += 1
+                
+            except Exception as e:
+                failed_imports.append((os.path.basename(archive_path), str(e)))
+                import traceback
+                traceback.print_exc()
+            finally:
+                QApplication.restoreOverrideCursor()
+        
+        # After processing all files, update UI and show results
+        if successful_imports > 0:
+            # Initialize plot labels if they don't exist
+            if not hasattr(self, 'x_label'):
+                self.x_label = 'Trace Number'
+            if not hasattr(self, 'y_label'):
+                self.y_label = 'Source Position (m)'
+            
+            # Select the last imported file
+            self.currentIndex = len(self.streams) - 1
+            self.fileListWidget.setCurrentRow(self.currentIndex)
             
-            # Create channel naming
-            stats.network = "XX"
-            stats.station = f"T{i+1:03d}"
-            stats.location = ""
-            stats.channel = "SHZ"  # Assume vertical seismometer
+            # Update the plot type dictionary
+            self.updatePlotTypeDict()
             
-            # Create the trace
-            trace = Trace(data=trace_data, header=stats)
-            stream.append(trace)
+            # Plot the new data
+            self.updatePlots()
         
-        return stream
+        # Show import summary
+        if failed_imports:
+            error_msg = f"Successfully imported {successful_imports} archive(s).\n\nFailed imports ({len(failed_imports)}):\n"
+            for fname, error in failed_imports[:5]:  # Show first 5 errors
+                error_msg += f"\n• {fname}: {error}"
+            if len(failed_imports) > 5:
+                error_msg += f"\n\n... and {len(failed_imports) - 5} more"
+            QMessageBox.warning(self, "Import Complete with Errors", error_msg)
+        elif successful_imports > 0:
+            QMessageBox.information(
+                self, "Import Successful", 
+                f"Successfully imported {successful_imports} ASCII archive(s)"
+            )
 
     #######################################
     # File loading and processing functions
@@ -11945,6 +12746,11 @@ class MainWindow(QMainWindow):
 
                     stream = swap_header_format(stream, format)
                     
+                    # Ensure data is float32 for SEGY/SU compatibility
+                    for trace in stream:
+                        if trace.data.dtype != np.float32:
+                            trace.data = trace.data.astype(np.float32)
+                    
                     # Save the stream as a SEGY or SU file
                     stream.write(savePath, format=format, 
                         data_encoding=5, byteorder='>')
@@ -11986,6 +12792,11 @@ class MainWindow(QMainWindow):
 
                             stream = swap_header_format(stream, self.output_format)
                             self.input_format[i] = check_format(stream)
+                            
+                            # Ensure data is float32 for SEGY/SU compatibility
+                            for trace in stream:
+                                if trace.data.dtype != np.float32:
+                                    trace.data = trace.data.astype(np.float32)
 
                             # Default file name is fileNames[i] without extension _ffid.format
                             # check if ffid is in the original file name
@@ -12026,6 +12837,11 @@ class MainWindow(QMainWindow):
                         merged_stream = swap_header_format(merged_stream, self.output_format)
                         for i, stream in enumerate(self.streams):
                             self.input_format[i] = check_format(stream)
+                        
+                        # Ensure data is float32 for SEGY/SU compatibility
+                        for trace in merged_stream:
+                            if trace.data.dtype != np.float32:
+                                trace.data = trace.data.astype(np.float32)
 
                         # Save the merged stream as a SEGY or SU file
                         merged_stream.write(savePath, format=self.output_format, 
@@ -12068,6 +12884,120 @@ class MainWindow(QMainWindow):
         # Save all shots in a single SU file
         self.output_format = 'SU'
         self.saveAllFiles(single=True)
+
+    def saveSingleFileASCII(self):
+        """Save the current shot as ASCII files in a tar.gz archive"""
+        if not self.streams:
+            QMessageBox.warning(self, "No Data", "No data loaded to save.")
+            return
+        
+        # Set the headers
+        self.setHeaders()
+        
+        # Get the directory to save the archive
+        if str(self.ffid[self.currentIndex]) in os.path.basename(self.currentFileName):
+            defaultSavePath = os.path.splitext(self.currentFileName)[0] + '.tar.gz'
+        else:
+            defaultSavePath = os.path.splitext(self.currentFileName)[0] + '_' + str(self.ffid[self.currentIndex]) + '.tar.gz'
+        
+        savePath, _ = QFileDialog.getSaveFileName(
+            self, "Save as ASCII archive", defaultSavePath, 
+            "TAR.GZ archives (*.tar.gz);;ZIP archives (*.zip)"
+        )
+        
+        if savePath:
+            QApplication.setOverrideCursor(Qt.WaitCursor)
+            try:
+                stream = self.streams[self.currentIndex]
+                shot_index = self.ffid[self.currentIndex]
+                
+                # Create temporary directory for the files
+                import tempfile
+                temp_dir = tempfile.mkdtemp()
+                
+                # Determine archive type
+                use_zip = savePath.endswith('.zip')
+                
+                # Export to ASCII
+                export_shot_to_ascii(stream, shot_index, temp_dir, archive=False)
+                
+                # Create archive
+                if use_zip:
+                    import zipfile
+                    with zipfile.ZipFile(savePath, 'w', zipfile.ZIP_DEFLATED) as zipf:
+                        for filename in os.listdir(temp_dir):
+                            file_path = os.path.join(temp_dir, filename)
+                            zipf.write(file_path, arcname=filename)
+                else:
+                    import tarfile
+                    with tarfile.open(savePath, "w:gz") as tar:
+                        for filename in os.listdir(temp_dir):
+                            file_path = os.path.join(temp_dir, filename)
+                            tar.add(file_path, arcname=filename)
+                
+                # Clean up temp directory
+                import shutil
+                shutil.rmtree(temp_dir)
+                
+                print(f"Saved single shot (ASCII): {savePath}")
+                QMessageBox.information(self, "File Saved", f"ASCII archive saved as:\n{savePath}")
+            except Exception as e:
+                QMessageBox.critical(self, "Save Error", f"Failed to save ASCII archive:\n{str(e)}")
+            finally:
+                QApplication.restoreOverrideCursor()
+
+    def saveAllFilesASCII(self):
+        """Save all shots as ASCII files in separate tar.gz archives"""
+        if not self.streams:
+            QMessageBox.warning(self, "No Data", "No data loaded to save.")
+            return
+        
+        # Set the headers
+        self.setHeaders()
+        
+        # Get the directory to save the archives
+        output_dir = QFileDialog.getExistingDirectory(
+            self, "Select Directory for ASCII Archives",
+            os.path.dirname(self.currentFileName) if self.currentFileName else ""
+        )
+        
+        if output_dir:
+            QApplication.setOverrideCursor(Qt.WaitCursor)
+            saved_count = 0
+            try:
+                for i, stream in enumerate(self.streams):
+                    shot_index = self.ffid[i]
+                    
+                    # Create temporary directory for the files
+                    import tempfile
+                    temp_dir = tempfile.mkdtemp()
+                    
+                    # Export to ASCII
+                    export_shot_to_ascii(stream, shot_index, temp_dir, archive=False)
+                    
+                    # Create archive
+                    archive_path = os.path.join(output_dir, f"shot_{shot_index:04d}.tar.gz")
+                    import tarfile
+                    with tarfile.open(archive_path, "w:gz") as tar:
+                        for filename in os.listdir(temp_dir):
+                            file_path = os.path.join(temp_dir, filename)
+                            tar.add(file_path, arcname=filename)
+                    
+                    # Clean up temp directory
+                    import shutil
+                    shutil.rmtree(temp_dir)
+                    
+                    saved_count += 1
+                    print(f"Saved shot {shot_index} (ASCII): {archive_path}")
+                
+                QMessageBox.information(
+                    self, "Files Saved", 
+                    f"Saved {saved_count} ASCII archives to:\n{output_dir}"
+                )
+            except Exception as e:
+                QMessageBox.critical(self, "Save Error", f"Failed to save ASCII archives:\n{str(e)}")
+            finally:
+                QApplication.restoreOverrideCursor()
                 
     def setHeaders(self):
         # Set stream headers based on self attributes
@@ -12075,6 +13005,26 @@ class MainWindow(QMainWindow):
         
         for i, st in enumerate(self.streams):
             input_format = check_format(st)
+            
+            # Calculate max coordinate value to adjust scalar if needed
+            max_coord = 0
+            for trace_index in range(len(st)):
+                max_coord = max(max_coord, 
+                               abs(self.source_position[i]) if self.source_position[i] is not None else 0,
+                               abs(self.trace_position[i][trace_index]) if self.trace_position[i][trace_index] is not None else 0,
+                               abs(self.trace_elevation[i][trace_index]) if self.trace_elevation[i][trace_index] is not None else 0,
+                               abs(self.source_elevation[i]) if self.source_elevation[i] is not None else 0)
+            
+            # Adjust scalar if values would exceed int16 range
+            if max_coord * coordinate_scalar >= 32000:
+                # Find appropriate scalar
+                if max_coord * 100 < 32000:
+                    coordinate_scalar = 100
+                elif max_coord * 10 < 32000:
+                    coordinate_scalar = 10
+                else:
+                    coordinate_scalar = 1
+            
             for trace_index, trace in enumerate(st):
                 trace.stats[input_format].trace_header.scalar_to_be_applied_to_all_coordinates = int(-coordinate_scalar)
                 trace.stats[input_format].trace_header.scalar_to_be_applied_to_all_elevations_and_depths = int(-coordinate_scalar)
@@ -12082,12 +13032,14 @@ class MainWindow(QMainWindow):
                 trace.stats[input_format].trace_header.delay_recording_time = int(self.delay[i]*1000)
                 trace.stats[input_format].trace_header.datum_elevation_at_receiver_group = int(np.round(np.mean(np.diff(self.trace_position[i])),self.rounding)*coordinate_scalar)
                 
-                trace.stats[input_format].trace_header.distance_from_center_of_the_source_point_to_the_center_of_the_receiver_group = int(self.source_position[i]*coordinate_scalar) - int(self.trace_position[i][trace_index]*coordinate_scalar)
-                trace.stats[input_format].trace_header.group_coordinate_x = int(self.trace_position[i][trace_index]*coordinate_scalar)
+                # Clamp all coordinate values to int16 range
+                offset_val = int(self.source_position[i]*coordinate_scalar) - int(self.trace_position[i][trace_index]*coordinate_scalar)
+                trace.stats[input_format].trace_header.distance_from_center_of_the_source_point_to_the_center_of_the_receiver_group = np.clip(offset_val, -32767, 32767)
+                trace.stats[input_format].trace_header.group_coordinate_x = np.clip(int(self.trace_position[i][trace_index]*coordinate_scalar), -32767, 32767)
                 trace.stats[input_format].trace_header.group_coordinate_y = int(0)
-                trace.stats[input_format].trace_header.receiver_group_elevation = int(self.trace_elevation[i][trace_index]*coordinate_scalar)
+                trace.stats[input_format].trace_header.receiver_group_elevation = np.clip(int(self.trace_elevation[i][trace_index]*coordinate_scalar), -32767, 32767)
                 
-                trace.stats[input_format].trace_header.source_coordinate_x = int(self.source_position[i]*coordinate_scalar)
+                trace.stats[input_format].trace_header.source_coordinate_x = np.clip(int(self.source_position[i]*coordinate_scalar), -32767, 32767)
                 trace.stats[input_format].trace_header.source_coordinate_y = int(0)
                 trace.stats[input_format].trace_header.surface_elevation_at_source = int(self.source_elevation[i]*coordinate_scalar)
         
@@ -12520,6 +13472,93 @@ class MainWindow(QMainWindow):
             dialog = HeaderDialog(files, list(attributes_to_collect.values()), header_values, self)
             dialog.exec_()
 
+    def showOverallHeaders(self):
+        """Show single values for each file (overall headers)"""
+        if self.streams:
+            files = [os.path.basename(file) for file in self.fileNames]
+            attributes_to_collect = {
+                "ffid": "FFID",
+                "delay": "Delay (s)",
+                "sample_interval": "Sample Interval (s)",
+                "n_sample": "Number of Samples",
+                "record_length": "Record Length (s)",
+                "source_position": "Source Position (m)",
+                "source_elevation": "Source Elevation (m)",
+            }
+
+            # Collect single values for each file
+            header_values = {}
+
+            for i, file in enumerate(files):
+                header_values[file] = {}
+                for header, display_name in attributes_to_collect.items():
+                    attribute_value = getattr(self, header, [])[i]
+                    # Store as single-element list for compatibility with HeaderDialog
+                    if isinstance(attribute_value, (list, tuple, np.ndarray)):
+                        # Take first value if it's a list
+                        header_values[file][display_name] = [attribute_value[0] if len(attribute_value) > 0 else 'N/A']
+                    else:
+                        header_values[file][display_name] = [attribute_value]
+                
+                # Add number of traces per shot
+                if i < len(self.streams) and self.streams[i]:
+                    header_values[file]["Number of Traces"] = [len(self.streams[i])]
+                else:
+                    header_values[file]["Number of Traces"] = ['N/A']
+                
+                # Add first trace position, elevation, and offset
+                if i < len(self.trace_position) and self.trace_position[i] is not None and len(self.trace_position[i]) > 0:
+                    header_values[file]["First Trace Position (m)"] = [self.trace_position[i][0]]
+                else:
+                    header_values[file]["First Trace Position (m)"] = ['N/A']
+                
+                if i < len(self.trace_elevation) and self.trace_elevation[i] is not None and len(self.trace_elevation[i]) > 0:
+                    header_values[file]["First Trace Elevation (m)"] = [self.trace_elevation[i][0]]
+                else:
+                    header_values[file]["First Trace Elevation (m)"] = ['N/A']
+                
+                if i < len(self.offset) and self.offset[i] is not None and len(self.offset[i]) > 0:
+                    header_values[file]["First Trace Offset (m)"] = [self.offset[i][0]]
+                else:
+                    header_values[file]["First Trace Offset (m)"] = ['N/A']
+                
+                # Add last trace position, elevation, and offset
+                if i < len(self.trace_position) and self.trace_position[i] is not None and len(self.trace_position[i]) > 0:
+                    header_values[file]["Last Trace Position (m)"] = [self.trace_position[i][-1]]
+                else:
+                    header_values[file]["Last Trace Position (m)"] = ['N/A']
+                
+                if i < len(self.trace_elevation) and self.trace_elevation[i] is not None and len(self.trace_elevation[i]) > 0:
+                    header_values[file]["Last Trace Elevation (m)"] = [self.trace_elevation[i][-1]]
+                else:
+                    header_values[file]["Last Trace Elevation (m)"] = ['N/A']
+                
+                if i < len(self.offset) and self.offset[i] is not None and len(self.offset[i]) > 0:
+                    header_values[file]["Last Trace Offset (m)"] = [self.offset[i][-1]]
+                else:
+                    header_values[file]["Last Trace Offset (m)"] = ['N/A']
+
+            # Create headers list in the desired order
+            headers = [
+                "FFID",
+                "Number of Traces",
+                "Delay (s)",
+                "Sample Interval (s)",
+                "Number of Samples",
+                "Record Length (s)",
+                "Source Position (m)",
+                "Source Elevation (m)",
+                "First Trace Position (m)",
+                "First Trace Elevation (m)",
+                "First Trace Offset (m)",
+                "Last Trace Position (m)",
+                "Last Trace Elevation (m)",
+                "Last Trace Offset (m)"
+            ]
+
+            dialog = OverallHeaderDialog(files, headers, header_values, self)
+            dialog.exec_()
+
     def editFFID(self):
         if self.streams:
             parameters = [
@@ -15499,6 +16538,85 @@ class MainWindow(QMainWindow):
         if self.pickLayoutItems[file_idx] is not None:
             self.pickLayoutItems[file_idx][first_trace:last_trace+1] = self.pickLayoutItems[file_idx][first_trace:last_trace+1][::-1]
 
+    def zeroPadTrace(self):
+        """Zero pad all traces in a shot by adding zeros at the end of the trace data."""
+        if self.streams:
+            parameters = [
+                {'label': 'Pad at end (seconds)', 'initial_value': 0.0, 'type': 'float'}
+            ]
+            
+            dialog = GenericParameterDialog(
+                title="Zero Pad Shot",
+                parameters=parameters,
+                add_checkbox=True,
+                checkbox_text="Apply to all shots",
+                parent=self
+            )
+            
+            if dialog.exec_():
+                values = dialog.getValues()
+                pad_end_seconds = values['Pad at end (seconds)']
+                apply_to_all = dialog.isChecked()
+                
+                # Validate inputs
+                if pad_end_seconds < 0:
+                    QMessageBox.warning(self, "Invalid Input", "Padding value must be non-negative")
+                    return
+                
+                if pad_end_seconds == 0:
+                    QMessageBox.warning(self, "Invalid Input", "Padding value must be greater than 0")
+                    return
+                
+                # Show wait cursor while processing
+                QApplication.setOverrideCursor(Qt.WaitCursor)
+                try:
+                    if apply_to_all:
+                        # Pad all traces for all files
+                        for i in range(len(self.streams)):
+                            # Convert seconds to samples
+                            pad_end = int(pad_end_seconds / self.sample_interval[i])
+                            
+                            # Pad all traces in this shot
+                            for trace_num in self.shot_trace_number[i]:
+                                self.streams[i] = zero_pad_trace(self.streams[i], trace_num, 0, pad_end)
+                            
+                            # Update n_sample and time array after padding
+                            if len(self.streams[i]) > 0:
+                                self.n_sample[i] = len(self.streams[i][0].data)
+                                self.time[i] = np.arange(self.n_sample[i]) * self.sample_interval[i] + self.delay[i]
+                            # Sync headers to obspy streams immediately
+                            self.syncHeadersToStreams(i)
+                        
+                        self.headers_modified = True
+                        QMessageBox.information(self, "Zero Padding Applied", 
+                            f"All traces padded with {pad_end_seconds} seconds at end for all shots")
+                    else:
+                        # Pad all traces for current file only
+                        # Convert seconds to samples
+                        pad_end = int(pad_end_seconds / self.sample_interval[self.currentIndex])
+                        
+                        # Pad all traces in this shot
+                        for trace_num in self.shot_trace_number[self.currentIndex]:
+                            self.streams[self.currentIndex] = zero_pad_trace(self.streams[self.currentIndex], trace_num, 0, pad_end)
+                        
+                        # Update n_sample and time array after padding
+                        if len(self.streams[self.currentIndex]) > 0:
+                            self.n_sample[self.currentIndex] = len(self.streams[self.currentIndex][0].data)
+                            self.time[self.currentIndex] = np.arange(self.n_sample[self.currentIndex]) * self.sample_interval[self.currentIndex] + self.delay[self.currentIndex]
+                        # Sync headers to obspy streams immediately
+                        self.syncHeadersToStreams(self.currentIndex)
+                        
+                        self.headers_modified = True
+                        QMessageBox.information(self, "Zero Padding Applied", 
+                            f"All traces padded with {pad_end_seconds} seconds at end")
+                    
+                    self.updatePlots()
+                    self.updateFileListDisplay()
+                    self.updatePlots()
+                finally:
+                    # Always restore cursor even if there's an error
+                    QApplication.restoreOverrideCursor()
+
     def batchEditFFID(self):
         if self.streams:
             parameters = [
@@ -16099,6 +17217,69 @@ class MainWindow(QMainWindow):
                     # Always restore cursor even if there's an error
                     QApplication.restoreOverrideCursor()
 
+    def batchZeroPadTraces(self):
+        """Batch zero pad all traces for a range of shots."""
+        if self.streams:
+            parameters = [
+                {'label': 'First Source #', 'initial_value': 1, 'type': 'int'},
+                {'label': 'Last Source #', 'initial_value': len(self.streams), 'type': 'int'},
+                {'label': 'Pad at end (seconds)', 'initial_value': 0.0, 'type': 'float'}
+            ]
+            
+            dialog = GenericParameterDialog(
+                title="Batch Zero Pad Shots",
+                parameters=parameters,
+                add_checkbox=False,
+                parent=self
+            )
+            
+            if dialog.exec_():
+                values = dialog.getValues()
+                first_shot = values['First Source #'] - 1
+                last_shot = values['Last Source #'] - 1
+                pad_end_seconds = values['Pad at end (seconds)']
+                
+                # Validate inputs
+                if pad_end_seconds < 0:
+                    QMessageBox.warning(self, "Invalid Input", "Padding value must be non-negative")
+                    return
+                
+                if pad_end_seconds == 0:
+                    QMessageBox.warning(self, "Invalid Input", "Padding value must be greater than 0")
+                    return
+                
+                # Show wait cursor while processing
+                QApplication.setOverrideCursor(Qt.WaitCursor)
+                try:
+                    # Pad all traces for specified range of shots
+                    for i in range(first_shot, min(last_shot + 1, len(self.streams))):
+                        # Convert seconds to samples for this file
+                        pad_end = int(pad_end_seconds / self.sample_interval[i])
+                        
+                        # Process all traces in this shot
+                        for trace_num in self.shot_trace_number[i]:
+                            self.streams[i] = zero_pad_trace(self.streams[i], trace_num, 0, pad_end)
+                        
+                        # Update n_sample and time array after padding
+                        if len(self.streams[i]) > 0:
+                            self.n_sample[i] = len(self.streams[i][0].data)
+                            self.time[i] = np.arange(self.n_sample[i]) * self.sample_interval[i] + self.delay[i]
+                        # Sync headers to obspy streams immediately after all padding for this file
+                        self.syncHeadersToStreams(i)
+                    
+                    # Mark headers/traces as modified so the unsaved-changes warning appears
+                    self.headers_modified = True
+                    
+                    QMessageBox.information(self, "Zero Padding Applied", 
+                        f"All traces padded with {pad_end_seconds} seconds at end for shots {first_shot+1} to {last_shot+1}")
+                    
+                    self.updatePlots()
+                    self.updateFileListDisplay()
+                    self.updatePlots()
+                finally:
+                    # Always restore cursor even if there's an error
+                    QApplication.restoreOverrideCursor()
+
     def batchReverseTraces(self):
         """Batch reverse trace data (flip data matrix left-to-right) while keeping headers in place"""
         if self.streams:
@@ -18411,8 +19592,10 @@ class MainWindow(QMainWindow):
                 plot_widget.plot(x_filled, t_interpolated, pen=None, 
                                     fillLevel=fillLevel, fillBrush=self.fill_brush)
 
-            # Plot the picks (only if picks have been initialized)
+            # Plot the picks (only if picks have been initialized and are not None)
             if (self.picks[self.currentIndex] is not None and 
+                i < len(self.picks[self.currentIndex]) and
+                self.picks[self.currentIndex][i] is not None and
                 not np.isnan(self.picks[self.currentIndex][i])):
                 # Get pick position
                 y_ok = self.picks[self.currentIndex][i]
@@ -18620,6 +19803,8 @@ class MainWindow(QMainWindow):
         
         for i in range(len(self.streams[self.currentIndex])):
             if (self.picks[self.currentIndex] is not None and 
+                i < len(self.picks[self.currentIndex]) and
+                self.picks[self.currentIndex][i] is not None and
                 not np.isnan(self.picks[self.currentIndex][i])):
                 # Get pick position
                 y_ok = self.picks[self.currentIndex][i]
@@ -18855,9 +20040,13 @@ class MainWindow(QMainWindow):
             plot_y = self.plotTypeDict[self.plotTypeY] # List of sources for the current trace
 
             if self.plotTypeY == 'offset':
-                y_all.extend(plot_y[i])
+                # Handle offset - ensure it's a list and no None values
+                offset_values = plot_y[i] if plot_y[i] is not None else [0.0] * m
+                y_all.extend(offset_values)
             else:
-                y_all.extend([plot_y[i]] * m)
+                # Handle other plot types - ensure no None values
+                y_value = plot_y[i] if plot_y[i] is not None else 0.0
+                y_all.extend([y_value] * m)
             
             # Only add picks if they have been initialized
             if self.picks[i] is not None:
@@ -18871,10 +20060,11 @@ class MainWindow(QMainWindow):
     def getAllPicks(self, x_all, y_all, pick_all):
         # Get all picks
 
-        # If there are picks that are not nan, plot them with colors      
-        x_pick = [x_all[i] for i in range(len(x_all)) if not np.isnan(pick_all[i])]
-        y_pick = [y_all[i] for i in range(len(y_all)) if not np.isnan(pick_all[i])]
-        pick_all = [pick_all[i] for i in range(len(pick_all)) if not np.isnan(pick_all[i])]
+        # If there are picks that are not nan, plot them with colors
+        # Filter out None values and NaN values
+        x_pick = [x_all[i] for i in range(len(x_all)) if pick_all[i] is not None and not np.isnan(pick_all[i])]
+        y_pick = [y_all[i] for i in range(len(y_all)) if pick_all[i] is not None and not np.isnan(pick_all[i])]
+        pick_all = [pick_all[i] for i in range(len(pick_all)) if pick_all[i] is not None and not np.isnan(pick_all[i])]
 
         return x_pick, y_pick, pick_all
     
@@ -18915,14 +20105,16 @@ class MainWindow(QMainWindow):
 
         x_all, y_all, pick_all = self.getAllPositions()
 
-        scatter = pqg.ScatterPlotItem(x=x_all, y=y_all, symbol='o',
-                                    brush=self.fill_brush, size=5) 
-        plot_widget.addItem(scatter)
+        # Only create scatter plot if we have valid positions
+        if len(x_all) > 0 and len(y_all) > 0:
+            scatter = pqg.ScatterPlotItem(x=x_all, y=y_all, symbol='o',
+                                        brush=self.fill_brush, size=5) 
+            plot_widget.addItem(scatter)
 
         x_pick, y_pick, pick_all = self.getAllPicks(x_all, y_all, pick_all)
 
         # If there are more than one pick, plot them with colors
-        if len(x_pick) > 1:
+        if len(x_pick) > 1 and len(pick_all) > 0:
 
             # Remove colorbar if it exists
             self.removeColorBar()
@@ -18930,10 +20122,12 @@ class MainWindow(QMainWindow):
             # Create a colormap
             self.createPicksColorMap()
 
-            # Create ScatterPlotItem with colors
-            scatter = pqg.ScatterPlotItem(x=x_pick, y=y_pick, symbol='s', 
-                                        brush=self.colors, pen=self.colors, size=8)
-            plot_widget.addItem(scatter)
+            # Only create scatter if we have colors (check again after createPicksColorMap)
+            if hasattr(self, 'colors') and len(self.colors) > 0 and len(x_pick) == len(self.colors):
+                # Create ScatterPlotItem with colors (only if we have valid data)
+                scatter = pqg.ScatterPlotItem(x=x_pick, y=y_pick, symbol='s', 
+                                            brush=self.colors, pen=self.colors, size=8)
+                plot_widget.addItem(scatter)
 
             # Add colorbar when there are picks
             self.colorbar = pqg.ColorBarItem(colorMap=self.colormap, values=(min(pick_all), max(pick_all)),
@@ -21343,7 +22537,14 @@ class MainWindow(QMainWindow):
         self.colormap = pqg.colormap.get(colormap_str, source='matplotlib')
 
         # Get the values of the picks that are not nan in a list of list
-        values = [value for sublist in self.picks for value in sublist if not np.isnan(value)]
+        # Filter out None values before checking for NaN
+        values = [value for sublist in self.picks for value in sublist if value is not None and not np.isnan(value)]
+
+        # Check if we have any valid values
+        if not values:
+            # No valid picks, create a dummy colormap
+            self.colors = []
+            return
 
         # Normalize the values to the range [0, 1]
         min_val = min(values)
@@ -21775,8 +22976,171 @@ Failed to match: {skipped_no_trace_found}"""
         
         return picks_matched, len(sources_with_picks), max_pick_time
 
+    def _loadPicksFromLST(self, lst_file, verbose=False):
+        """
+        Load picks from a Rayfract .LST file.
+        
+        Parameters
+        ----------
+        lst_file : str
+            Path to .LST file
+        verbose : bool
+            Print debug information
+        
+        Returns
+        -------
+        tuple
+            (n_picks_in_file, n_matched_picks)
+        """
+        from .pick_io import read_lst_file, match_lst_picks_to_geometry
+        
+        try:
+            # Read LST file
+            lst_data = read_lst_file(lst_file, verbose=verbose)
+            
+            if lst_data['n_picks'] == 0:
+                QMessageBox.warning(self, "No Picks", f"No valid picks found in {os.path.basename(lst_file)}")
+                return 0, 0
+            
+            # Calculate position scaling factor
+            # Compare median geophone spacing in LST to mean_dg in seismic data
+            position_scale = 1.0
+            
+            # Calculate median spacing from LST positions
+            all_positions = [pos for _, _, pos, _ in lst_data['picks']]
+            if len(all_positions) > 1:
+                unique_positions = sorted(set(all_positions))
+                if len(unique_positions) > 1:
+                    spacings = [unique_positions[i+1] - unique_positions[i] 
+                               for i in range(len(unique_positions)-1)]
+                    median_spacing_lst = np.median(spacings)
+                    
+                    # Use self.mean_dg from seismic data
+                    if hasattr(self, 'mean_dg') and self.mean_dg is not None and self.mean_dg > 0:
+                        if median_spacing_lst > 0:
+                            position_scale = self.mean_dg / median_spacing_lst
+            
+            # Match picks to current geometry
+            matched = match_lst_picks_to_geometry(
+                lst_data,
+                self.trace_position,
+                self.source_position,
+                shot_number_offset=0,  # Could be made configurable via dialog
+                position_tolerance=0.1,  # Could be made configurable via dialog
+                position_scale=position_scale,
+                verbose=False
+            )
+            
+            # Apply matched picks
+            for i, (pick_list, error_list) in enumerate(zip(matched['picks'], matched['errors'])):
+                if self.picks[i] is None:
+                    self.picks[i] = [np.nan] * len(pick_list)
+                if self.error[i] is None:
+                    self.error[i] = [0.001] * len(error_list)
+                
+                for j, (pick, error) in enumerate(zip(pick_list, error_list)):
+                    if not np.isnan(pick):
+                        self.picks[i][j] = pick
+                        self.error[i][j] = error
+            
+            # Mark picks as modified
+            self.picks_modified = True
+            
+            # Trigger pick update
+            self.update_pick_flag = True
+            
+            # Only show warning if no picks were matched
+            if matched['n_matched'] == 0:
+                QMessageBox.warning(self, "No Matches",
+                                  f"Could not match any picks from {os.path.basename(lst_file)} to current geometry.\n\n"
+                                  f"File contains {matched['n_total']} picks but none matched.")
+            
+            return lst_data['n_picks'], matched['n_matched']
+            
+        except Exception as e:
+            QMessageBox.critical(self, "Error Loading LST File",
+                               f"Error reading {os.path.basename(lst_file)}:\n\n{str(e)}")
+            if verbose:
+                import traceback
+                traceback.print_exc()
+            return 0, 0
+
+    def _loadPicksFromVS(self, vs_file, verbose=False):
+        """
+        Load picks from a SeisImager/PickWin .vs file.
+        
+        Parameters
+        ----------
+        vs_file : str
+            Path to .vs file
+        verbose : bool
+            Print debug information
+        
+        Returns
+        -------
+        tuple
+            (n_picks_in_file, n_matched_picks)
+        """
+        from .pick_io import read_vs_file, match_vs_picks_to_geometry
+        
+        try:
+            # Read VS file
+            vs_data = read_vs_file(vs_file, verbose=verbose)
+            
+            if vs_data['n_picks'] == 0:
+                QMessageBox.warning(self, "No Picks", f"No valid picks found in {os.path.basename(vs_file)}")
+                return 0, 0
+            
+            # Calculate position scaling factor
+            # VS files use absolute positions for shots and geophones
+            position_scale = 1.0
+            
+            # Match picks to current geometry
+            matched = match_vs_picks_to_geometry(
+                vs_data,
+                self.trace_position,
+                self.source_position,
+                offset_tolerance=0.5,  # Could be made configurable via dialog
+                position_scale=position_scale,
+                verbose=False
+            )
+            
+            # Apply matched picks
+            for i, (pick_list, error_list) in enumerate(zip(matched['picks'], matched['errors'])):
+                if self.picks[i] is None:
+                    self.picks[i] = [np.nan] * len(pick_list)
+                if self.error[i] is None:
+                    self.error[i] = [0.001] * len(error_list)
+                
+                for j, (pick, error) in enumerate(zip(pick_list, error_list)):
+                    if not np.isnan(pick):
+                        self.picks[i][j] = pick
+                        self.error[i][j] = error
+            
+            # Mark picks as modified
+            self.picks_modified = True
+            
+            # Trigger pick update
+            self.update_pick_flag = True
+            
+            # Only show warning if no picks were matched
+            if matched['n_matched'] == 0:
+                QMessageBox.warning(self, "No Matches",
+                                  f"Could not match any picks from {os.path.basename(vs_file)} to current geometry.\n\n"
+                                  f"File contains {matched['n_total']} picks but none matched.")
+            
+            return vs_data['n_picks'], matched['n_matched']
+            
+        except Exception as e:
+            QMessageBox.critical(self, "Error Loading VS File",
+                               f"Error reading {os.path.basename(vs_file)}:\n\n{str(e)}")
+            if verbose:
+                import traceback
+                traceback.print_exc()
+            return 0, 0
+
     def loadPicks(self, fname=None, verbose=False):
-        # Load picks from single or multiple pygimli .sgt files
+        # Load picks from .sgt (PyGimli), .LST (Rayfract), or .vs (PickWin) files
         
         # Check if seismic data is loaded first
         if not self.streams:
@@ -21786,7 +23150,7 @@ Failed to match: {skipped_no_trace_found}"""
         # The first argument returned is the filename(s) and path(s)
         if fname is None or not fname:
             fnames, _ = QFileDialog.getOpenFileNames(
-                self, 'Open file(s)', filter='Source-Geophone-Time file (*.sgt)')
+                self, 'Open file(s)', filter='Pick files (*.sgt *.LST *.lst *.vs);;SGT files (*.sgt);;LST files (*.LST *.lst);;VS files (*.vs)')
         else:
             # If fname is provided, ensure it's a list for consistent processing
             if isinstance(fname, str):
@@ -21797,7 +23161,7 @@ Failed to match: {skipped_no_trace_found}"""
         if fnames:
             # Initialize counters for all files
             total_picks_loaded = 0
-            total_picks_in_files = 0  # Track total picks across all SGT files
+            total_picks_in_files = 0  # Track total picks across all files
             total_sources_loaded = 0
             overall_max_picked_time = 0
             
@@ -21806,6 +23170,28 @@ Failed to match: {skipped_no_trace_found}"""
                 if verbose:
                     print(f"\nProcessing file {file_idx + 1}/{len(fnames)}: {fname}")
                 
+                # Detect file type by extension
+                file_ext = fname.lower().split('.')[-1]
+                
+                if file_ext == 'lst':
+                    # Load LST (Rayfract) file
+                    n_picks_file, n_matched = self._loadPicksFromLST(fname, verbose=verbose)
+                    total_picks_in_files += n_picks_file
+                    total_picks_loaded += n_matched
+                    if n_matched > 0:
+                        total_sources_loaded += 1
+                    continue  # Skip to next file
+                
+                if file_ext == 'vs':
+                    # Load VS (PickWin/SeisImager) file
+                    n_picks_file, n_matched = self._loadPicksFromVS(fname, verbose=verbose)
+                    total_picks_in_files += n_picks_file
+                    total_picks_loaded += n_matched
+                    if n_matched > 0:
+                        total_sources_loaded += 1
+                    continue  # Skip to next file
+                
+                # Default: Load SGT (PyGimli) file
                 with open(fname, 'r') as f:
                     # Read number of stations
                     n_stations = int(f.readline().split('#')[0].strip())