batplot 1.8.4__py3-none-any.whl → 1.8.5__py3-none-any.whl

batplot/interactive.py

@@ -57,6 +57,7 @@ from .color_utils import (
     ensure_colormap,
     _CUSTOM_CMAPS,
 )
+from .config import load_config, save_config
 
 
 class _FilterIMKWarning:
@@ -253,16 +254,16 @@ def interactive_menu(fig, ax, y_data_list, x_data_list, labels, orig_y,
                 has_cif = bool(getattr(_bp, 'cif_tick_series', None))
         except Exception:
             pass
-        col1 = ["c: colors", "f: font", "l: line", "t: toggle axes", "g: size", "h: legend"]
+        col1 = ["c: colors", "f: font", "l: line", "t: toggle axes", "g: size", "h: legend", "sm: smooth"]
         if has_cif:
             col1.append("z: hkl")
             col1.append("j: CIF titles")
-        col2 = ["a: rearrange", "d: offset", "r: rename", "x: change X", "y: change Y"]
+        col2 = ["a: rearrange", "o: offset", "r: rename", "x: change X", "y: change Y", "d: derivative"]
         col3 = ["v: find peaks", "n: crosshair", "p: print(export) style/geom", "i: import style/geom", "e: export figure", "s: save project", "b: undo", "q: quit"]
         
         # Hide offset/y-range in stack mode
         if args.stack:
-            col2 = [item for item in col2 if not item.startswith("d:") and not item.startswith("y:")]
+            col2 = [item for item in col2 if not item.startswith("o:") and not item.startswith("y:")]
         
         if not is_diffraction:
             col3 = [item for item in col3 if not item.startswith("n:")]
@@ -884,7 +885,17 @@ def interactive_menu(fig, ax, y_data_list, x_data_list, labels, orig_y,
     # NEW: style / diagnostics printer (clean version)
     def print_style_info():
         cts = getattr(_bp, 'cif_tick_series', None) if _bp is not None else None
-        show_hkl = bool(getattr(_bp, 'show_cif_hkl', False)) if _bp is not None else None
+        # Read show_cif_hkl from __main__ module (where it's stored when toggled)
+        show_hkl = None
+        try:
+            _bp_module = sys.modules.get('__main__')
+            if _bp_module is not None and hasattr(_bp_module, 'show_cif_hkl'):
+                show_hkl = bool(getattr(_bp_module, 'show_cif_hkl', False))
+        except Exception:
+            pass
+        # Fall back to _bp object if not in __main__
+        if show_hkl is None and _bp is not None:
+            show_hkl = bool(getattr(_bp, 'show_cif_hkl', False)) if hasattr(_bp, 'show_cif_hkl') else None
         return _bp_print_style_info(
             fig, ax,
             y_data_list, labels,
@@ -1083,6 +1094,342 @@ def interactive_menu(fig, ax, y_data_list, x_data_list, labels, orig_y,
     # history management:
     state_history = []
 
+    # ====================================================================
+    # SMOOTHING AND REDUCE ROWS HELPER FUNCTIONS
+    # ====================================================================
+    
+    def _savgol_kernel(window: int, poly: int) -> np.ndarray:
+        """Return Savitzky–Golay smoothing kernel of given window/poly."""
+        half = window // 2
+        x = np.arange(-half, half + 1, dtype=float)
+        A = np.vander(x, poly + 1, increasing=True)
+        ATA = A.T @ A
+        ATA_inv = np.linalg.pinv(ATA)
+        target = np.zeros(poly + 1, dtype=float)
+        target[0] = 1.0  # evaluate polynomial at x=0
+        coeffs = target @ ATA_inv @ A.T
+        return coeffs
+
+    def _savgol_smooth(y: np.ndarray, window: int = 9, poly: int = 3) -> np.ndarray:
+        """Apply Savitzky–Golay smoothing (defaults from DiffCapAnalyzer) to data."""
+        n = y.size
+        if n < 3:
+            return y
+        if window > n:
+            window = n if n % 2 == 1 else n - 1
+        if window < 3:
+            return y
+        if window % 2 == 0:
+            window -= 1
+        if window < 3:
+            return y
+        if poly >= window:
+            poly = window - 1
+        coeffs = _savgol_kernel(window, poly)
+        half = window // 2
+        padded = np.pad(y, (half, half), mode='edge')
+        smoothed = np.convolve(padded, coeffs[::-1], mode='valid')
+        return smoothed
+
+    def _fft_smooth(y: np.ndarray, points: int = 5, cutoff: float = 0.1) -> np.ndarray:
+        """Apply FFT filter smoothing to data."""
+        n = y.size
+        if n < 3:
+            return y
+        # FFT
+        fft_vals = np.fft.rfft(y)
+        freq = np.fft.rfftfreq(n)
+        # Low-pass filter: zero out frequencies above cutoff
+        mask = freq <= cutoff
+        fft_vals[~mask] = 0
+        # Inverse FFT
+        smoothed = np.fft.irfft(fft_vals, n)
+        return smoothed
+
+    def _adjacent_average_smooth(y: np.ndarray, points: int = 5) -> np.ndarray:
+        """Apply Adjacent-Averaging smoothing to data."""
+        n = y.size
+        if n < points:
+            return y
+        if points < 2:
+            return y
+        # Use convolution for moving average
+        kernel = np.ones(points) / points
+        # Pad edges
+        padded = np.pad(y, (points//2, points//2), mode='edge')
+        smoothed = np.convolve(padded, kernel, mode='valid')
+        return smoothed
+
+    def _get_last_reduce_rows_settings(method: str) -> dict:
+        """Get last reduce rows settings from config file.
+        
+        Args:
+            method: Method name ('delete_skip', 'delete_missing', 'merge')
+        
+        Returns:
+            Dictionary with last settings for the method, or empty dict if none
+        """
+        config = load_config()
+        last_settings = config.get('last_reduce_rows_settings', {})
+        return last_settings.get(method, {})
+    
+    def _save_last_reduce_rows_settings(method: str, settings: dict) -> None:
+        """Save last reduce rows settings to config file.
+        
+        Args:
+            method: Method name ('delete_skip', 'delete_missing', 'merge')
+            settings: Dictionary with settings to save
+        """
+        config = load_config()
+        if 'last_reduce_rows_settings' not in config:
+            config['last_reduce_rows_settings'] = {}
+        config['last_reduce_rows_settings'][method] = settings
+        save_config(config)
+    
+    def _get_last_smooth_settings_from_config() -> dict:
+        """Get last smooth settings from config file (persistent across sessions).
+        
+        Returns:
+            Dictionary with last smooth settings, or empty dict if none
+        """
+        config = load_config()
+        return config.get('last_smooth_settings', {})
+    
+    def _save_last_smooth_settings_to_config(settings: dict) -> None:
+        """Save last smooth settings to config file (persistent across sessions).
+        
+        Args:
+            settings: Dictionary with smooth settings to save
+        """
+        config = load_config()
+        config['last_smooth_settings'] = settings
+        save_config(config)
+    
+    def _ensure_original_data():
+        """Ensure original data is stored for all curves."""
+        if not hasattr(fig, '_original_x_data_list'):
+            fig._original_x_data_list = [np.array(a, copy=True) for a in x_data_list]
+            fig._original_y_data_list = [np.array(a, copy=True) for a in y_data_list]
+    
+    def _update_full_processed_data():
+        """Update the full processed data (after all processing steps, before any X-range filtering)."""
+        # This stores the complete processed data (reduce + smooth + derivative) for X-range filtering
+        fig._full_processed_x_data_list = [np.array(a, copy=True) for a in x_data_list]
+        fig._full_processed_y_data_list = [np.array(a, copy=True) for a in y_data_list]
+    
+    def _reset_to_original():
+        """Reset all curves to original data."""
+        if not hasattr(fig, '_original_x_data_list'):
+            return (False, 0, 0)
+        reset_count = 0
+        total_points = 0
+        for i in range(min(len(fig._original_x_data_list), len(ax.lines))):
+            try:
+                orig_x = fig._original_x_data_list[i]
+                orig_y = fig._original_y_data_list[i]
+                # Restore offsets
+                if i < len(offsets_list):
+                    orig_y_with_offset = orig_y + offsets_list[i]
+                else:
+                    orig_y_with_offset = orig_y.copy()
+                ax.lines[i].set_data(orig_x, orig_y_with_offset)
+                x_data_list[i] = orig_x.copy()
+                y_data_list[i] = orig_y_with_offset.copy()
+                reset_count += 1
+                total_points += len(orig_x)
+            except Exception:
+                pass
+        # Clear processing settings
+        if hasattr(fig, '_smooth_settings'):
+            delattr(fig, '_smooth_settings')
+        return (reset_count > 0, reset_count, total_points)
+
+    def _apply_data_changes():
+        """Update plot and data lists after data modification."""
+        for i in range(min(len(ax.lines), len(x_data_list), len(y_data_list))):
+            try:
+                ax.lines[i].set_data(x_data_list[i], y_data_list[i])
+            except Exception:
+                pass
+        try:
+            fig.canvas.draw_idle()
+        except Exception:
+            pass
+
+    def _calculate_derivative(x: np.ndarray, y: np.ndarray, order: int = 1) -> np.ndarray:
+        """Calculate 1st or 2nd derivative using numpy gradient.
+        
+        Args:
+            x: X values
+            y: Y values
+            order: 1 for first derivative (dy/dx), 2 for second derivative (d²y/dx²)
+        
+        Returns:
+            Derivative array (same length as input)
+        """
+        if len(y) < 2:
+            return y.copy()
+        # Calculate dy/dx
+        dy_dx = np.gradient(y, x)
+        if order == 1:
+            return dy_dx
+        elif order == 2:
+            # Calculate d²y/dx² = d(dy/dx)/dx
+            if len(dy_dx) < 2:
+                return np.zeros_like(y)
+            d2y_dx2 = np.gradient(dy_dx, x)
+            return d2y_dx2
+        else:
+            return y.copy()
+    
+    def _calculate_reversed_derivative(x, y, order):
+        """Calculate reversed 1st or 2nd derivative (dx/dy or d²x/dy²).
+        
+        Args:
+            x: X values
+            y: Y values
+            order: 1 for first reversed derivative (dx/dy), 2 for second reversed derivative (d²x/dy²)
+        
+        Returns:
+            Reversed derivative array (same length as input)
+        """
+        if len(y) < 2:
+            return y.copy()
+        # First calculate dy/dx
+        dy_dx = np.gradient(y, x)
+        # Avoid division by zero - replace zeros with small epsilon
+        epsilon = 1e-10
+        dy_dx_safe = np.where(np.abs(dy_dx) < epsilon, np.sign(dy_dx) * epsilon, dy_dx)
+        # Calculate dx/dy = 1 / (dy/dx)
+        dx_dy = 1.0 / dy_dx_safe
+        if order == 1:
+            return dx_dy
+        elif order == 2:
+            # Calculate d²x/dy² = d(dx/dy)/dy
+            # d(dx/dy)/dy = d(1/(dy/dx))/dy = -1/(dy/dx)² * d²y/dx²
+            if len(dx_dy) < 2:
+                return np.zeros_like(y)
+            # Calculate d²y/dx² first
+            d2y_dx2 = np.gradient(dy_dx, x)
+            # d²x/dy² = -d²y/dx² / (dy/dx)³
+            d2x_dy2 = -d2y_dx2 / (dy_dx_safe ** 3)
+            return d2x_dy2
+        else:
+            return y.copy()
+
+    def _update_ylabel_for_derivative(order: int, current_label: str = None, is_reversed: bool = False) -> str:
+        """Generate appropriate y-axis label for derivative.
+        
+        Args:
+            order: 1 for first derivative, 2 for second derivative
+            current_label: Current y-axis label (optional)
+            is_reversed: True for reversed derivative (dx/dy), False for normal (dy/dx)
+        
+        Returns:
+            New y-axis label string
+        """
+        if current_label is None:
+            current_label = ax.get_ylabel() or "Y"
+        
+        # Try to detect common patterns and update accordingly
+        current_lower = current_label.lower()
+        
+        if is_reversed:
+            # Reversed derivative: dx/dy or d²x/dy²
+            y_label = current_label if current_label and current_label != "Y" else (ax.get_ylabel() or "Y")
+            if order == 1:
+                # First reversed derivative: dx/dy
+                if x_label:
+                    return f"d({x_label})/d({y_label})"
+                else:
+                    return f"dx/d({y_label})"
+            else:  # order == 2
+                # Second reversed derivative: d²x/dy²
+                if x_label:
+                    return f"d²({x_label})/d({y_label})²"
+                else:
+                    return f"d²x/d({y_label})²"
+        
+        # Normal derivative: dy/dx or d²y/dx²
+        if order == 1:
+            # First derivative: dy/dx or dY/dX
+            if "/" in current_label:
+                # If already has derivative notation, try to increment
+                if "d²" in current_label or "d2" in current_lower:
+                    # Change from 2nd to 1st (shouldn't normally happen, but handle it)
+                    new_label = current_label.replace("d²", "d").replace("d2", "d")
+                    return new_label
+                elif "d" in current_label.lower() and "/" in current_label:
+                    # Already has derivative, keep as is but update order if needed
+                    return current_label
+            # Add d/dx prefix or suffix
+            if x_label:
+                if any(op in current_label for op in ["/", "(", "["]):
+                    # Complex label, prepend d/dx
+                    return f"d({current_label})/d({x_label})"
+                else:
+                    # Simple label, use d/dx notation
+                    return f"d({current_label})/d({x_label})"
+            else:
+                return f"d({current_label})/dx"
+        else:  # order == 2
+            # Second derivative: d²y/dx² or d2Y/dX2
+            if "/" in current_label:
+                if "d²" in current_label or "d2" in current_lower:
+                    # Already 2nd derivative, keep as is
+                    return current_label
+                elif "d" in current_label.lower() and "/" in current_label:
+                    # First derivative, convert to second
+                    new_label = current_label.replace("d(", "d²(").replace("d2(", "d²(").replace("d/", "d²/").replace("/d(", "²/d(")
+                    return new_label
+            # Add d²/dx² prefix
+            if x_label:
+                if any(op in current_label for op in ["/", "(", "["]):
+                    return f"d²({current_label})/d({x_label})²"
+                else:
+                    return f"d²({current_label})/d({x_label})²"
+            else:
+                return f"d²({current_label})/dx²"
+        
+        return current_label
+
+    def _ensure_pre_derivative_data():
+        """Ensure pre-derivative data is stored for reset."""
+        if not hasattr(fig, '_pre_derivative_x_data_list'):
+            fig._pre_derivative_x_data_list = [np.array(a, copy=True) for a in x_data_list]
+            fig._pre_derivative_y_data_list = [np.array(a, copy=True) for a in y_data_list]
+            fig._pre_derivative_ylabel = ax.get_ylabel() or ""
+
+    def _reset_from_derivative():
+        """Reset all curves from derivative back to pre-derivative state."""
+        if not hasattr(fig, '_pre_derivative_x_data_list'):
+            return (False, 0, 0)
+        reset_count = 0
+        total_points = 0
+        for i in range(min(len(fig._pre_derivative_x_data_list), len(ax.lines))):
+            try:
+                pre_x = fig._pre_derivative_x_data_list[i]
+                pre_y = fig._pre_derivative_y_data_list[i]
+                # Restore offsets
+                if i < len(offsets_list):
+                    pre_y_with_offset = pre_y + offsets_list[i]
+                else:
+                    pre_y_with_offset = pre_y.copy()
+                ax.lines[i].set_data(pre_x, pre_y_with_offset)
+                x_data_list[i] = pre_x.copy()
+                y_data_list[i] = pre_y_with_offset.copy()
+                reset_count += 1
+                total_points += len(pre_x)
+            except Exception:
+                pass
+        # Restore y-axis label
+        if hasattr(fig, '_pre_derivative_ylabel'):
+            ax.set_ylabel(fig._pre_derivative_ylabel)
+        # Clear derivative settings
+        if hasattr(fig, '_derivative_order'):
+            delattr(fig, '_derivative_order')
+        return (reset_count > 0, reset_count, total_points)
+
     def push_state(note=""):
         """Snapshot current editable state (before a modifying action)."""
         try:
@@ -1161,6 +1508,26 @@ def interactive_menu(fig, ax, y_data_list, x_data_list, labels, orig_y,
             snap["y_data_list"] = [np.array(a, copy=True) for a in y_data_list]
             snap["orig_y"]      = [np.array(a, copy=True) for a in orig_y]
             snap["offsets"]     = list(offsets_list)
+            # Processed data (for smooth/reduce operations)
+            if hasattr(fig, '_original_x_data_list'):
+                snap["original_x_data_list"] = [np.array(a, copy=True) for a in fig._original_x_data_list]
+                snap["original_y_data_list"] = [np.array(a, copy=True) for a in fig._original_y_data_list]
+            if hasattr(fig, '_full_processed_x_data_list'):
+                snap["full_processed_x_data_list"] = [np.array(a, copy=True) for a in fig._full_processed_x_data_list]
+                snap["full_processed_y_data_list"] = [np.array(a, copy=True) for a in fig._full_processed_y_data_list]
+            if hasattr(fig, '_smooth_settings'):
+                snap["smooth_settings"] = dict(fig._smooth_settings)
+            if hasattr(fig, '_last_smooth_settings'):
+                snap["last_smooth_settings"] = dict(fig._last_smooth_settings)
+            # Derivative data (for derivative operations)
+            if hasattr(fig, '_pre_derivative_x_data_list'):
+                snap["pre_derivative_x_data_list"] = [np.array(a, copy=True) for a in fig._pre_derivative_x_data_list]
+                snap["pre_derivative_y_data_list"] = [np.array(a, copy=True) for a in fig._pre_derivative_y_data_list]
+                snap["pre_derivative_ylabel"] = str(getattr(fig, '_pre_derivative_ylabel', ''))
+            if hasattr(fig, '_derivative_order'):
+                snap["derivative_order"] = int(fig._derivative_order)
+            if hasattr(fig, '_derivative_reversed'):
+                snap["derivative_reversed"] = bool(fig._derivative_reversed)
             # Label text content
             snap["label_texts"] = [t.get_text() for t in label_text_objects]
             state_history.append(snap)
@@ -1381,12 +1748,72 @@ def interactive_menu(fig, ax, y_data_list, x_data_list, labels, orig_y,
             offsets_list[:] = list(snap["offsets"]) 
             delta = snap.get("delta", delta)
             
+            # Restore processed data (for smooth/reduce operations)
+            if "original_x_data_list" in snap:
+                fig._original_x_data_list = [np.array(a, copy=True) for a in snap["original_x_data_list"]]
+                fig._original_y_data_list = [np.array(a, copy=True) for a in snap["original_y_data_list"]]
+            elif hasattr(fig, '_original_x_data_list'):
+                # Clear if not in snapshot
+                delattr(fig, '_original_x_data_list')
+                delattr(fig, '_original_y_data_list')
+            if "full_processed_x_data_list" in snap:
+                fig._full_processed_x_data_list = [np.array(a, copy=True) for a in snap["full_processed_x_data_list"]]
+                fig._full_processed_y_data_list = [np.array(a, copy=True) for a in snap["full_processed_y_data_list"]]
+            elif hasattr(fig, '_full_processed_x_data_list'):
+                # Clear if not in snapshot
+                delattr(fig, '_full_processed_x_data_list')
+                delattr(fig, '_full_processed_y_data_list')
+            if "smooth_settings" in snap:
+                fig._smooth_settings = dict(snap["smooth_settings"])
+            elif hasattr(fig, '_smooth_settings'):
+                delattr(fig, '_smooth_settings')
+            if "last_smooth_settings" in snap:
+                fig._last_smooth_settings = dict(snap["last_smooth_settings"])
+            elif hasattr(fig, '_last_smooth_settings'):
+                delattr(fig, '_last_smooth_settings')
+            # Restore derivative data (for derivative operations)
+            if "pre_derivative_x_data_list" in snap:
+                fig._pre_derivative_x_data_list = [np.array(a, copy=True) for a in snap["pre_derivative_x_data_list"]]
+                fig._pre_derivative_y_data_list = [np.array(a, copy=True) for a in snap["pre_derivative_y_data_list"]]
+                fig._pre_derivative_ylabel = str(snap.get("pre_derivative_ylabel", ""))
+            elif hasattr(fig, '_pre_derivative_x_data_list'):
+                delattr(fig, '_pre_derivative_x_data_list')
+                delattr(fig, '_pre_derivative_y_data_list')
+                if hasattr(fig, '_pre_derivative_ylabel'):
+                    delattr(fig, '_pre_derivative_ylabel')
+            if "derivative_order" in snap:
+                fig._derivative_order = int(snap["derivative_order"])
+            elif hasattr(fig, '_derivative_order'):
+                delattr(fig, '_derivative_order')
+            if "derivative_reversed" in snap:
+                fig._derivative_reversed = bool(snap["derivative_reversed"])
+            elif hasattr(fig, '_derivative_reversed'):
+                delattr(fig, '_derivative_reversed')
+            # Restore y-axis label if derivative was applied
+            if "derivative_order" in snap:
+                try:
+                    current_ylabel = ax.get_ylabel() or ""
+                    order = int(snap["derivative_order"])
+                    is_reversed = snap.get("derivative_reversed", False)
+                    new_ylabel = _update_ylabel_for_derivative(order, current_ylabel, is_reversed=is_reversed)
+                    ax.set_ylabel(new_ylabel)
+                except Exception:
+                    pass
+            
             # Recalculate y_data_list from orig_y and offsets_list to ensure consistency
+            # Ensure lists have the same length before assigning
+            max_len = max(len(orig_y), len(y_data_list), len(offsets_list))
+            while len(orig_y) < max_len:
+                orig_y.append(np.array([]))
+            while len(y_data_list) < max_len:
+                y_data_list.append(np.array([]))
+            while len(offsets_list) < max_len:
+                offsets_list.append(0.0)
             for i in range(len(orig_y)):
                 if i < len(offsets_list):
                     y_data_list[i] = orig_y[i] + offsets_list[i]
                 else:
-                    y_data_list[i] = orig_y[i].copy()
+                    y_data_list[i] = orig_y[i].copy() if orig_y[i].size > 0 else np.array([])
             
             # Update line data with restored values
             for i in range(min(len(ax.lines), len(x_data_list), len(y_data_list))):
@@ -1423,7 +1850,15 @@ def interactive_menu(fig, ax, y_data_list, x_data_list, labels, orig_y,
                     pass
             if _bp is not None and 'show_cif_hkl' in snap:
                 try:
-                    setattr(_bp, 'show_cif_hkl', bool(snap['show_cif_hkl']))
+                    new_state = bool(snap['show_cif_hkl'])
+                    setattr(_bp, 'show_cif_hkl', new_state)
+                    # Also store in __main__ module so draw function can access it
+                    try:
+                        _bp_module = sys.modules.get('__main__')
+                        if _bp_module is not None:
+                            setattr(_bp_module, 'show_cif_hkl', new_state)
+                    except Exception:
+                        pass
                 except Exception:
                     pass
             if _bp is not None and 'show_cif_titles' in snap:
@@ -1508,8 +1943,16 @@ def interactive_menu(fig, ax, y_data_list, x_data_list, labels, orig_y,
             try:
                 # Flip visibility flag in batplot module
                 cur = bool(getattr(_bp, 'show_cif_hkl', False)) if _bp is not None else False
+                new_state = not cur
                 if _bp is not None:
-                    setattr(_bp, 'show_cif_hkl', not cur)
+                    setattr(_bp, 'show_cif_hkl', new_state)
+                # Also store in __main__ module so draw function can access it
+                try:
+                    _bp_module = sys.modules.get('__main__')
+                    if _bp_module is not None:
+                        setattr(_bp_module, 'show_cif_hkl', new_state)
+                except Exception:
+                    pass
                 # Avoid re-entrant extension while redrawing
                 prev_ext = bool(getattr(_bp, 'cif_extend_suspended', False)) if _bp is not None else False
                 if _bp is not None:
@@ -2433,7 +2876,49 @@ def interactive_menu(fig, ax, y_data_list, x_data_list, labels, orig_y,
                                 print("Invalid value, ignored.")
                                 continue
                             push_state("xrange")
-                            ax.set_xlim(current_xlim[0], new_upper)
+                            new_min = current_xlim[0]
+                            new_max = new_upper
+                            ax.set_xlim(new_min, new_max)
+                            # Re-filter data from original processed data if available
+                            data_is_processed = (hasattr(fig, '_original_x_data_list') or 
+                                               hasattr(fig, '_smooth_settings') or 
+                                               hasattr(fig, '_derivative_order') or
+                                               hasattr(fig, '_pre_derivative_x_data_list'))
+                            if data_is_processed and hasattr(fig, '_original_x_data_list'):
+                                for i in range(len(labels)):
+                                    if i < len(fig._original_x_data_list):
+                                        x_current = fig._original_x_data_list[i]
+                                        y_current = fig._original_y_data_list[i]
+                                        if i < len(offsets_list):
+                                            y_current_no_offset = y_current - offsets_list[i]
+                                        else:
+                                            y_current_no_offset = y_current.copy()
+                                        mask = (x_current >= new_min) & (x_current <= new_max)
+                                        x_sub = np.asarray(x_current[mask], dtype=float).flatten()
+                                        y_sub = np.asarray(y_current_no_offset[mask], dtype=float).flatten()
+                                        if x_sub.size == 0:
+                                            ax.lines[i].set_data([], [])
+                                            x_data_list[i] = np.array([], dtype=float)
+                                            y_data_list[i] = np.array([], dtype=float)
+                                            if i < len(orig_y):
+                                                orig_y[i] = np.array([], dtype=float)
+                                            continue
+                                        if i < len(offsets_list):
+                                            y_sub = y_sub + offsets_list[i]
+                                        ax.lines[i].set_data(x_sub, y_sub)
+                                        x_data_list[i] = np.asarray(x_sub, dtype=float).flatten()
+                                        y_data_list[i] = np.asarray(y_sub, dtype=float).flatten()
+                                        # Update orig_y with robust method
+                                        while len(orig_y) <= i:
+                                            orig_y.append(np.array([], dtype=float))
+                                        try:
+                                            y_no_offset = y_sub - offsets_list[i] if i < len(offsets_list) else y_sub
+                                            y_no_offset_1d = np.array(y_no_offset, dtype=float).ravel()
+                                            if i < len(orig_y):
+                                                del orig_y[i]
+                                            orig_y.insert(i, y_no_offset_1d)
+                                        except Exception:
+                                            pass
                             ax.relim()
                             ax.autoscale_view(scalex=False, scaley=True)
                             update_labels(ax, y_data_list, label_text_objects, args.stack, getattr(fig, '_stack_label_at_bottom', False))
@@ -2464,7 +2949,49 @@ def interactive_menu(fig, ax, y_data_list, x_data_list, labels, orig_y,
                                 print("Invalid value, ignored.")
                                 continue
                             push_state("xrange")
-                            ax.set_xlim(new_lower, current_xlim[1])
+                            new_min = new_lower
+                            new_max = current_xlim[1]
+                            ax.set_xlim(new_min, new_max)
+                            # Re-filter data from original processed data if available
+                            data_is_processed = (hasattr(fig, '_original_x_data_list') or 
+                                               hasattr(fig, '_smooth_settings') or 
+                                               hasattr(fig, '_derivative_order') or
+                                               hasattr(fig, '_pre_derivative_x_data_list'))
+                            if data_is_processed and hasattr(fig, '_original_x_data_list'):
+                                for i in range(len(labels)):
+                                    if i < len(fig._original_x_data_list):
+                                        x_current = fig._original_x_data_list[i]
+                                        y_current = fig._original_y_data_list[i]
+                                        if i < len(offsets_list):
+                                            y_current_no_offset = y_current - offsets_list[i]
+                                        else:
+                                            y_current_no_offset = y_current.copy()
+                                        mask = (x_current >= new_min) & (x_current <= new_max)
+                                        x_sub = np.asarray(x_current[mask], dtype=float).flatten()
+                                        y_sub = np.asarray(y_current_no_offset[mask], dtype=float).flatten()
+                                        if x_sub.size == 0:
+                                            ax.lines[i].set_data([], [])
+                                            x_data_list[i] = np.array([], dtype=float)
+                                            y_data_list[i] = np.array([], dtype=float)
+                                            if i < len(orig_y):
+                                                orig_y[i] = np.array([], dtype=float)
+                                            continue
+                                        if i < len(offsets_list):
+                                            y_sub = y_sub + offsets_list[i]
+                                        ax.lines[i].set_data(x_sub, y_sub)
+                                        x_data_list[i] = np.asarray(x_sub, dtype=float).flatten()
+                                        y_data_list[i] = np.asarray(y_sub, dtype=float).flatten()
+                                        # Update orig_y with robust method
+                                        while len(orig_y) <= i:
+                                            orig_y.append(np.array([], dtype=float))
+                                        try:
+                                            y_no_offset = y_sub - offsets_list[i] if i < len(offsets_list) else y_sub
+                                            y_no_offset_1d = np.array(y_no_offset, dtype=float).ravel()
+                                            if i < len(orig_y):
+                                                del orig_y[i]
+                                            orig_y.insert(i, y_no_offset_1d)
+                                        except Exception:
+                                            pass
                             ax.relim()
                             ax.autoscale_view(scalex=False, scaley=True)
                             update_labels(ax, y_data_list, label_text_objects, args.stack, getattr(fig, '_stack_label_at_bottom', False))
@@ -2482,22 +3009,266 @@ def interactive_menu(fig, ax, y_data_list, x_data_list, labels, orig_y,
                             print(f"X range updated: {ax.get_xlim()[0]:.6g} to {ax.get_xlim()[1]:.6g}")
                         continue
                     if rng.lower() == 'a':
-                        # Auto: restore original range from x_full_list
+                        # Auto: restore original range from CURRENT PROCESSED data (not original unprocessed)
                         push_state("xrange-auto")
-                        if x_full_list:
+                        try:
+                            # Check if data has been processed
+                            data_is_processed = (hasattr(fig, '_original_x_data_list') or 
+                                               hasattr(fig, '_smooth_settings') or 
+                                               hasattr(fig, '_derivative_order') or
+                                               hasattr(fig, '_pre_derivative_x_data_list'))
+                            if data_is_processed and x_data_list and all(xd.size > 0 for xd in x_data_list):
+                                # Use CURRENT processed data to determine full range (preserves all processing)
+                                print(f"DEBUG: Using current processed data for auto restore (has {len(x_data_list)} curves)")
+                                new_min = min(xd.min() for xd in x_data_list if xd.size)
+                                new_max = max(xd.max() for xd in x_data_list if xd.size)
+                                print(f"DEBUG: Processed data range: {new_min:.6g} to {new_max:.6g}")
+                            elif x_full_list:
+                                print(f"DEBUG: Using original full data (no processing detected)")
+                                new_min = min(xf.min() for xf in x_full_list if xf.size)
+                                new_max = max(xf.max() for xf in x_full_list if xf.size)
+                            else:
+                                print("No original data available.")
+                                continue
+                            # Restore all data - use CURRENT PROCESSED data (preserves all processing steps)
+                            for i in range(len(labels)):
+                                if data_is_processed and hasattr(fig, '_full_processed_x_data_list') and i < len(fig._full_processed_x_data_list):
+                                    # Use FULL processed data (preserves all processing: reduce + smooth + derivative)
+                                    print(f"DEBUG: Auto restore curve {i+1}: Using full processed data ({len(fig._full_processed_x_data_list[i])} points)")
+                                    xf = np.asarray(fig._full_processed_x_data_list[i], dtype=float).flatten()
+                                    yf = np.asarray(fig._full_processed_y_data_list[i], dtype=float).flatten()
+                                    yf_raw = yf - (offsets_list[i] if i < len(offsets_list) else 0.0)
+                                elif data_is_processed and i < len(x_data_list) and x_data_list[i].size > 0:
+                                    # Fallback: use current processed data
+                                    print(f"DEBUG: Auto restore curve {i+1}: Using current processed data ({len(x_data_list[i])} points)")
+                                    xf = np.asarray(x_data_list[i], dtype=float).flatten()
+                                    yf = np.asarray(y_data_list[i], dtype=float).flatten()
+                                    yf_raw = yf - (offsets_list[i] if i < len(offsets_list) else 0.0)
+                                else:
+                                    # Use full original data (no processing)
+                                    print(f"DEBUG: Auto restore curve {i+1}: Using original full data")
+                                    xf = x_full_list[i] if i < len(x_full_list) else x_data_list[i]
+                                    yf_raw = raw_y_full_list[i] if i < len(raw_y_full_list) else (orig_y[i] if i < len(orig_y) else y_data_list[i])
+                                    xf = np.asarray(xf, dtype=float).flatten()
+                                    yf_raw = np.asarray(yf_raw, dtype=float).flatten()
+                                mask = (xf >= new_min) & (xf <= new_max)
+                                x_sub = np.asarray(xf[mask], dtype=float).flatten()
+                                y_sub_raw = np.asarray(yf_raw[mask], dtype=float).flatten()
+                                if x_sub.size == 0:
+                                    ax.lines[i].set_data([], [])
+                                    x_data_list[i] = np.array([], dtype=float)
+                                    y_data_list[i] = np.array([], dtype=float)
+                                    if i < len(orig_y):
+                                        orig_y[i] = np.array([], dtype=float)
+                                    continue
+                                should_normalize = args.stack or getattr(args, 'norm', False)
+                                if should_normalize:
+                                    if y_sub_raw.size:
+                                        y_min = float(y_sub_raw.min())
+                                        y_max = float(y_sub_raw.max())
+                                        span = y_max - y_min
+                                        if span > 0:
+                                            y_sub_norm = (y_sub_raw - y_min) / span
+                                        else:
+                                            y_sub_norm = np.zeros_like(y_sub_raw)
+                                    else:
+                                        y_sub_norm = y_sub_raw
+                                else:
+                                    y_sub_norm = y_sub_raw
+                                offset_val = offsets_list[i] if i < len(offsets_list) else 0.0
+                                y_with_offset = y_sub_norm + offset_val
+                                ax.lines[i].set_data(x_sub, y_with_offset)
+                                x_data_list[i] = np.asarray(x_sub, dtype=float).flatten()
+                                y_data_list[i] = np.asarray(y_with_offset, dtype=float).flatten()
+                                # Ensure orig_y list has enough elements
+                                while len(orig_y) <= i:
+                                    orig_y.append(np.array([], dtype=float))
+                                # Create a new 1D array - ensure it's a proper numpy array
+                                # Handle all edge cases: scalar, 0-d array, multi-d array
+                                try:
+                                    if isinstance(y_sub_norm, np.ndarray):
+                                        if y_sub_norm.ndim == 0:
+                                            y_sub_norm_1d = np.array([float(y_sub_norm)], dtype=float)
+                                        else:
+                                            y_sub_norm_1d = np.array(y_sub_norm.flatten(), dtype=float, copy=True)
+                                    else:
+                                        # It's a scalar or list
+                                        y_sub_norm_1d = np.array(y_sub_norm, dtype=float).flatten()
+                                    # Ensure it's 1D
+                                    if y_sub_norm_1d.ndim != 1:
+                                        y_sub_norm_1d = y_sub_norm_1d.reshape(-1)
+                                    # Replace list element - delete old one first if needed
+                                    if i < len(orig_y):
+                                        del orig_y[i]
+                                    orig_y.insert(i, y_sub_norm_1d)
+                                except Exception as e:
+                                    # Fallback: just create a simple array
+                                    try:
+                                        y_sub_norm_1d = np.array(y_sub_norm, dtype=float).ravel()
+                                        if i < len(orig_y):
+                                            orig_y[i] = y_sub_norm_1d
+                                        else:
+                                            orig_y.append(y_sub_norm_1d)
+                                    except Exception:
+                                        # Last resort: skip orig_y update
+                                        pass
+                            ax.set_xlim(new_min, new_max)
+                            ax.relim(); ax.autoscale_view(scalex=False, scaley=True)
+                            update_labels(ax, y_data_list, label_text_objects, args.stack, getattr(fig, '_stack_label_at_bottom', False))
+                            try:
+                                if hasattr(ax, '_cif_extend_func'):
+                                    ax._cif_extend_func(ax.get_xlim()[1])
+                            except Exception:
+                                pass
+                            try:
+                                if hasattr(ax, '_cif_draw_func'):
+                                    ax._cif_draw_func()
+                            except Exception:
+                                pass
+                            fig.canvas.draw()
+                            print(f"X range restored to original: {ax.get_xlim()[0]:.6g} to {ax.get_xlim()[1]:.6g}")
+                        except Exception as e:
+                            print(f"Error during auto restore: {e}")
+                            import traceback
+                            traceback.print_exc()
+                        continue
+                    push_state("xrange")
+                    if rng.lower() == 'full':
+                        # Use full data if available, otherwise use current processed data
+                        if x_full_list and all(xf.size > 0 for xf in x_full_list):
                             new_min = min(xf.min() for xf in x_full_list if xf.size)
                             new_max = max(xf.max() for xf in x_full_list if xf.size)
                         else:
-                            print("No original data available.")
-                            continue
-                        # Restore all data
-                        for i in range(len(labels)):
-                            xf = x_full_list[i]; yf_raw = raw_y_full_list[i]
-                            mask = (xf>=new_min) & (xf<=new_max)
-                            x_sub = xf[mask]; y_sub_raw = yf_raw[mask]
+                            new_min = min(xd.min() for xd in x_data_list if xd.size)
+                            new_max = max(xd.max() for xd in x_data_list if xd.size)
+                    else:
+                        new_min, new_max = map(float, rng.split())
+                    ax.set_xlim(new_min, new_max)
+                    # Check if data has been processed (smooth/derivative/reduce)
+                    data_is_processed = (hasattr(fig, '_original_x_data_list') or 
+                                       hasattr(fig, '_smooth_settings') or 
+                                       hasattr(fig, '_derivative_order') or
+                                       hasattr(fig, '_pre_derivative_x_data_list'))
+                    
+                    for i in range(len(labels)):
+                        if data_is_processed and i < len(x_data_list) and x_data_list[i].size > 0:
+                            # Use full processed data if available (allows expansion), otherwise use current filtered data
+                            curr_x = np.asarray(x_data_list[i], dtype=float)
+                            curr_min = curr_x.min() if curr_x.size > 0 else float('inf')
+                            curr_max = curr_x.max() if curr_x.size > 0 else float('-inf')
+                            
+                            # Check if we need full processed data (for expansion beyond current filter)
+                            need_full = (new_min < curr_min or new_max > curr_max)
+                            
+                            if need_full and hasattr(fig, '_full_processed_x_data_list') and i < len(fig._full_processed_x_data_list):
+                                # Use full processed data to allow expansion
+                                full_x = np.asarray(fig._full_processed_x_data_list[i], dtype=float)
+                                if full_x.size > 0:
+                                    full_min = full_x.min()
+                                    full_max = full_x.max()
+                                    print(f"DEBUG: Curve {i+1}: Expanding range ({curr_min:.6g}-{curr_max:.6g} -> {new_min:.6g}-{new_max:.6g}), using full processed data (range {full_min:.6g} to {full_max:.6g})")
+                                    x_current = full_x
+                                    y_current = np.asarray(fig._full_processed_y_data_list[i], dtype=float)
+                                else:
+                                    print(f"DEBUG: Curve {i+1}: Full processed data empty, using current data")
+                                    x_current = curr_x
+                                    y_current = np.asarray(y_data_list[i], dtype=float)
+                            else:
+                                print(f"DEBUG: Curve {i+1}: Using current processed data (range {curr_min:.6g} to {curr_max:.6g}, requested {new_min:.6g} to {new_max:.6g})")
+                                x_current = curr_x
+                                y_current = np.asarray(y_data_list[i], dtype=float)
+                            # Remove offset for filtering
+                            if i < len(offsets_list):
+                                y_current_no_offset = y_current - offsets_list[i]
+                            else:
+                                y_current_no_offset = y_current.copy()
+                            mask = (x_current >= new_min) & (x_current <= new_max)
+                            x_sub = np.asarray(x_current[mask], dtype=float).flatten()
+                            y_sub = np.asarray(y_current_no_offset[mask], dtype=float).flatten()
+                            if x_sub.size == 0:
+                                ax.lines[i].set_data([], [])
+                                x_data_list[i] = np.array([], dtype=float)
+                                y_data_list[i] = np.array([], dtype=float)
+                                if i < len(orig_y):
+                                    orig_y[i] = np.array([], dtype=float)
+                                continue
+                            # Restore offset
+                            if i < len(offsets_list):
+                                y_sub = y_sub + offsets_list[i]
+                            ax.lines[i].set_data(x_sub, y_sub)
+                            x_data_list[i] = np.asarray(x_sub, dtype=float).flatten()
+                            y_data_list[i] = np.asarray(y_sub, dtype=float).flatten()
+                            # Update orig_y
+                            # Update orig_y with robust method
+                            while len(orig_y) <= i:
+                                orig_y.append(np.array([], dtype=float))
+                            try:
+                                y_no_offset = y_sub - offsets_list[i] if i < len(offsets_list) else y_sub
+                                y_no_offset_1d = np.array(y_no_offset, dtype=float).ravel()
+                                if i < len(orig_y):
+                                    del orig_y[i]
+                                orig_y.insert(i, y_no_offset_1d)
+                            except Exception:
+                                pass
+                        elif data_is_processed and i < len(x_data_list) and x_data_list[i].size > 0:
+                            # Fallback: use current data if _original_x_data_list not available
+                            x_current = np.asarray(x_data_list[i], dtype=float)
+                            y_current = np.asarray(y_data_list[i], dtype=float)
+                            mask = (x_current >= new_min) & (x_current <= new_max)
+                            x_sub = np.asarray(x_current[mask], dtype=float).flatten()
+                            y_sub = np.asarray(y_current[mask], dtype=float).flatten()
                             if x_sub.size == 0:
                                 ax.lines[i].set_data([], [])
-                                y_data_list[i] = np.array([]); orig_y[i] = np.array([]); continue
+                                x_data_list[i] = np.array([], dtype=float)
+                                y_data_list[i] = np.array([], dtype=float)
+                                if i < len(orig_y):
+                                    orig_y[i] = np.array([], dtype=float)
+                                continue
+                            ax.lines[i].set_data(x_sub, y_sub)
+                            x_data_list[i] = np.asarray(x_sub, dtype=float).flatten()
+                            y_data_list[i] = np.asarray(y_sub, dtype=float).flatten()
+                            # Update orig_y - use same robust method as in 'a' branch
+                            while len(orig_y) <= i:
+                                orig_y.append(np.array([], dtype=float))
+                            try:
+                                y_no_offset = y_sub - offsets_list[i] if i < len(offsets_list) else y_sub
+                                if isinstance(y_no_offset, np.ndarray):
+                                    if y_no_offset.ndim == 0:
+                                        y_no_offset_1d = np.array([float(y_no_offset)], dtype=float)
+                                    else:
+                                        y_no_offset_1d = np.array(y_no_offset.flatten(), dtype=float, copy=True)
+                                else:
+                                    y_no_offset_1d = np.array(y_no_offset, dtype=float).flatten()
+                                if y_no_offset_1d.ndim != 1:
+                                    y_no_offset_1d = y_no_offset_1d.reshape(-1)
+                                if i < len(orig_y):
+                                    del orig_y[i]
+                                orig_y.insert(i, y_no_offset_1d)
+                            except Exception:
+                                try:
+                                    y_no_offset = y_sub - offsets_list[i] if i < len(offsets_list) else y_sub
+                                    y_no_offset_1d = np.array(y_no_offset, dtype=float).ravel()
+                                    if i < len(orig_y):
+                                        orig_y[i] = y_no_offset_1d
+                                    else:
+                                        orig_y.append(y_no_offset_1d)
+                                except Exception:
+                                    pass
+                        else:
+                            # Use original full data as source
+                            xf = x_full_list[i] if i < len(x_full_list) else x_data_list[i]
+                            yf_raw = raw_y_full_list[i] if i < len(raw_y_full_list) else (orig_y[i] if i < len(orig_y) else y_data_list[i])
+                            mask = (xf >= new_min) & (xf <= new_max)
+                            x_sub = np.array(xf[mask], copy=True)
+                            y_sub_raw = np.array(yf_raw[mask], copy=True)
+                            if x_sub.size == 0:
+                                ax.lines[i].set_data([], [])
+                                x_data_list[i] = np.array([])
+                                y_data_list[i] = np.array([])
+                                if i < len(orig_y):
+                                    orig_y[i] = np.array([])
+                                continue
+                            # Auto-normalize for --stack mode, or explicit --norm flag
                             should_normalize = args.stack or getattr(args, 'norm', False)
                             if should_normalize:
                                 if y_sub_raw.size:
@@ -2512,63 +3283,13 @@ def interactive_menu(fig, ax, y_data_list, x_data_list, labels, orig_y,
                                     y_sub_norm = y_sub_raw
                             else:
                                 y_sub_norm = y_sub_raw
-                            offset_val = offsets_list[i]
+                            offset_val = offsets_list[i] if i < len(offsets_list) else 0.0
                             y_with_offset = y_sub_norm + offset_val
                             ax.lines[i].set_data(x_sub, y_with_offset)
                             x_data_list[i] = x_sub
                             y_data_list[i] = y_with_offset
-                            orig_y[i] = y_sub_norm
-                        ax.set_xlim(new_min, new_max)
-                        ax.relim(); ax.autoscale_view(scalex=False, scaley=True)
-                        update_labels(ax, y_data_list, label_text_objects, args.stack, getattr(fig, '_stack_label_at_bottom', False))
-                        try:
-                            if hasattr(ax, '_cif_extend_func'):
-                                ax._cif_extend_func(ax.get_xlim()[1])
-                        except Exception:
-                            pass
-                        try:
-                            if hasattr(ax, '_cif_draw_func'):
-                                ax._cif_draw_func()
-                        except Exception:
-                            pass
-                        fig.canvas.draw()
-                        print(f"X range restored to original: {ax.get_xlim()[0]:.6g} to {ax.get_xlim()[1]:.6g}")
-                        continue
-                    push_state("xrange")
-                    if rng.lower() == 'full':
-                        new_min = min(xf.min() for xf in x_full_list if xf.size)
-                        new_max = max(xf.max() for xf in x_full_list if xf.size)
-                    else:
-                        new_min, new_max = map(float, rng.split())
-                    ax.set_xlim(new_min, new_max)
-                    for i in range(len(labels)):
-                        xf = x_full_list[i]; yf_raw = raw_y_full_list[i]
-                        mask = (xf>=new_min) & (xf<=new_max)
-                        x_sub = xf[mask]; y_sub_raw = yf_raw[mask]
-                        if x_sub.size == 0:
-                            ax.lines[i].set_data([], [])
-                            y_data_list[i] = np.array([]); orig_y[i] = np.array([]); continue
-                        # Auto-normalize for --stack mode, or explicit --norm flag
-                        should_normalize = args.stack or getattr(args, 'norm', False)
-                        if should_normalize:
-                            if y_sub_raw.size:
-                                y_min = float(y_sub_raw.min())
-                                y_max = float(y_sub_raw.max())
-                                span = y_max - y_min
-                                if span > 0:
-                                    y_sub_norm = (y_sub_raw - y_min) / span
-                                else:
-                                    y_sub_norm = np.zeros_like(y_sub_raw)
-                            else:
-                                y_sub_norm = y_sub_raw
-                        else:
-                            y_sub_norm = y_sub_raw
-                        offset_val = offsets_list[i]
-                        y_with_offset = y_sub_norm + offset_val
-                        ax.lines[i].set_data(x_sub, y_with_offset)
-                        x_data_list[i] = x_sub
-                        y_data_list[i] = y_with_offset
-                        orig_y[i] = y_sub_norm
+                            if i < len(orig_y):
+                                orig_y[i] = y_sub_norm
                     ax.relim(); ax.autoscale_view(scalex=False, scaley=True)
                     update_labels(ax, y_data_list, label_text_objects, args.stack, getattr(fig, '_stack_label_at_bottom', False))
                     # Extend CIF ticks after x-range change
@@ -2697,7 +3418,98 @@ def interactive_menu(fig, ax, y_data_list, x_data_list, labels, orig_y,
                     print(f"Y range set to ({float(ymin)}, {float(ymax)})")
                 except Exception as e:
                     print(f"Error setting Y-axis range: {e}")
-        elif key == 'd':  # <-- DELTA / OFFSET HANDLER (now only reachable if not args.stack)
+        elif key == 'd':  # <-- DERIVATIVE HANDLER
+            while True:
+                try:
+                    print("\n\033[1mDerivative Menu\033[0m")
+                    print("Commands:")
+                    print("  1: Calculate 1st derivative (dy/dx)")
+                    print("  2: Calculate 2nd derivative (d²y/dx²)")
+                    print("  3: Calculate reversed 1st derivative (dx/dy)")
+                    print("  4: Calculate reversed 2nd derivative (d²x/dy²)")
+                    print("  reset: Reset to data before derivative")
+                    print("  q: back to main menu")
+                    sub = _safe_input(colorize_prompt("d> ")).strip().lower()
+                    if not sub or sub == 'q':
+                        break
+                    if sub == 'reset':
+                        push_state("derivative-reset")
+                        success, reset_count, total_points = _reset_from_derivative()
+                        if success:
+                            print(f"Reset {reset_count} curve(s) from derivative to original data ({total_points} total points restored).")
+                            ax.relim()
+                            ax.autoscale_view(scalex=False, scaley=True)
+                            update_labels(ax, y_data_list, label_text_objects, args.stack, getattr(fig, '_stack_label_at_bottom', False))
+                            _apply_data_changes()
+                        else:
+                            print("No derivative data to reset.")
+                        continue
+                    if sub in ('1', '2', '3', '4'):
+                        try:
+                            option = int(sub)
+                            is_reversed = (option == 3 or option == 4)
+                            order = 1 if option in (1, 3) else 2
+                            push_state(f"derivative-{option}")
+                            _ensure_pre_derivative_data()
+                            processed = 0
+                            total_points = 0
+                            for i in range(len(x_data_list)):
+                                try:
+                                    # Use current data (may already be processed)
+                                    current_x = x_data_list[i].copy()
+                                    current_y = y_data_list[i].copy()
+                                    # Remove offset for processing
+                                    if i < len(offsets_list):
+                                        current_y_no_offset = current_y - offsets_list[i]
+                                    else:
+                                        current_y_no_offset = current_y.copy()
+                                    n_points = len(current_y_no_offset)
+                                    if n_points < 2:
+                                        print(f"Curve {i+1} has too few points (<2) for derivative calculation.")
+                                        continue
+                                    # Calculate derivative
+                                    if is_reversed:
+                                        derivative_y = _calculate_reversed_derivative(current_x, current_y_no_offset, order)
+                                    else:
+                                        derivative_y = _calculate_derivative(current_x, current_y_no_offset, order)
+                                    if len(derivative_y) > 0:
+                                        # Restore offset
+                                        if i < len(offsets_list):
+                                            derivative_y = derivative_y + offsets_list[i]
+                                        # Update data (keep same x, replace y with derivative)
+                                        x_data_list[i] = current_x.copy()
+                                        y_data_list[i] = derivative_y
+                                        processed += 1
+                                        total_points += n_points
+                                except Exception as e:
+                                    print(f"Error processing curve {i+1}: {e}")
+                            if processed > 0:
+                                # Update y-axis label
+                                current_ylabel = ax.get_ylabel() or ""
+                                new_ylabel = _update_ylabel_for_derivative(order, current_ylabel, is_reversed=is_reversed)
+                                ax.set_ylabel(new_ylabel)
+                                # Store derivative order and reversed flag
+                                fig._derivative_order = order
+                                fig._derivative_reversed = is_reversed
+                                # Update plot
+                                _apply_data_changes()
+                                ax.relim()
+                                ax.autoscale_view(scalex=False, scaley=True)
+                                update_labels(ax, y_data_list, label_text_objects, args.stack, getattr(fig, '_stack_label_at_bottom', False))
+                                fig.canvas.draw_idle()
+                                order_name = "1st" if order == 1 else "2nd"
+                                direction = "reversed " if is_reversed else ""
+                                print(f"Applied {direction}{order_name} derivative to {processed} curve(s) with {total_points} total points.")
+                                print(f"Y-axis label updated to: {new_ylabel}")
+                                _update_full_processed_data()  # Store full processed data for X-range filtering
+                            else:
+                                print("No curves were processed.")
+                        except ValueError:
+                            print("Invalid input.")
+                        continue
+                except Exception as e:
+                    print(f"Error in derivative menu: {e}")
+        elif key == 'o':  # <-- OFFSET HANDLER (now only reachable if not args.stack)
             print("\n\033[1mOffset adjustment menu:\033[0m")
             print(f"  {colorize_menu('1-{}: adjust individual curve offset'.format(len(labels)))}")
             print(f"  {colorize_menu('a: set spacing between curves')}")
@@ -3797,6 +4609,668 @@ def interactive_menu(fig, ax, y_data_list, x_data_list, labels, orig_y,
                         fig.canvas.draw()
             except Exception as e:
                 print(f"Error saving figure: {e}")
+        elif key == 'sm':
+            # Smoothing and data reduction menu
+            _ensure_original_data()
+            while True:
+                print("\n\033[1mSmoothing and Data Reduction\033[0m")
+                print("Commands:")
+                print("  r: reduce rows (delete/merge rows based on pattern)")
+                print("  s: smooth data (various smoothing methods)")
+                print("  reset: reset all curves to original data")
+                print("  q: back to main menu")
+                sub = _safe_input(colorize_prompt("sm> ")).strip().lower()
+                if not sub:
+                    continue
+                if sub == 'q':
+                    break
+                if sub == 'reset':
+                    push_state("smooth-reset")
+                    success, reset_count, total_points = _reset_to_original()
+                    if success:
+                        print(f"Reset {reset_count} curve(s) to original data ({total_points} total points restored).")
+                        _apply_data_changes()
+                    else:
+                        print("No processed data to reset.")
+                    continue
+                if sub == 'r':
+                    # Reduce rows submenu
+                    while True:
+                        print("\n\033[1mReduce Rows\033[0m")
+                        print("Methods:")
+                        print("  1: Delete N rows, then skip M rows")
+                        print("  2: Delete rows with missing values")
+                        print("  3: Reduce N rows with merged values (average/sum/min/max)")
+                        print("  q: back to smooth menu")
+                        method = _safe_input(colorize_prompt("sm>r> ")).strip().lower()
+                        if not method or method == 'q':
+                            break
+                        if method == '1':
+                            # Delete N rows, then skip M rows
+                            try:
+                                # Check for last settings
+                                last_settings = _get_last_reduce_rows_settings('delete_skip')
+                                last_n = last_settings.get('n')
+                                last_m = last_settings.get('m')
+                                last_start_row = last_settings.get('start_row')
+                                
+                                if last_n is not None and last_m is not None and last_start_row is not None:
+                                    use_last = _safe_input(f"Use last settings? (N={last_n}, M={last_m}, start_row={last_start_row+1}, y/n or enter N): ").strip().lower()
+                                    # Check if user entered a number directly (skip "use last settings")
+                                    if use_last and use_last.replace('-', '').replace('.', '').isdigit():
+                                        n = int(float(use_last))
+                                        if n < 1:
+                                            print("N must be >= 1.")
+                                            continue
+                                        m_in = _safe_input(f"Enter M (rows to skip, default {last_m}): ").strip()
+                                        m = int(m_in) if m_in else last_m
+                                        if m < 0:
+                                            print("M must be >= 0.")
+                                            continue
+                                        start_in = _safe_input(f"Starting row (1-based, default {last_start_row+1}): ").strip()
+                                        start_row = int(start_in) - 1 if start_in else last_start_row
+                                    elif use_last != 'n':
+                                        n = last_n
+                                        m = last_m
+                                        start_row = last_start_row  # Already 0-based in config
+                                    else:
+                                        n_in = _safe_input(f"Enter N (rows to delete, default {last_n}): ").strip()
+                                        n = int(n_in) if n_in else last_n
+                                        if n < 1:
+                                            print("N must be >= 1.")
+                                            continue
+                                        m_in = _safe_input(f"Enter M (rows to skip, default {last_m}): ").strip()
+                                        m = int(m_in) if m_in else last_m
+                                        if m < 0:
+                                            print("M must be >= 0.")
+                                            continue
+                                        start_in = _safe_input(f"Starting row (1-based, default {last_start_row+1}): ").strip()
+                                        start_row = int(start_in) - 1 if start_in else last_start_row
+                                else:
+                                    n_in = _safe_input("Enter N (rows to delete, default 1): ").strip()
+                                    n = int(n_in) if n_in else 1
+                                    if n < 1:
+                                        print("N must be >= 1.")
+                                        continue
+                                    m_in = _safe_input("Enter M (rows to skip, default 0): ").strip()
+                                    m = int(m_in) if m_in else 0
+                                    if m < 0:
+                                        print("M must be >= 0.")
+                                        continue
+                                    start_in = _safe_input("Starting row (1-based, default 1): ").strip()
+                                    start_row = int(start_in) - 1 if start_in else 0
+                                
+                                if start_row < 0:
+                                    start_row = 0
+                                push_state("reduce-rows-delete-skip")
+                                _ensure_original_data()
+                                processed = 0
+                                total_before = 0
+                                total_after = 0
+                                for i in range(len(x_data_list)):
+                                    try:
+                                        # Use current data (may already be processed), not original
+                                        orig_x = x_data_list[i].copy()
+                                        orig_y = y_data_list[i].copy()
+                                        # Remove offset for processing
+                                        if i < len(offsets_list):
+                                            orig_y = orig_y - offsets_list[i]
+                                        if start_row >= len(orig_x):
+                                            continue
+                                        before = len(orig_x)
+                                        # Create mask: delete n rows, then skip m rows, repeat
+                                        mask = np.ones(len(orig_x), dtype=bool)
+                                        idx = start_row
+                                        while idx < len(orig_x):
+                                            # Delete n rows
+                                            end_del = min(idx + n, len(orig_x))
+                                            mask[idx:end_del] = False
+                                            idx = end_del
+                                            # Skip m rows
+                                            idx = min(idx + m, len(orig_x))
+                                        new_x = orig_x[mask]
+                                        new_y = orig_y[mask]
+                                        after = len(new_x)
+                                        if len(new_x) > 0:
+                                            # Restore offset
+                                            if i < len(offsets_list):
+                                                new_y = new_y + offsets_list[i]
+                                            x_data_list[i] = new_x
+                                            y_data_list[i] = new_y
+                                            processed += 1
+                                            total_before += before
+                                            total_after += after
+                                    except Exception as e:
+                                        print(f"Error processing curve {i+1}: {e}")
+                                if processed > 0:
+                                    removed = total_before - total_after
+                                    pct = 100 * removed / total_before if total_before else 0
+                                    print(f"Processed {processed} curve(s); removed {removed} of {total_before} points ({pct:.1f}%).")
+                                    _update_full_processed_data()  # Store full processed data for X-range filtering
+                                    _apply_data_changes()
+                                    # Save settings for next time
+                                    _save_last_reduce_rows_settings('delete_skip', {
+                                        'n': n,
+                                        'm': m,
+                                        'start_row': start_row  # Save as 0-based
+                                    })
+                                else:
+                                    print("No curves were processed.")
+                            except ValueError:
+                                print("Invalid number.")
+                            continue
+                        if method == '2':
+                            # Delete rows with missing values
+                            try:
+                                # Check for last settings
+                                last_settings = _get_last_reduce_rows_settings('delete_missing')
+                                last_delete_entire_row = last_settings.get('delete_entire_row')
+                                
+                                if last_delete_entire_row is not None:
+                                    default_str = "y" if last_delete_entire_row else "n"
+                                    use_last = _safe_input(f"Use last settings? (delete_entire_row={'y' if last_delete_entire_row else 'n'}, y/n or enter y/n): ").strip().lower()
+                                    # Check if user entered y/n directly (skip "use last settings")
+                                    if use_last in ('y', 'n', 'yes', 'no'):
+                                        delete_entire_row = use_last in ('y', 'yes')
+                                    elif use_last != 'n':
+                                        delete_entire_row = last_delete_entire_row
+                                    else:
+                                        delete_entire_row_in = _safe_input(f"Delete entire row? (y/n, default {default_str}): ").strip().lower()
+                                        delete_entire_row = delete_entire_row_in != 'n'
+                                else:
+                                    delete_entire_row_in = _safe_input("Delete entire row? (y/n, default y): ").strip().lower()
+                                    delete_entire_row = delete_entire_row_in != 'n'
+                                push_state("reduce-rows-delete-missing")
+                                _ensure_original_data()
+                                processed = 0
+                                total_before = 0
+                                total_after = 0
+                                for i in range(len(x_data_list)):
+                                    try:
+                                        # Use current data (may already be processed), not original
+                                        orig_x = x_data_list[i].copy()
+                                        orig_y = y_data_list[i].copy()
+                                        # Remove offset for processing
+                                        if i < len(offsets_list):
+                                            orig_y = orig_y - offsets_list[i]
+                                        before = len(orig_x)
+                                        # Check for missing values (NaN or inf)
+                                        if delete_entire_row:
+                                            mask = np.isfinite(orig_x) & np.isfinite(orig_y)
+                                        else:
+                                            # Only delete missing in current column
+                                            mask = np.isfinite(orig_y)
+                                        new_x = orig_x[mask]
+                                        new_y = orig_y[mask]
+                                        after = len(new_x)
+                                        if len(new_x) > 0:
+                                            # Restore offset
+                                            if i < len(offsets_list):
+                                                new_y = new_y + offsets_list[i]
+                                            x_data_list[i] = new_x
+                                            y_data_list[i] = new_y
+                                            processed += 1
+                                            total_before += before
+                                            total_after += after
+                                    except Exception as e:
+                                        print(f"Error processing curve {i+1}: {e}")
+                                if processed > 0:
+                                    removed = total_before - total_after
+                                    pct = 100 * removed / total_before if total_before else 0
+                                    print(f"Processed {processed} curve(s); removed {removed} of {total_before} points ({pct:.1f}%).")
+                                    _update_full_processed_data()  # Store full processed data for X-range filtering
+                                    _apply_data_changes()
+                                    # Save settings for next time
+                                    _save_last_reduce_rows_settings('delete_missing', {
+                                        'delete_entire_row': delete_entire_row
+                                    })
+                                else:
+                                    print("No curves were processed.")
+                            except Exception:
+                                print("Error processing data.")
+                            continue
+                        if method == '3':
+                            # Reduce N rows with merged values
+                            try:
+                                # Check for last settings
+                                last_settings = _get_last_reduce_rows_settings('merge')
+                                last_n = last_settings.get('n')
+                                last_merge_by = last_settings.get('merge_by')
+                                last_start_row = last_settings.get('start_row')
+                                
+                                if last_n is not None and last_merge_by is not None and last_start_row is not None:
+                                    merge_names = {
+                                        '1': 'First point',
+                                        '2': 'Last point',
+                                        '3': 'Average',
+                                        '4': 'Min',
+                                        '5': 'Max',
+                                        '6': 'Sum'
+                                    }
+                                    merge_name = merge_names.get(last_merge_by, 'Average')
+                                    use_last = _safe_input(f"Use last settings? (N={last_n}, merge_by={merge_name}, start_row={last_start_row+1}, y/n or enter N): ").strip().lower()
+                                    # Check if user entered a number directly (skip "use last settings")
+                                    if use_last and use_last.replace('-', '').replace('.', '').isdigit():
+                                        n = int(float(use_last))
+                                        if n < 2:
+                                            print("N must be >= 2.")
+                                            continue
+                                        print("Merge by:")
+                                        print("  1: First point")
+                                        print("  2: Last point")
+                                        print("  3: Average")
+                                        print("  4: Min")
+                                        print("  5: Max")
+                                        print("  6: Sum")
+                                        merge_by_in = _safe_input(f"Choose (1-6, default {last_merge_by}): ").strip()
+                                        merge_by = merge_by_in if merge_by_in else last_merge_by
+                                        start_in = _safe_input(f"Starting row (1-based, default {last_start_row+1}): ").strip()
+                                        start_row = int(start_in) - 1 if start_in else last_start_row
+                                    elif use_last != 'n':
+                                        n = last_n
+                                        merge_by = last_merge_by
+                                        start_row = last_start_row  # Already 0-based in config
+                                    else:
+                                        n_in = _safe_input(f"Enter N (rows to merge, default {last_n}): ").strip()
+                                        n = int(n_in) if n_in else last_n
+                                        if n < 2:
+                                            print("N must be >= 2.")
+                                            continue
+                                        print("Merge by:")
+                                        print("  1: First point")
+                                        print("  2: Last point")
+                                        print("  3: Average")
+                                        print("  4: Min")
+                                        print("  5: Max")
+                                        print("  6: Sum")
+                                        merge_by_in = _safe_input(f"Choose (1-6, default {last_merge_by}): ").strip()
+                                        merge_by = merge_by_in if merge_by_in else last_merge_by
+                                        start_in = _safe_input(f"Starting row (1-based, default {last_start_row+1}): ").strip()
+                                        start_row = int(start_in) - 1 if start_in else last_start_row
+                                else:
+                                    n_in = _safe_input("Enter N (rows to merge, default 2): ").strip()
+                                    n = int(n_in) if n_in else 2
+                                    if n < 2:
+                                        print("N must be >= 2.")
+                                        continue
+                                    print("Merge by:")
+                                    print("  1: First point")
+                                    print("  2: Last point")
+                                    print("  3: Average")
+                                    print("  4: Min")
+                                    print("  5: Max")
+                                    print("  6: Sum")
+                                    merge_by_in = _safe_input("Choose (1-6, default 3): ").strip()
+                                    merge_by = merge_by_in if merge_by_in else '3'
+                                    start_in = _safe_input("Starting row (1-based, default 1): ").strip()
+                                    start_row = int(start_in) - 1 if start_in else 0
+                                
+                                if start_row < 0:
+                                    start_row = 0
+                                
+                                merge_funcs = {
+                                    '1': lambda arr: arr[0] if len(arr) > 0 else np.nan,
+                                    '2': lambda arr: arr[-1] if len(arr) > 0 else np.nan,
+                                    '3': np.nanmean,
+                                    '4': np.nanmin,
+                                    '5': np.nanmax,
+                                    '6': np.nansum,
+                                }
+                                merge_func = merge_funcs.get(merge_by, np.nanmean)
+                                push_state("reduce-rows-merge")
+                                _ensure_original_data()
+                                processed = 0
+                                total_before = 0
+                                total_after = 0
+                                for i in range(len(x_data_list)):
+                                    try:
+                                        # Use current data (may already be processed), not original
+                                        orig_x = x_data_list[i].copy()
+                                        orig_y = y_data_list[i].copy()
+                                        # Remove offset for processing
+                                        if i < len(offsets_list):
+                                            orig_y = orig_y - offsets_list[i]
+                                        if start_row >= len(orig_x):
+                                            continue
+                                        before = len(orig_x)
+                                        # Group into chunks of N
+                                        new_x_list = []
+                                        new_y_list = []
+                                        idx = 0
+                                        while idx < start_row:
+                                            new_x_list.append(orig_x[idx])
+                                            new_y_list.append(orig_y[idx])
+                                            idx += 1
+                                        while idx < len(orig_x):
+                                            end_idx = min(idx + n, len(orig_x))
+                                            chunk_x = orig_x[idx:end_idx]
+                                            chunk_y = orig_y[idx:end_idx]
+                                            # Merge: use first x, merge y based on method
+                                            new_x = chunk_x[0] if len(chunk_x) > 0 else np.nan
+                                            new_y = merge_func(chunk_y) if len(chunk_y) > 0 else np.nan
+                                            if np.isfinite(new_x) and np.isfinite(new_y):
+                                                new_x_list.append(new_x)
+                                                new_y_list.append(new_y)
+                                            idx = end_idx
+                                        if len(new_x_list) > 0:
+                                            new_x = np.array(new_x_list)
+                                            new_y = np.array(new_y_list)
+                                            after = len(new_x)
+                                            # Restore offset
+                                            if i < len(offsets_list):
+                                                new_y = new_y + offsets_list[i]
+                                            x_data_list[i] = new_x
+                                            y_data_list[i] = new_y
+                                            processed += 1
+                                            total_before += before
+                                            total_after += after
+                                    except Exception as e:
+                                        print(f"Error processing curve {i+1}: {e}")
+                                if processed > 0:
+                                    removed = total_before - total_after
+                                    pct = 100 * removed / total_before if total_before else 0
+                                    print(f"Processed {processed} curve(s); reduced {total_before} to {total_after} points (removed {removed}, {pct:.1f}%).")
+                                    _update_full_processed_data()  # Store full processed data for X-range filtering
+                                    _apply_data_changes()
+                                    # Save settings for next time
+                                    _save_last_reduce_rows_settings('merge', {
+                                        'n': n,
+                                        'merge_by': merge_by,
+                                        'start_row': start_row  # Save as 0-based
+                                    })
+                                else:
+                                    print("No curves were processed.")
+                            except (ValueError, KeyError):
+                                print("Invalid input.")
+                            continue
+                if sub == 's':
+                    # Smooth submenu
+                    while True:
+                        print("\n\033[1mSmooth Data\033[0m")
+                        print("Methods:")
+                        print("  1: Adjacent-Averaging (moving average)")
+                        print("  2: Savitzky-Golay (polynomial smoothing)")
+                        print("  3: FFT Filter (low-pass frequency filter)")
+                        print("  q: back to smooth menu")
+                        method = _safe_input(colorize_prompt("sm>s> ")).strip().lower()
+                        if not method or method == 'q':
+                            break
+                        if method == '1':
+                            # Adjacent-Averaging
+                            try:
+                                # Check for last settings (from config file for persistence)
+                                config_settings = _get_last_smooth_settings_from_config()
+                                session_settings = getattr(fig, '_last_smooth_settings', {})
+                                # Prefer config settings (persistent) over session settings
+                                last_settings = config_settings if config_settings.get('method') == 'adjacent_average' else session_settings
+                                last_method = last_settings.get('method')
+                                last_points = last_settings.get('points')
+                                
+                                if last_method == 'adjacent_average' and last_points is not None:
+                                    use_last = _safe_input(f"Use last settings? (points={last_points}, y/n or enter points): ").strip().lower()
+                                    # Check if user entered a number directly (skip "use last settings")
+                                    if use_last and use_last.replace('-', '').replace('.', '').isdigit():
+                                        points = int(float(use_last))
+                                    elif use_last != 'n':
+                                        points = last_points
+                                    else:
+                                        points_in = _safe_input(f"Number of points (default {last_points}): ").strip()
+                                        points = int(points_in) if points_in else last_points
+                                else:
+                                    points_in = _safe_input("Number of points (default 5): ").strip()
+                                    points = int(points_in) if points_in else 5
+                                
+                                if points < 2:
+                                    print("Points must be >= 2.")
+                                    continue
+                                push_state("smooth-adjacent-average")
+                                _ensure_original_data()
+                                processed = 0
+                                total_points = 0
+                                for i in range(len(x_data_list)):
+                                    try:
+                                        # Use current data (may already be processed), not original
+                                        orig_x = x_data_list[i].copy()
+                                        orig_y = y_data_list[i].copy()
+                                        # Remove offset for processing
+                                        if i < len(offsets_list):
+                                            orig_y = orig_y - offsets_list[i]
+                                        n_points = len(orig_y)
+                                        # Apply smoothing
+                                        smoothed_y = _adjacent_average_smooth(orig_y, points)
+                                        if len(smoothed_y) > 0:
+                                            # Restore offset
+                                            if i < len(offsets_list):
+                                                smoothed_y = smoothed_y + offsets_list[i]
+                                            # Keep original x, update y
+                                            x_data_list[i] = orig_x.copy()
+                                            y_data_list[i] = smoothed_y
+                                            processed += 1
+                                            total_points += n_points
+                                    except Exception as e:
+                                        print(f"Error processing curve {i+1}: {e}")
+                                if processed > 0:
+                                    print(f"Smoothed {processed} curve(s) with {total_points} total points using Adjacent-Averaging (window={points}).")
+                                    _update_full_processed_data()  # Store full processed data for X-range filtering
+                                    _apply_data_changes()
+                                    # Store settings (both current and last)
+                                    if not hasattr(fig, '_smooth_settings'):
+                                        fig._smooth_settings = {}
+                                    fig._smooth_settings['method'] = 'adjacent_average'
+                                    fig._smooth_settings['points'] = points
+                                    # Store as last settings for next time (both in-memory and config file)
+                                    if not hasattr(fig, '_last_smooth_settings'):
+                                        fig._last_smooth_settings = {}
+                                    fig._last_smooth_settings['method'] = 'adjacent_average'
+                                    fig._last_smooth_settings['points'] = points
+                                    # Save to config file for persistence across sessions
+                                    _save_last_smooth_settings_to_config({
+                                        'method': 'adjacent_average',
+                                        'points': points
+                                    })
+                                else:
+                                    print("No curves were smoothed.")
+                            except ValueError:
+                                print("Invalid number.")
+                            continue
+                        if method == '2':
+                            # Savitzky-Golay
+                            try:
+                                # Check for last settings (from config file for persistence)
+                                config_settings = _get_last_smooth_settings_from_config()
+                                session_settings = getattr(fig, '_last_smooth_settings', {})
+                                # Prefer config settings (persistent) over session settings
+                                last_settings = config_settings if config_settings.get('method') == 'savgol' else session_settings
+                                last_method = last_settings.get('method')
+                                last_window = last_settings.get('window')
+                                last_poly = last_settings.get('poly')
+                                
+                                if last_method == 'savgol' and last_window is not None and last_poly is not None:
+                                    use_last = _safe_input(f"Use last settings? (window={last_window}, poly={last_poly}, y/n or enter window): ").strip().lower()
+                                    # Check if user entered a number directly (skip "use last settings")
+                                    if use_last and use_last.replace('-', '').replace('.', '').isdigit():
+                                        window = int(float(use_last))
+                                        if window < 3:
+                                            window = 3
+                                        if window % 2 == 0:
+                                            window += 1
+                                        poly_in = _safe_input(f"Polynomial order (default {last_poly}): ").strip()
+                                        poly = int(poly_in) if poly_in else last_poly
+                                    elif use_last != 'n':
+                                        window = last_window
+                                        poly = last_poly
+                                    else:
+                                        window_in = _safe_input(f"Window size (odd >= 3, default {last_window}): ").strip()
+                                        window = int(window_in) if window_in else last_window
+                                        if window < 3:
+                                            window = 3
+                                        if window % 2 == 0:
+                                            window += 1
+                                        poly_in = _safe_input(f"Polynomial order (default {last_poly}): ").strip()
+                                        poly = int(poly_in) if poly_in else last_poly
+                                else:
+                                    window_in = _safe_input("Window size (odd >= 3, default 9): ").strip()
+                                    window = int(window_in) if window_in else 9
+                                    if window < 3:
+                                        window = 3
+                                    if window % 2 == 0:
+                                        window += 1
+                                    poly_in = _safe_input("Polynomial order (default 3): ").strip()
+                                    poly = int(poly_in) if poly_in else 3
+                                
+                                if poly < 1:
+                                    poly = 1
+                                if poly >= window:
+                                    poly = window - 1
+                                push_state("smooth-savgol")
+                                _ensure_original_data()
+                                processed = 0
+                                total_points = 0
+                                for i in range(len(x_data_list)):
+                                    try:
+                                        # Use current data (may already be processed), not original
+                                        orig_x = x_data_list[i].copy()
+                                        orig_y = y_data_list[i].copy()
+                                        # Remove offset for processing
+                                        if i < len(offsets_list):
+                                            orig_y = orig_y - offsets_list[i]
+                                        n_points = len(orig_y)
+                                        # Apply smoothing
+                                        smoothed_y = _savgol_smooth(orig_y, window, poly)
+                                        if len(smoothed_y) > 0:
+                                            # Restore offset
+                                            if i < len(offsets_list):
+                                                smoothed_y = smoothed_y + offsets_list[i]
+                                            # Keep original x, update y
+                                            x_data_list[i] = orig_x.copy()
+                                            y_data_list[i] = smoothed_y
+                                            processed += 1
+                                            total_points += n_points
+                                    except Exception as e:
+                                        print(f"Error processing curve {i+1}: {e}")
+                                if processed > 0:
+                                    print(f"Smoothed {processed} curve(s) with {total_points} total points using Savitzky-Golay (window={window}, poly={poly}).")
+                                    _update_full_processed_data()  # Store full processed data for X-range filtering
+                                    _apply_data_changes()
+                                    # Store settings (both current and last)
+                                    if not hasattr(fig, '_smooth_settings'):
+                                        fig._smooth_settings = {}
+                                    fig._smooth_settings['method'] = 'savgol'
+                                    fig._smooth_settings['window'] = window
+                                    fig._smooth_settings['poly'] = poly
+                                    # Store as last settings for next time (both in-memory and config file)
+                                    if not hasattr(fig, '_last_smooth_settings'):
+                                        fig._last_smooth_settings = {}
+                                    fig._last_smooth_settings['method'] = 'savgol'
+                                    fig._last_smooth_settings['window'] = window
+                                    fig._last_smooth_settings['poly'] = poly
+                                    # Save to config file for persistence across sessions
+                                    _save_last_smooth_settings_to_config({
+                                        'method': 'savgol',
+                                        'window': window,
+                                        'poly': poly
+                                    })
+                                else:
+                                    print("No curves were smoothed.")
+                            except ValueError:
+                                print("Invalid number.")
+                            continue
+                        if method == '3':
+                            # FFT Filter
+                            try:
+                                # Check for last settings (from config file for persistence)
+                                config_settings = _get_last_smooth_settings_from_config()
+                                session_settings = getattr(fig, '_last_smooth_settings', {})
+                                # Prefer config settings (persistent) over session settings
+                                last_settings = config_settings if config_settings.get('method') == 'fft' else session_settings
+                                last_method = last_settings.get('method')
+                                last_points = last_settings.get('points')
+                                last_cutoff = last_settings.get('cutoff')
+                                
+                                if last_method == 'fft' and last_points is not None and last_cutoff is not None:
+                                    use_last = _safe_input(f"Use last settings? (points={last_points}, cutoff={last_cutoff:.3f}, y/n or enter points): ").strip().lower()
+                                    # Check if user entered a number directly (skip "use last settings")
+                                    if use_last and use_last.replace('-', '').replace('.', '').isdigit():
+                                        points = int(float(use_last))
+                                        if points < 2:
+                                            points = 2
+                                        cutoff_in = _safe_input(f"Cutoff frequency (0-1, default {last_cutoff:.3f}): ").strip()
+                                        cutoff = float(cutoff_in) if cutoff_in else last_cutoff
+                                    elif use_last != 'n':
+                                        points = last_points
+                                        cutoff = last_cutoff
+                                    else:
+                                        points_in = _safe_input(f"Points for FFT (default {last_points}): ").strip()
+                                        points = int(points_in) if points_in else last_points
+                                        if points < 2:
+                                            points = 2
+                                        cutoff_in = _safe_input(f"Cutoff frequency (0-1, default {last_cutoff:.3f}): ").strip()
+                                        cutoff = float(cutoff_in) if cutoff_in else last_cutoff
+                                else:
+                                    points_in = _safe_input("Points for FFT (default 5): ").strip()
+                                    points = int(points_in) if points_in else 5
+                                    if points < 2:
+                                        points = 2
+                                    cutoff_in = _safe_input("Cutoff frequency (0-1, default 0.1): ").strip()
+                                    cutoff = float(cutoff_in) if cutoff_in else 0.1
+                                
+                                if cutoff < 0:
+                                    cutoff = 0
+                                if cutoff > 1:
+                                    cutoff = 1
+                                push_state("smooth-fft")
+                                _ensure_original_data()
+                                processed = 0
+                                total_points = 0
+                                for i in range(len(x_data_list)):
+                                    try:
+                                        # Use current data (may already be processed), not original
+                                        orig_x = x_data_list[i].copy()
+                                        orig_y = y_data_list[i].copy()
+                                        # Remove offset for processing
+                                        if i < len(offsets_list):
+                                            orig_y = orig_y - offsets_list[i]
+                                        n_points = len(orig_y)
+                                        # Apply smoothing
+                                        smoothed_y = _fft_smooth(orig_y, points, cutoff)
+                                        if len(smoothed_y) > 0:
+                                            # Restore offset
+                                            if i < len(offsets_list):
+                                                smoothed_y = smoothed_y + offsets_list[i]
+                                            # Keep original x, update y
+                                            x_data_list[i] = orig_x.copy()
+                                            y_data_list[i] = smoothed_y
+                                            processed += 1
+                                            total_points += n_points
+                                    except Exception as e:
+                                        print(f"Error processing curve {i+1}: {e}")
+                                if processed > 0:
+                                    print(f"Smoothed {processed} curve(s) with {total_points} total points using FFT Filter (cutoff={cutoff:.3f}).")
+                                    _update_full_processed_data()  # Store full processed data for X-range filtering
+                                    _apply_data_changes()
+                                    # Store settings (both current and last)
+                                    if not hasattr(fig, '_smooth_settings'):
+                                        fig._smooth_settings = {}
+                                    fig._smooth_settings['method'] = 'fft'
+                                    fig._smooth_settings['points'] = points
+                                    fig._smooth_settings['cutoff'] = cutoff
+                                    # Store as last settings for next time (both in-memory and config file)
+                                    if not hasattr(fig, '_last_smooth_settings'):
+                                        fig._last_smooth_settings = {}
+                                    fig._last_smooth_settings['method'] = 'fft'
+                                    fig._last_smooth_settings['points'] = points
+                                    fig._last_smooth_settings['cutoff'] = cutoff
+                                    # Save to config file for persistence across sessions
+                                    _save_last_smooth_settings_to_config({
+                                        'method': 'fft',
+                                        'points': points,
+                                        'cutoff': cutoff
+                                    })
+                                else:
+                                    print("No curves were smoothed.")
+                            except ValueError:
+                                print("Invalid number.")
+                            continue
         elif key == 'v':
             while True:
                 try: