SonataSmooth is a compound of "sonata" and "smooth". A sonata is a musical form in which multiple movements blend into a single, harmonious whole-here serving as a metaphor for different smoothing algorithms working together in concert. "Smooth" highlights the sleek process of gently removing noise from data.

Key components

• Sonata : Evokes the idea of various movements (algorithms) uniting to produce a harmonious result
• Smooth : Emphasizes the smoothing function that gracefully eliminates data noise

True to its name, SonataSmooth embodies the philosophy of applying multiple techniques in harmony to process data as smoothly and clearly as a piece of music.

SonataSmooth is a C# .NET Windows Forms application for efficient noise reduction and smoothing of numerical datasets. It supports multiple data input methods, including manual entry, clipboard paste, and drag-and-drop, with robust validation and parsing. Users can apply a variety of advanced filtering algorithms such as Rectangular Mean, Binomial Average, Binomial Median, Gaussian Weighted Median, Gaussian, and Savitzky-Golay filters, customizing parameters as needed. The application features a responsive, user-friendly interface with real-time progress feedback and batch editing capabilities. Designed for flexibility and performance.

SonataSmooth is specialized for 1D data smoothing and noise reduction.
While limited to single‑dimension datasets, it can be applied across a wide range of domains where sequential numeric signals require pre-processing or refinement :

• Machine Learning / Deep Learning Pre-processing

  • Clean raw training data by removing spikes, jitter, or irregular noise
  • Improve model accuracy by stabilizing time‑series inputs such as sensor readings or financial signals

• IoT and Sensor Data Processing

  • Smooth noisy sensor outputs (temperature, humidity, vibration, etc.) for reliable monitoring
  • Enhance anomaly detection by reducing false positives caused by random fluctuations

• Financial and Economic Time Series

  • Filter out short‑term volatility in stock prices, currency exchange rates, or transaction volumes
  • Prepare stable datasets for forecasting models

• Scientific and Experimental Measurements

  • Refine laboratory or field data (e.g., spectroscopy, environmental monitoring) to highlight meaningful trends
  • Reduce measurement noise without distorting underlying patterns

• Signal Processing (1D only)

  • Smooth audio waveform amplitudes or other linear signals
  • Preserve essential features while reducing background noise

• Data Visualization & Reporting

  • Generate clearer charts and plots by removing distracting noise
  • Provide stakeholders with more interpretable datasets

Minor bugs fixed.

• Windows Operating System
  • Windows 11 recommended, compatible with Windows 10
• .NET Framework 4.8 or .NET Framework 4.8.1
  • Runtime : .NET Framework 4.8.1 (native ARM64 supported on Windows 11)
  • Architectures : ARM64 (native), x64 (native), x86 (native)
  • Verified on ARM64 and x64 devices (native builds)
• Visual Studio 2026 (for development)
  • Development environment is recommended to use Visual Studio 2022 or newer
• Microsoft Office (Excel)
  • Excel 2013 Service Pack 1 (clean install) verified to work without additional configuration.
  • Later versions (Excel 2016, 2019, 2021, 2024, Microsoft 365) also confirmed stable.
  • Minimum recommended version : Excel 2019 or later for long-term support and reliability.
  • Bitness must match : x86 app with 32‑bit Office, or x64 app with 64‑bit Office.
  • CSV export does not require Microsoft Office.

• System.Windows.Forms
• System.Threading.Tasks
• System.Linq
• Microsoft.Office.Interop.Excel (for Excel export)

• Clone or download the repository.
• Open the solution file (.slnx) in Visual Studio.
• Add necessary references if required.
• Build the project.
• Run the application.

On first launch after an application upgrade, compatible settings are migrated and normalized once. Subsequent launches use normal save / load persistence.

Key points :

• One‑time migration flag : HasUpgradedSettings
• Boundary Method stored and restored by text (e.g., "Symmetric", "Replicate", "Adaptive", "ZeroPad"); normalized strings ensure consistent display (aliases like "Zero Padding" → "ZeroPad")
• Clamping / normalization :
  • AlphaBlend clamped to [0.0, 1.0]
  • DerivOrder clamped to [0, 10]
  • SigmaFactor clamped to [1.0, 12.0]
• Settings are saved automatically on app close and when pressing the Save button in the settings panel.

The export title (Excel sheet name & metadata) is validated :

• Max length : 31 characters
• Disallowed characters : : \ / ? * [ ] and all OS-invalid filename characters
• Reserved DOS names rejected (CON, PRN, AUX, NUL, COM1 - COM9, LPT1 - LPT9)

Invalid input reverts to the placeholder and shows a warning dialog. The placeholder text "Click here to enter a title for your dataset." is restored whenever validation fails or the field is cleared. On invalid or cleared input the placeholder is restored with centered alignment and gray foreground; valid titles display left-aligned with normal system text color.

Export Enablement Rules :

• Export button is enabled when the Initial Dataset contains at least one entry AND the title field is non‑placeholder. Full title validation runs when the field loses focus; invalid titles are reverted to the placeholder and export becomes disabled.
• Clearing all Initial Dataset items or reverting the title to the placeholder immediately disables export.

1. Launch the Application : Run the compiled .exe file or start the project from Visual Studio.
2. Input Data : Enter numeric values manually, paste from clipboard, or drag-and-drop text / HTML.
3. Select Filter : Choose exactly one smoothing method for calibration using the radio buttons (rbtnRect, rbtnAvg, rbtnMed, rbtnGaussMed, rbtnGauss, rbtnSG). In the Export Settings dialog you can enable multiple methods (chbRect, chbAvg, chbMed, chbGaussMed, chbGauss, chbSG) for batch export.
4. Calibrate : Click the 'Calibrate' button (btnCalibrate) to apply the selected filter(s).
5. Review Results : View the smoothed output in the "Refined Dataset" listbox (lbRefinedData).
6. Edit Data : Use the "Modify Selected Entries" dialog (btnInitEdit) to batch-edit selected items in the initial dataset.
7. Export : Click Export (btnExport) to save results as .CSV or Excel (.xlsx), with optional chart visualization. Configure export options in the "Export Configuration" dialog (btnExportSettings).

• Initial Dataset ListBox : lbInitData
• Refined Dataset ListBox : lbRefinedData
• Kernel Radius ComboBox : cbxKernelRadius
• Polynomial Order ComboBox : cbxPolyOrder
• Derivative Order ComboBox : cbxDerivOrder
• Boundary Method ComboBox : cbxBoundaryMethod
• Calibration Method CheckBoxes : chbRect, chbAvg, chbMed, chbGaussMed, chbGauss, chbSG
• Edit Button : btnInitEdit
• Initial ↔ Refined Selection Sync Buttons : btnInitSelectSync, btnRefSelectSync
• Dataset Title TextBox : txtDatasetTitle
• Export Buttons : btnExport, btnExportSettings
• ProgressBar : pbMain, pbModify
• Count Labels : lblInitCnt, lblRefCnt
• StatusStrip & Labels : statStripMain, slblCalibratedType, slblKernelRadius, tlblPolyOrder, slblPolyOrder, tlblDerivativeOrder, slblDerivativeOrder, tlblBoundaryMethod, slblBoundaryMethod, tlblAlphaBlend, slblAlphaBlend, slblDesc, tlblSeparator1, tlblSeparator2, tlblSeparator3, tlblSeparator4, tlblSeparator5
• Other Controls : All controls use clear, descriptive names matching their function in the codebase.

Visibility : tlblPolyOrder, slblPolyOrder, tlblDerivativeOrder, slblDerivativeOrder are only shown when Savitzky-Golay is active.

This guide explains how different noise filters work with different types of signals. It also simply introduces Pascal's Triangle.

• Rectangular Averaging : Simple but effective for steady high‑frequency noise suppression.
• Binomial Averaging : A balanced middle ground, especially strong for periodic signals with moderate noise.
• Binomial Median Filtering : The most robust across datasets and metrics; excels at handling spikes (both occasional and frequent), frequent noise, and step changes, making it the overall best performer, but less consistent for consecutive spikes.
• Gaussian Weighted Median Filtering (GWMF) : A hybrid combining Gaussian smoothness with median robustness; excellent for occasional spikes and smooth‑curve preservation.
• Gaussian Filtering : Produces smooth curves and natural signal flow, but struggles with abrupt changes and extreme outliers.
• Savitzky‑Golay Filtering : Excels at preserving waveforms, trends, and mixed frequencies; ideal for scientific data and smooth curve analysis.

Overall : Binomial Median Filtering demonstrates the highest aggregate performance across diverse signal types and evaluation metrics. GWMF provides a versatile alternative, especially strong for occasional spikes and noisy smooth‑curve scenarios, while other filters retain niche strengths in specific contexts.

Pascal's Triangle is a triangle of numbers built like this :

• Start with 1 at the top.
• Each new row adds two numbers from the row above to get a new one.
• The edges of each row are always 1.

Row 1 :　　　　　　1
Row 2 :　　　　　1　 1
Row 3 :　　　　1　 2　 1
Row 4 :　　　1　 3　 3　 1
Row 5 :　　1　 4 　6　 4　 1

Filters like Binomial Averaging use rows from Pascal's Triangle as weights. Bigger numbers in the middle give more importance to center values when filtering.

• Rectangular Averaging (Moving Average)
  Adds up a group of points and divides by how many there are. It's simple and fast. Best for removing constant buzz or small jitters.

• Binomial Averaging
  Like a moving average, but with weights from Pascal's Triangle. The center gets more focus. Keeps the shape of your signal better while smoothing small noise.

• Binomial Median Filtering
  Sorts nearby values and picks the middle one, using extra weight for the center. Removes sharp spikes while keeping the signal shape.

• Gaussian Weighted Median Filtering (GWMF)
  Computes a median using Gaussian weights within the kernel window. It preserves smooth curves with robustness to occasional spikes. In Adaptive mode, the kernel length W shrinks at edges, σ is recomputed as W / sigmaFactor, and weights are normalized; alpha blending applies at runtime.

• Gaussian Filtering
  Uses a bell-shaped curve for weights. Very smooth, but may let sharp jumps stay.

• Savitzky‑Golay Filtering
  Fits tiny curves to chunks of data. Keeps wave shapes and slow changes almost perfectly, but not as strong for sudden spikes.

Let's say we use the 5th row : 1 4 6 4 1

1. Total = 1 + 4 + 6 + 4 + 1 = 16
2. Weights = [1 / 16, 4 / 16, 6 / 16, 4 / 16, 1 / 16] → [0.0625 , 0.25 , 0.375 , 0.25 , 0.0625]
3. Data Window = [2, 5, 1, 3, 4]

Apply the weights :
2 × 0.0625 + 5 × 0.25 + 1 × 0.375 + 3 × 0.25 + 4 × 0.0625 = 2.75

That final value (2.75) becomes your new filtered point.

Edge handling determines which values are used when the kernel window extends beyond the first or last element.

Display names in exports :

• Symmetric → "Symmetric (Mirror)"
• Replicate → "Replicate (Nearest)"
• ZeroPad → "Zero Padding"
• Adaptive → "Adaptive"

public enum BoundaryMode { Symmetric, Replicate, Adaptive, ZeroPad }

private double GetValueWithBoundary(double[] data, int idx, BoundaryMode mode)
{
    int n = data.Length;

    switch (mode)
    {
        case BoundaryMode.Symmetric : 
            if (idx < 0)
                idx = -idx - 1;
            else if (idx >= n)
                idx = 2 * n - idx - 1;

            if (idx < 0)
                return 0;

            return data[idx];

        case BoundaryMode.Replicate : 
            if (idx < 0)
                idx = 0;
            else if (idx >= n)
                idx = n - 1;

            return data[idx];

        case BoundaryMode.ZeroPad : 
            if (idx < 0 || idx >= n)
                return 0.0;

            return data[idx];

        case BoundaryMode.Adaptive : 
            // Single-sample access : treat like symmetric (window logic handled separately)
            if (idx < 0)
                idx = -idx - 1;
            else if (idx >= n)
                idx = 2 * n - idx - 1;

            if (idx < 0)
                return 0;

            return data[idx];

        default : 
            if (idx < 0)
                idx = -idx - 1;
            else if (idx >= n)
                idx = 2 * n - idx - 1;

            if (idx < 0)
                return 0;

            return data[idx];
    }
}

Non‑Adaptive paths (Rect, Avg, Med, GaussMed, Gauss, SG) fetch samples through a unified accessor GetValueWithBoundary(data, idx, mode).

Adaptive paths differ per filter :

• Rect, Avg, Med, GaussMed, Gauss: the window is trimmed to in‑range samples and processed directly without padding.
  • Rect: computes the simple mean of the truncated window (W), averaging only the in-range samples (no zero / repeat padding).
  • Avg: recomputes a local binomial row for truncated W, normalizes by its sum, and averages (no sort).
  • Med: recomputes local binomial weights for truncated W, sorts by value, and selects the weighted median (handles even / odd total weight).
  • GaussMed: recomputes local Gaussian weights for truncated W with σ = W / Sigma Factor (Sigma Factor is always clamped to [1.0, 12.0]), normalizes; sorts (value, weight) pairs by value and selects the weighted median where cumulative weight ≥ 1 / 2.
  • Gauss: recomputes a Gaussian kernel for truncated W with σ = W / Sigma Factor (Sigma Factor is always clamped to [1.0, 12.0]), normalizes, then computes a weighted average (convolution‑like sum, no sort).
• SG: keeps the intended window length (2r + 1) by shifting an asymmetric window near edges. If full support cannot be met, the effective polynomial order is clamped to effPoly = min(polyOrder, W - 1); a runtime check throws when derivOrder > effPoly. Asymmetric coefficients are recomputed per (left, right) shape and cached.

• Symmetric : recommended default for smooth analytical signals (mirror mapping).
• Replicate : suitable for stepwise / plateau sensor data (nearest endpoint).
• ZeroPad : emphasizes decay / contrast at boundaries.
• Adaptive : edge‑aware; window trimming or shifting per filter (see below).

Auto‑switching behavior (suppressed if _userSelectedBoundary is true; _suppressAutoBoundary prevents feedback loops):

• Rectangular selected → Boundary Method set to "Replicate"
• Binomial Average / Binomial Median / Gaussian Weighted Median / Gaussian selected → Boundary Method set to "Symmetric"
• Savitzky-Golay selected → Boundary Method set to "Adaptive"

• Rectangular (Moving Average) :

  • Window shrinks at edges : W = left + right + 1
  • Averages only in‑range samples (no zero / replicate bias)

• Binomial Average :

  • Computes a fresh binomial row for the truncated W using CalcBinomialCoefficients(W)
  • Normalizes by the local sum; does not slice the full 2r + 1 row

• Binomial Median (Weighted Median with binomial weights) :

  • Recomputes local binomial weights for truncated W
  • Performs weighted median over strictly in‑range values sorted by value

• Gaussian Weighted Median :

  • Recomputes local Gaussian weights for truncated W with σ = W / sigmaFactor
  • Sorts (value, weight) pairs by value; selects the smallest index where cumulative weight ≥ half of total

• Gaussian :

  • Recomputes a Gaussian kernel for truncated W with σ = W / sigmaFactor
  • Coefficients are normalized (sum = 1); no padding distortions

• Savitzky-Golay (Smoothing or Derivative) :

  • Attempts to retain window length 2r + 1 by shifting left / right near edges
  • Effective polynomial order: effPoly = min(polyOrder, W - 1)
  • Throws InvalidOperationException if derivOrder > effPoly
  • Uses asymmetric coefficients from least‑squares on the shifted grid (recomputed for each (left, right) shape)

SonataSmooth provides a robust, user-friendly interface for entering and managing numerical datasets :

• Manual Entry : Users can type values directly into the input box and add them to the Initial Dataset with a button click or by pressing Enter.
• Clipboard Paste : Numeric values can be pasted from the clipboard; the app uses optimized regular expressions to extract numbers, even from mixed or formatted text.
• Drag & Drop : Supports dropping plain text, CSV, or HTML-formatted data; HTML tags are stripped and all valid numbers are parsed.
• Batch Addition : Large datasets are added in batches to the ListBox, with real-time progress feedback and smooth UI updates. (Batch Addition detail : items are appended in chunks of 1000 per AddItemsInBatches to keep UI responsive.)
• Validation : All input is validated for numeric format; errors are reported with clear messages and invalid entries are rejected.
• Selection & Editing : Items can be selected, deselected, edited (single or multiple), deleted, or copied to the clipboard. Selection operations are optimized for large lists.
• Copy Behavior : If no items (or all items) are selected, copying exports the entire list; if a partial selection exists, only the selected items are copied. (Applies to both Initial and Refined datasets.)
• Clear All Behavior : Clearing all items in the Initial Dataset also clears the Refined Dataset and resets related status labels and placeholders.
• Delete Selected Behavior : When deleting only selected items, the Initial Dataset removes those items and the Refined Dataset is preserved. If all items are selected (i.e., selected count equals total count), the operation behaves like Clear All : the Refined Dataset is cleared and the dataset title is reset to the placeholder (centered, gray).
• Selection Operation Cancellation : "Select All" uses internal CancellationTokenSource instances (_ctsInitSelectAll, _ctsRefSelectAll) so starting a new selection immediately cancels any in‑progress selection. The UI remains responsive and can be retriggered to interrupt long operations.

When large batches are added (paste / drag-drop / bulk append), the list auto-scrolls to the newest appended item (TopIndex set to last) to provide immediate visual confirmation.

• Defines how many data points on each side of the target point are included in the smoothing window.
• The kernel width is calculated as (2 × radius) + 1.
• For Gaussian-based filters, the standard deviation (σ) is computed as : σ = (2 × radius + 1) / Sigma Factor where Sigma Factor is user-selectable (default : 6.0, range : 1.0 - 12.0).
• Recommended range : 3 to 7.
• If the kernel window is larger than the dataset, the app will show an error and prevent calibration / export.

Kernel radius specifies how many data points on each side of the center element are included in the filtering window. The total window length (kernel width) is calculated as 2 × r + 1.

The total window length (kernel width) is calculated as :

$$ [ \text{kernelWidth} = 2 \times r + 1 ] $$

For example, if (r = 2) :

$$ [ \text{kernelWidth} = 2 \times 2 + 1 = 5 ] $$

This means your median (or any other sliding-window) filter will span 5 consecutive samples at each position.

• Sigma Factor is a user-configurable parameter (default : 6.0, clamped to [1.0, 12.0]) that determines the standard deviation (σ) of the Gaussian kernel used in both Gaussian Weighted Median Filtering and Gaussian Filtering. In Symmetric mode, σ = (2 × radius + 1) / Sigma Factor; in Adaptive mode, σ = W / Sigma Factor (W : window length at each index). The actual Sigma Factor value is always reflected in all calculations and in the export metadata (CSV / Excel).
  • Symmetric mode : σ = (2 × radius + 1) / Sigma Factor
  • Adaptive mode : σ = W / Sigma Factor (where W is the window length at each index)
  • The Sigma Factor value is always reflected in all calculations and in the export metadata (CSV / Excel).
  • The value is clamped to the range [1.0, 12.0] for stability and consistency.

• Specifies the degree of the polynomial used to fit the data within each smoothing window (used only for Savitzky-Golay filtering).
  • Recommended range : 2 to 6.
  • Must be strictly less than the kernel window size; otherwise, an error is shown.

Polynomial order polyOrder specifies the highest degree of the polynomial fitted to the data within each smoothing window. A higher order can capture more complex curvature but may also overfit noise. The polynomial order is defined as :

polyOrder = degree of the polynomial

For example, if (polyOrder = 2) :

This means the filter will fit a 2nd-degree polynomial (a parabola) across each window of data points.

• polyOrder must be less than the window length (2 × r + 1) to ensure a well-posed fitting problem.
• Increasing polyOrder improves flexibility but risks ringing artifacts at the boundaries.
• Common practice is to start with polyOrder = 2 or 3 and adjust based on how well features are preserved versus noise reduction.
• Always validate smoothing performance on representative signal segments before batch processing.

(Displayed only when Savitzky-Golay is selected.)

• Defines which derivative of the fitted local polynomial is evaluated.
• Constraint : derivOrder ≤ polyOrder
• Effective clamp (Adaptive edges) : effPoly = min(polyOrder, W - 1); runtime validation enforces derivOrder ≤ effPoly.
• Scaling : coefficients multiplied by factorial(derivOrder) / delta^derivOrder (delta = 1.0).
• Recommended range : 0 - 3 (higher orders amplify noise sharply).

Typical uses :

• 0 : Smoothing (baseline SG)
• 1 : Slope estimation
• 2 : Curvature / peak detection
• 3 : Inflection diagnostics (only with sufficiently wide windows)

• Window size : windowSize = 2 × radius + 1
• Constraint : windowSize ≤ dataCount
• Polynomial constraint (SG only) : polyOrder < windowSize
• Derivative constraint (SG only) : derivOrder ≤ polyOrder
• Adaptive SG edge constraint : if effPoly = min(polyOrder, W - 1) then derivOrder ≤ effPoly

Failure triggers explicit error dialogs matching runtime validation.

Caution : If the dataset count is smaller than the required window size ((2 × radius) + 1), calibration / export is aborted with a dialog instead of attempting partial smoothing.

• Regex-based Parsing : Uses compiled regular expressions to efficiently extract numbers from any text source.
• Batch UI Updates : ListBox modifications (add, delete, edit) are performed in batches to prevent flicker and maintain responsiveness.
• Progress Feedback : ProgressBar and status labels provide immediate feedback during bulk operations.
• Error Handling : All parsing and input errors are caught and reported to the user, preventing silent failures.
• Parameter Validation : Kernel radius and polynomial order are validated before any smoothing operation.

// Manual entry
private void btnInitAdd_Click(object sender, EventArgs e)
{
    if (double.TryParse(txtInitAdd.Text, out double value))
    {
        lbInitData.Items.Add(value);
        lblInitCnt.Text = "Count : " + lbInitData.Items.Count;
        slblDesc.Visible = true;
        slblDesc.Text = $"Value '{value}' has been added to Initial Dataset.";
    }
    else
    {
        txtInitAdd.Focus();
        txtInitAdd.SelectAll();
    }
    UpdatelbInitDataBtnsState(null, EventArgs.Empty);
    UpdatelbRefinedDataBtnsState(null, EventArgs.Empty);
    txtInitAdd.Text = String.Empty;
}

// Clipboard paste
private async void btnInitPaste_Click(object sender, EventArgs e)
{
    string text = Clipboard.GetText();
    var matches = clipboardRegex.Matches(text)
        .Cast<Match>()
        .Where(m => !string.IsNullOrEmpty(m.Value))
        .ToArray();
    double[] values = await Task.Run(() =>
        matches.AsParallel()
            .WithDegreeOfParallelism(Environment.ProcessorCount)
            .Select(m => double.Parse(m.Value, NumberStyles.Any, CultureInfo.InvariantCulture))
            .ToArray()
    );
    lbInitData.BeginUpdate();
    lbInitData.Items.AddRange(values.Cast<object>().ToArray());
    lbInitData.EndUpdate();
    lblInitCnt.Text = $"Count : {lbInitData.Items.Count}";
    UpdateStatusLabel(beforeCount);
}

// Drag & drop
private async void lbInitData_DragDrop(object sender, DragEventArgs e)
{
    string raw = GetDropText(e);
    if (string.IsNullOrWhiteSpace(raw)) return;
    if (raw.IndexOf("<html", StringComparison.OrdinalIgnoreCase) >= 0)
        raw = await Task.Run(() => htmlTagRegex.Replace(raw, " "));
    double[] parsed = await Task.Run(() =>
        numberRegex.Matches(raw)
            .Cast<Match>()
            .AsParallel()
            .AsOrdered()
            .WithDegreeOfParallelism(Environment.ProcessorCount)
            .Select(m => double.TryParse(m.Value.Replace(",", "").Trim(), NumberStyles.Any, CultureInfo.InvariantCulture, out double d) ? d : double.NaN)
            .Where(d => !double.IsNaN(d))
            .ToArray()
    );
    await AddItemsInBatches(lbInitData, parsed, progressReporter, 60);
    lblInitCnt.Text = "Count : " + lbInitData.Items.Count;
    UpdateStatusLabel(beforeCount);
}

// Parameter validation
// Result wrapper (mirrors FrmMain.cs)
private struct OperationResult
{
    public bool Success { get; }
    public string Error { get; }

    private OperationResult(bool success, string error)
    {
        Success = success;
        Error = error;
    }

    public static OperationResult OK() => new OperationResult(true, null);

    public static OperationResult Fail(string error) => new OperationResult(false, error);
}

// Parameter validation
private OperationResult ValidateSmoothingParameters(int dataCount, int w, int polyOrder)
{
    int windowSize = 2 * w + 1;
    bool useSG = rbtnSG != null && rbtnSG.Checked;

    if (windowSize > dataCount)
    {
        var msg =
            "Kernel radius is too large.\n\n" +
            "Window size formula : (2 × radius) + 1\n" +
            $"Current : (2 × {w}) + 1 = {windowSize}\n" +
            $"Data count : {dataCount}\n\n" +
            "Rule : windowSize ≤ dataCount";

        return OperationResult.Fail(msg);
    }

    if (useSG && polyOrder >= windowSize)
    {
        var msg =
            "Polynomial order must be smaller than the window size.\n\n" +
            "Rule : polyOrder < windowSize\n" +
            $"Current polyOrder : {polyOrder}\n" +
            $"Window size : {windowSize}\n\n" +
            "Tip : windowSize = (2 × radius) + 1";

        return OperationResult.Fail(msg);
    }

    return OperationResult.OK();
}

Alpha α blends the original sample with the filtered output for selected methods :

• Applicable to: Binomial Averaging, Binomial Median, Gaussian Weighted Median Filtering (GWMF), Gaussian
• Not applied to: Rectangular, Savitzky‑Golay (including derivatives)
• Formula per element i : output[i] = α * filtered[i] + (1 - α) * input[i]
• Range : 0.00 – 1.00 (clamped)
• UI binding : cbxAlpha and lblAlpha are enabled only for rbtnAvg, rbtnMed, rbtnGauss, rbtnGaussMed

Runtime usage in smoothing (extended to GWMF) :

double a = alpha;

if (a < 0.0)
{
    a = 0.0;
}
else if (a > 1.0)
{
    a = 1.0;
}

// Binomial Average (blended)
binomAvg[i] = a * filtered + (1.0 - a) * input[i];

// Binomial Median (blended)
median[i] = a * filtered + (1.0 - a) * input[i];

// Gaussian Weighted Median (blended)
gaussMedian[i] = a * filtered + (1.0 - a) * input[i];

// Gaussian (blended)
gauss[i] = a * filtered + (1.0 - a) * input[i];

Alpha enablement and synchronization with Export Settings :

• UI binding : cbxAlpha and lblAlpha are enabled for rbtnAvg, rbtnMed, rbtnGauss, rbtnGaussMed.

private void UpdateAlphaEnablement()
{
    bool alphaRelevant = rbtnAvg.Checked || rbtnMed.Checked || rbtnGaussMed.Checked || rbtnGauss.Checked;

    lblAlpha.Enabled = alphaRelevant;
    cbxAlpha.Enabled = alphaRelevant;

    if (cbxAlpha.Enabled && string.IsNullOrWhiteSpace(cbxAlpha.Text))
    {
        cbxAlpha.Text = "1.00";
    }
}

private void cbxAlpha_SelectedIndexChanged(object sender, EventArgs e)
{
    double alpha = ParseAlphaOrDefault(cbxAlpha.Text, 1.0);

    cbxAlpha.Text = alpha.ToString("0.00", CultureInfo.InvariantCulture);

    if (settingsForm.cbxAlpha != null)
    {
        settingsForm.cbxAlpha.Text = cbxAlpha.Text;
    }

    UpdateAlphaEnablement();
}

Boundary-method auto-switching and Alpha enablement hooks :

private void rbtnAvg_CheckedChanged(object sender, EventArgs e)
{
    if (rbtnAvg.Checked)
    {
        SetAlphaEnabled(true);
        SetBoundaryMethod("Symmetric");
    }

    UpdateAlphaEnablement();
}

private void rbtnMed_CheckedChanged(object sender, EventArgs e)
{
    if (rbtnMed.Checked)
    {
        SetAlphaEnabled(true);
        SetBoundaryMethod("Symmetric");
    }

    UpdateAlphaEnablement();
}

private void rbtnGauss_CheckedChanged(object sender, EventArgs e)
{
    if (rbtnGauss.Checked)
    {
        SetAlphaEnabled(true);
        SetBoundaryMethod("Symmetric");
    }

    UpdateAlphaEnablement();
}

Leverage all CPU cores without blocking the UI. The smoothing kernels are executed with Parallel.For (small arrays run serially), writing per-index results to distinct buffers. PLINQ is used only in input parsing (clipboard / drag-drop), not in the smoothing pass.

When the user clicks "Calibrate", the application processes the input data using the selected filter. The computation is parallelized using Parallel.For (falls back to serial for small n).

• When the user calibrates or exports data, the selected filters are applied to each data point in parallel.
• Each filter uses its own kernel (window) and boundary handling (selected boundary mode, including Adaptive).
• All filter results are computed in a single pass, leveraging all available CPU cores.
• The UI remains responsive, and progress is reported in real time.

Adaptive mode introduces per-index dynamic window sizing or window shifting (Savitzky-Golay). Parallel execution remains safe because each index writes to distinct output arrays and uses only read-only input. Minimum size for parallel dispatch : if n < 2000 a serial loop is used to avoid Parallel.For overhead (threshold hard-coded in ApplySmoothing).

Leverage all CPU cores to avoid blocking the UI. PLINQ's .AsOrdered() preserves the original order, and .WithDegreeOfParallelism matches the number of logical processors.

• Parallelization : Uses Parallel.For for the smoothing pass. PLINQ is used only for input parsing (clipboard / drag‑drop), not during kernel execution.
• Single-Pass Multi-Filter : All enabled filters are computed together, minimizing memory usage and maximizing throughput.
• Boundary Handling : Edge behavior is configurable (Symmetric / Replicate / Zero‑Pad / Adaptive) for every smoothing method.
• Thread-Safe UI : Progress bars and status labels are updated safely from background threads.

private (double[] Rect, double[] Binom, double[] Median, double[] GaussMed, double[] Gauss, double[] SG)
    ApplySmoothing(
        double[] input,
        int r,
        int polyOrder,
        int derivOrder,
        double delta,
        BoundaryMode boundaryMode,
        bool doRect,
        bool doAvg,
        bool doMed,
        bool doGaussMed,
        bool doGauss,
        bool doSG,
        double alpha = 1.0,
        double sigmaFactor = 6.0)
{
    var vr = ValidateSmoothingParameters(input?.Length ?? 0, r, polyOrder);
    if (!vr.Success)
        throw new InvalidOperationException(vr.Error);

    // Savitzky-Golay constraint : derivative order must not exceed polynomial order
    if (doSG && derivOrder > polyOrder)
    {
        throw new InvalidOperationException(
            $"Derivative order must be ≤ polynomial order.\n\n" +
            $"Current derivativeOrder : {derivOrder}\n" +
            $"Current polyOrder : {polyOrder}");
    }

    int n = input.Length;
    int windowSize = 2 * r + 1;

    // Precompute weight vectors where applicable
    long[] binom = (doAvg || doMed) ? CalcBinomialCoefficients(windowSize) : null;
    double[] gaussCoeffsForMedian = doGaussMed ? ComputeGaussianCoefficients(windowSize, (windowSize, (2.0 * r + 1) / sigmaFactor) : null;
    double[] gaussCoeffs = doGauss ? ComputeGaussianCoefficients(windowSize, (windowSize, (2.0 * r + 1) / sigmaFactor) : null;

    // SG symmetric coefficients (used only when not in Adaptive boundary mode)
    double[] sgSmoothCoeffs = (doSG && derivOrder == 0 && boundaryMode != BoundaryMode.Adaptive)
        ? ComputeSavitzkyGolayCoefficients(windowSize, polyOrder, derivOrder: 0, delta: 1.0)
        : null;

    double[] sgDerivCoeffs = (doSG && derivOrder > 0 && boundaryMode != BoundaryMode.Adaptive)
        ? ComputeSavitzkyGolayCoefficients(windowSize, polyOrder, derivOrder, delta)
        : null;

    var rect = new double[n];
    var binomAvg = new double[n];
    var median = new double[n];
    var gaussMedian = new double[n];
    var gauss = new double[n];
    var sg = new double[n];

    // Precompute constants for averaging
    double invRectDiv = (doRect && windowSize > 0) ? 1.0 / windowSize : 0.0;
    double binomSum = 0.0;
    if (doAvg && binom != null)
    {
        for (int i = 0; i < binom.Length; i++)
            binomSum += binom[i];
    }

    // Unified boundary-aware sample accessor
    double Sample(int idx) => GetValueWithBoundary(input, idx, boundaryMode);

    // Clamp alpha once for the entire pass
    double a = alpha;
    if (a < 0.0) a = 0.0;
    else if (a > 1.0) a = 1.0;

    // Adaptive window helper (trim to available samples)
    void GetAdaptiveWindow(int center, out int left, out int right, out int start)
    {
        left = Math.Min(r, center);
        right = Math.Min(r, n - 1 - center);
        start = center - left;
    }

    bool useParallel = n >= 2000;

    Action<int> smoothingAction = i =>
    {
        // Rectangular (no blending)
        if (doRect)
        {
            if (boundaryMode == BoundaryMode.Adaptive)
            {
                GetAdaptiveWindow(i, out int left, out int right, out int start);
                int W = left + right + 1;
                double sum = 0.0;
                for (int pos = 0; pos < W; pos++)
                    sum += input[start + pos];
                rect[i] = W > 0 ? sum / W : 0.0;
            }
            else
            {
                double sum = 0.0;
                for (int k = -r; k <= r; k++)
                    sum += Sample(i + k);
                rect[i] = sum * invRectDiv;
            }
        }

        // Binomial Average (with blending)
        if (doAvg && binom != null)
        {
            double filtered;
            if (boundaryMode == BoundaryMode.Adaptive)
            {
                GetAdaptiveWindow(i, out int left, out int right, out int start);
                int W = left + right + 1;
                if (W < 1)
                {
                    filtered = 0.0;
                }
                else
                {
                    long[] localBinom = CalcBinomialCoefficients(W);
                    double localSum = 0.0;
                    for (int j = 0; j < W; j++) localSum += localBinom[j];

                    double sum = 0.0;
                    for (int pos = 0; pos < W; pos++)
                        sum += input[start + pos] * localBinom[pos];

                    filtered = localSum > 0 ? sum / localSum : 0.0;
                }
            }
            else
            {
                double sum = 0.0;
                for (int k = -r; k <= r; k++)
                    sum += Sample(i + k) * binom[k + r];
                filtered = binomSum > 0 ? sum / binomSum : 0.0;
            }
            binomAvg[i] = a * filtered + (1.0 - a) * input[i];
        }

        // Binomial Median (with blending)
        if (doMed && binom != null)
        {
            double filtered;
            if (boundaryMode == BoundaryMode.Adaptive)
            {
                GetAdaptiveWindow(i, out int left, out int right, out int start);
                int W = left + right + 1;
                if (W < 1)
                {
                    filtered = 0.0;
                }
                else
                {
                    long[] localBinom = CalcBinomialCoefficients(W);
                    var pairs = new List<(double Value, long Weight)>(W);
                    for (int pos = 0; pos < W; pos++)
                        pairs.Add((input[start + pos], localBinom[pos]));

                    if (pairs.Count == 0)
                    {
                        filtered = 0.0;
                    }
                    else
                    {
                        pairs.Sort((aV, bV) => aV.Value.CompareTo(bV.Value));

                        long totalWeight = 0;
                        for (int j = 0; j < pairs.Count; j++)
                            totalWeight += pairs[j].Weight;

                        if (totalWeight <= 0)
                        {
                            filtered = 0.0;
                        }
                        else
                        {
                            bool even = (totalWeight & 1L) == 0;
                            long half = totalWeight / 2;
                            long accum = 0;
                            filtered = pairs[pairs.Count - 1].Value;

                            for (int j = 0; j < pairs.Count; j++)
                            {
                                accum += pairs[j].Weight;
                                if (accum > half)
                                {
                                    filtered = pairs[j].Value;
                                    break;
                                }
                                if (even && accum == half)
                                {
                                    double nextVal = (j + 1 < pairs.Count) ? pairs[j + 1].Value : pairs[j].Value;
                                    filtered = (pairs[j].Value + nextVal) / 2.0;
                                    break;
                                }
                            }
                        }
                    }
                }
            }
            else
            {
                filtered = WeightedMedianAt(input, i, r, binom, boundaryMode, a);
            }
            median[i] = a * filtered + (1.0 - a) * input[i];
        }

        // Gaussian Weighted Median (with blending)
        if (doGaussMed && gaussCoeffsForMedian != null)
        {
            double filtered;
            if (boundaryMode == BoundaryMode.Adaptive)
            {
                int left = Math.Min(r, i);
                int right = Math.Min(r, n - 1 - i);
                int start = i - left;
                int W = left + right + 1;

                if (W < 1)
                {
                    filtered = 0.0;
                }
                else
                {
                    double sigmaLocal = W / sigmaFactor;
                    double[] localGauss = ComputeGaussianCoefficients(W, sigmaLocal);

                    var values = new double[W];
                    var wts = new double[W];
                    for (int pos = 0; pos < W; pos++)
                    {
                        int absIdx = start + pos;
                        values[pos] = input[absIdx];
                        wts[pos] = localGauss[pos]; // weights centered in the local window
                    }

                    Array.Sort(values, wts);

                    double total = 0.0;
                    for (int j = 0; j < W; j++) total += wts[j];

                    if (total > 0.0)
                    {
                        double half = total / 2.0;
                        double accum = 0.0;
                        int sel = W - 1;
                        for (int j = 0; j < W; j++)
                        {
                            accum += wts[j];
                            if (accum >= half) { sel = j; break; }
                        }
                        filtered = values[sel];
                    }
                    else
                    {
                        filtered = 0.0;
                    }
                }
            }
            else
            {
                int W = 2 * r + 1;
                var values = new double[W];
                var wts = new double[W];

                for (int k = -r; k <= r; k++)
                {
                    int idx = i + k;
                    values[k + r] = Sample(idx);
                    wts[k + r] = gaussCoeffsForMedian[k + r];
                }

                Array.Sort(values, wts);

                double total = 0.0;
                for (int j = 0; j < W; j++) total += wts[j];

                if (total > 0.0)
                {
                    double half = total / 2.0;
                    double accum = 0.0;
                    int sel = W - 1;
                    for (int j = 0; j < W; j++)
                    {
                        accum += wts[j];
                        if (accum >= half) { sel = j; break; }
                    }
                    filtered = values[sel];
                }
                else
                {
                    filtered = Sample(i);
                }
            }
            gaussMedian[i] = a * filtered + (1.0 - a) * input[i];
        }

        // Gaussian (with blending)
        if (doGauss && gaussCoeffs != null)
        {
            double filtered;
            if (boundaryMode == BoundaryMode.Adaptive)
            {
                GetAdaptiveWindow(i, out int left, out int right, out int start);
                int W = left + right + 1;
                if (W < 1)
                {
                    filtered = 0.0;
                }
                else
                {
                    double sigmaLocal = W / sigmaFactor;
                    double[] localGauss = ComputeGaussianCoefficients(W, sigmaLocal);
                    double sum = 0.0;
                    for (int pos = 0; pos < W; pos++)
                        sum += localGauss[pos] * input[start + pos];
                    filtered = sum;
                }
            }
            else
            {
                double sum = 0.0;
                for (int k = -r; k <= r; k++)
                    sum += gaussCoeffs[k + r] * Sample(i + k);
                filtered = sum;
            }
            gauss[i] = a * filtered + (1.0 - a) * input[i];
        }

        // Savitzky-Golay (no blending)
        if (doSG)
        {
            if (boundaryMode == BoundaryMode.Adaptive)
            {
                int desiredW = windowSize;
                int left = Math.Min(r, i);
                int right = desiredW - 1 - left;

                // Shift window to stay within bounds
                if (i + right > n - 1)
                {
                    int shift = (i + right) - (n - 1);
                    right -= shift;
                    left += shift;
                }

                if (left < 0) left = 0;
                if (right < 0) right = 0;

                double sum = 0.0;
                if (derivOrder == 0)
                {
                    var coeffs = ComputeSGCoefficientsAsymmetric(left, right, polyOrder);
                    for (int k = -left; k <= right; k++)
                        sum += coeffs[k + left] * input[i + k];
                }
                else
                {
                    int W = left + right + 1;
                    int effPoly = Math.Min(polyOrder, W - 1);
                    if (derivOrder > effPoly)
                    {
                        throw new InvalidOperationException(
                            $"Edge-adaptive window too small for derivative (W = {W}, effPoly = {effPoly}, derivative = {derivOrder}).");
                    }

                    var coeffs = ComputeSGCoefficientsAsymmetricDerivative(left, right, effPoly, derivOrder, delta);
                    for (int k = -left; k <= right; k++)
                        sum += coeffs[k + left] * input[i + k];
                }
                sg[i] = sum;
            }
            else
            {
                if (derivOrder == 0 && sgSmoothCoeffs != null)
                {
                    double sum = 0.0;
                    for (int k = -r; k <= r; k++)
                        sum += sgSmoothCoeffs[k + r] * Sample(i + k);
                    sg[i] = sum;
                }
                else if (derivOrder > 0 && sgDerivCoeffs != null)
                {
                    double sum = 0.0;
                    for (int k = -r; k <= r; k++)
                        sum += sgDerivCoeffs[k + r] * Sample(i + k);
                    sg[i] = sum;
                }
            }
        }
    };

    // Dispatch : parallel for large arrays; serial for small to avoid overhead
    if (useParallel)
    {
        Parallel.For(0, n, smoothingAction);
    }
    else
    {
        for (int i = 0; i < n; i++)
            smoothingAction(i);
    }

    return (rect, binomAvg, median, gaussMedian, gauss, sg);
}

A simple sliding-window average over 2 × r + 1 points honoring the selected Boundary Mode (Symmetric, Replicate, Zero‑Pad). In Adaptive mode, the window shrinks at edges and averages only in‑range samples (no zero or repeat padding is used).

Every neighbor contributes equally (uniform weights).

• Uniform Weights : Each value in the window contributes equally.
• Noise Reduction : Smooths out short-term fluctuations.

if (useRect)
{
    double Sample(int idx) => GetValueWithBoundary(input, idx, boundaryMode);
    double invRectDiv = 1.0 / (2 * r + 1);
    
    for (int i = 0; i < input.Length; i++)
    {
        double sum = 0.0;
        for (int k = -r; k <= r; k++)
        {
            sum += Sample(i + k);
        }
        rectFiltered[i] = sum * invRectDiv;
    }
}

Averages values in the window, but each value is weighted according to binomial coefficients, giving more importance to central values.

A discrete approximation of Gaussian smoothing (binomial coefficients approximate a normal distribution).

• Binomial Weights : Central values have higher influence.
• Smoother Output : Reduces noise while maintaining signal shape.

else if (useAvg)
{
    long[] binom = CalcBinomialCoefficients(2 * r + 1);
    double binomSum = binom.Sum();
    double Sample(int idx) => GetValueWithBoundary(input, idx, boundaryMode);
    
    for (int i = 0; i < input.Length; i++)
    {
        double sum = 0.0;
        for (int k = -r; k <= r; k++)
        {
            sum += Sample(i + k) * binom[k + r];
        }
        binomFiltered[i] = sum / binomSum;
    }
}

In Adaptive mode, the kernel width shrinks at edges and a NEW binomial row of length W is computed (CalcBinomialCoefficients(W)), ensuring correct symmetric weighting rather than truncating the full-length coefficients.

Computes the median of values in the window, weighted by binomial coefficients, to reduce noise while preserving edges.

Median filtering is robust against outliers; binomial weights bias the median toward center points.

• Weighted Median : Each value's influence is determined by its weight.
• Edge Preservation : More robust to outliers than mean filters.

else if (useMed)
{
    long[] binom = CalcBinomialCoefficients(2 * r + 1);
    double Sample(int idx) => GetValueWithBoundary(input, idx, boundaryMode);
    
    for (int i = 0; i < input.Length; i++)
    {
        var pairs = new List<(double Value, long Weight)>();
        for (int k = -r; k <= r; k++)
        {
            pairs.Add((Sample(i + k), binom[k + r]));
        }
    
        pairs.Sort((a, b) => a.Value.CompareTo(b.Value));
        long totalWeight = pairs.Sum(p => p.Weight);
        long half = totalWeight / 2;
        bool even = (totalWeight & 1) == 0;
    
        long acc = 0;
        for (int j = 0; j < pairs.Count; j++)
        {
            acc += pairs[j].Weight;
            if (acc > half)
            {
                medianFiltered[i] = pairs[j].Value;
                break;
            }
            if (even && acc == half)
            {
                double next = (j + 1 < pairs.Count) ? pairs[j + 1].Value : pairs[j].Value;
                medianFiltered[i] = (pairs[j].Value + next) / 2.0;
                break;
            }
        }
    }
}

Adaptive recalculates local binomial weights for truncated W and performs weighted median over only in-range samples - removing edge padding bias. (Implementation detail : An adaptive path also exists inside WeightedMedianAt that keeps full window length by sliding; ApplySmoothing intentionally bypasses it and uses the truncated‑recompute strategy documented above.)

Computes the median within the kernel window using Gaussian weights centered at the target index. Unlike a mean filter, the median is robust to outliers; the Gaussian weights emphasize values closer to the center, improving fidelity on smooth curves while suppressing occasional spikes.

• Window length : W = 2 × r + 1 (symmetric) or W = left + right + 1 (Adaptive edges)
• Weights : Gaussian kernel g[k] = exp(-(k^2) / (2σ^2)) normalized to sum to 1
  • Symmetric mode : σ = (2 × radius + 1) / Sigma Factor
  • Adaptive mode : σ = W / Sigma Factor (W: window length at each index, recomputed per index)
  • Sigma Factor is user-configurable (default: 6.0), clamped to [1.0, 12.0], and applies to both Gaussian Weighted Median and Gaussian Filtering. The actual value used is always reflected in export metadata and calculations.
• Weighted median selection :
  • Sort pairs (value, weight) by value ascending
  • Accumulate weights until reaching at least half of the total (≥ Σw / 2)
  • The value at that position is the weighted median
• Boundary handling :
  • Non-Adaptive : Sample(i + k) uses GetValueWithBoundary for Symmetric / Replicate / ZeroPad
  • Adaptive : window truncates to available samples; weights are recomputed for W, and only in-range samples are used (no padding)
• Alpha blend (runtime, if enabled): output[i] = α × filtered[i] + (1 − α) × input[i] with α ∈ [0.00, 1.00]

GWMF combines the robustness of median filtering with the smoothness bias of Gaussian weighting :

• Robustness : The median is insensitive to extreme outliers compared to means.
• Locality : Gaussian weights peak at the center, ensuring nearby samples dominate.
• Edge correctness : Adaptive recomputes σ and weights for truncated windows, avoiding artificial padding biases.
• Stability : In symmetric mode weights are centered; in Adaptive mode weights remain centered in the local truncated window.

Mathematically :

• Kernel positions k ∈ [−r, …, r] (symmetric) or k ∈ [−left, …, right] (adaptive shift / truncate)
• Unnormalized weights : w(k) = exp(−k² / (2σ²))
• Normalization : g(k) = w(k) / Σ_j w(j)
• Weighted median v* solves min over threshold : find smallest index in sorted values s.t. Σ_{j ≤ *} g_sorted(j) ≥ 1 / 2

Alpha blend preserves a tunable fraction of the original signal, preventing over-smoothing :

• α = 0 → original
• α = 1 → fully filtered
• 0 < α < 1 → convex combination

Symmetric window (uses boundary accessor and precomputed Gaussian weights) :

// Symmetric GWMF inside ApplySmoothing (FrmMain.cs)
int W = 2 * r + 1;
var values = new double[W];
var wts = new double[W];

for (int k = -r; k <= r; k++)
{
    int idx = i + k;
    values[k + r] = Sample(idx); // GetValueWithBoundary
    wts[k + r] = gaussCoeffsForMedian[k + r]; // normalized Gaussian weights (σ = (2r + 1) / sigmaFactor)
}

// Sort by value ascending, carrying weights alongside
Array.Sort(values, wts);

// Select weighted median : cumulative weight crosses half
double total = 0.0;
for (int j = 0; j < W; j++)
{
    total += wts[j];
}

double filtered;
if (total > 0.0)
{
    double half = total / 2.0;
    double accum = 0.0;
    int sel = W - 1;

    for (int j = 0; j < W; j++)
    {
        accum += wts[j];
        if (accum >= half)
        {
            sel = j;
            break;
        }
    }

    filtered = values[sel];
}
else
{
    filtered = Sample(i); // fallback: original (degenerate weights)
}

// Alpha blend (applies when GWMF is enabled)
gaussMedian[i] = a * filtered + (1.0 - a) * input[i];

Adaptive window (recomputes σ and weights for truncated window W at each index) :

// Adaptive GWMF inside ApplySmoothing (FrmMain.cs)
int left = Math.Min(r, i);
int right = Math.Min(r, n - 1 - i);
int start = i - left;
int W = left + right + 1;

double filtered;
if (W < 1)
{
    filtered = 0.0;
}
else
{
    double sigmaLocal = W / sigmaFactor;
    double[] localGauss = ComputeGaussianCoefficients(W, sigmaLocal); // normalized per-window

    var values = new double[W];
    var wts = new double[W];

    for (int pos = 0; pos < W; pos++)
    {
        int absIdx = start + pos;
        values[pos] = input[absIdx]; // direct in-range access (Adaptive avoids padding)
        wts[pos] = localGauss[pos];
    }

    Array.Sort(values, wts);

    double total = 0.0;
    for (int j = 0; j < W; j++)
    {
        total += wts[j];
    }

    if (total > 0.0)
    {
        double half = total / 2.0;
        double accum = 0.0;
        int sel = W - 1;

        for (int j = 0; j < W; j++)
        {
            accum += wts[j];
            if (accum >= half)
            {
                sel = j;
                break;
            }
        }

        filtered = values[sel];
    }
    else
    {
        filtered = 0.0;
    }
}

// Alpha blend (applies when GWMF is enabled)
gaussMedian[i] = a * filtered + (1.0 - a) * input[i];

Applies a normalized 1D Gaussian kernel honoring the selected Boundary Mode (Symmetric, Replicate, ZeroPad, Adaptive). In Adaptive mode the kernel length W shrinks and σ = W / sigmaFactor is recomputed.

Gaussian weights emphasize central values, producing smooth results.

The standard deviation (σ) for the Gaussian kernel is calculated as :

• Symmetric mode : σ = (2 × radius + 1) / Sigma Factor
• Adaptive mode : σ = W / Sigma Factor (W : window length at each index)
• Sigma Factor is user-configurable (default : 6.0), clamped to [1.0, 12.0], and applies to both Gaussian Weighted Median and Gaussian Filtering. The actual value used is always reflected in export metadata and calculations.

if (useGauss)
{
    double sigma = (2.0 * r + 1) / sigmaFactor;
    
    // SigmaFactor is user-configurable (default : 6.0, range : 1.0 - 12.0)
    double[] gaussCoeffs = ComputeGaussianCoefficients(2 * r + 1, sigma);
    double Sample(int idx) => GetValueWithBoundary(input, idx, boundaryMode);

    for (int i = 0; i < input.Length; i++)
    {
        double sum = 0.0;
        for (int k = -r; k <= r; k++)
        {
            sum += gaussCoeffs[k + r] * Sample(i + k);
        }
        gaussFiltered[i] = sum;
    }
}

Adaptive mode recomputes a Gaussian kernel of length W with σ = W / Sigma Factor (where Sigma Factor is clamped to [1.0, 12.0]). This ensures the relative spread remains consistent across varying window sizes and avoids artificial flattening. The actual Sigma Factor used is always reflected in export metadata and calculations.

A fixed-size window of length 2 × r + 1 slides over the 1D signal.

At each position :

1. Out‑of‑bounds indices are handled according to the selected Boundary Mode. With Adaptive (auto‑selected when SG is chosen), the window is shifted asymmetrically near edges to maintain length without artificial padding; non‑Adaptive modes map indices using Mirror (Symmetric), Replicate (Nearest), or Zero‑Pad.
2. Each sample in the window is multiplied by its precomputed Savitzky‑Golay coefficient (derived from polynomial least‑squares fitting), and the weighted sum gives the smoothed output at the central point. (When Adaptive is selected, the window is shifted asymmetrically near edges and coefficients are recomputed from edge-specific least‑squares fits with caching.)

This method preserves important features such as peaks and edges better than simple moving averages.

Savitzky‑Golay filtering performs a least‑squares fit of a low‑degree polynomial to the samples in the window, then evaluates the polynomial at the center.
Unlike Gaussian filtering, the weights are not based on a bell‑shaped curve, but are determined analytically to minimize the mean‑squared error for the chosen polynomial degree.

• Polynomial Fitting : Fits a polynomial of specified degree within the window.
• Feature Preservation : Retains higher‑order moments (e.g., slope, curvature) while reducing high‑frequency noise.

else if (useSG)
{
    double[] sgCoeffs = ComputeSavitzkyGolayCoefficients(2 * r + 1, polyOrder, derivOrder : 0, delta : 1.0);
    double Sample(int idx) => GetValueWithBoundary(input, idx, boundaryMode);
    
    for (int i = 0; i < input.Length; i++)
    {
        double sum = 0.0;
        for (int k = -r; k <= r; k++)
        {
            sum += sgCoeffs[k + r] * Sample(i + k);
        }
        sgFiltered[i] = sum;
    }
}

Used only when Savitzky-Golay is selected.

Rules & Validation :

• derivOrder ≤ polyOrder (enforced during calibration & export).
• In adaptive edge windows : effective polynomial effPoly = min(polyOrder, W - 1); if derivOrder > effPoly, an error is raised.
• Coefficient scaling : derivative coefficients are multiplied by factorial(derivOrder) / delta^derivOrder (delta = 1.0 in current implementation).
• For derivOrder == 0, coefficients are normalized to sum to 1 (DC preservation). For derivOrder > 0, no DC normalization (derivative sums ≠ 1 by design).

Guidance :

• Start with 0 (smoothing) or 1 (slope).
• Higher orders rapidly amplify noise - ensure sufficient radius (larger window) before using 2 or 3.
• Avoid derivative orders close to polyOrder when the dataset is short or radius is minimal.
• For Adaptive edge windows, the effective polynomial order is clamped : effPoly = min(polyOrder, W - 1). Derivative coefficients are scaled by factorial(derivOrder) / delta^derivOrder after construction, matching the symmetric path.

To avoid recomputing edge-specific polynomial fits repeatedly, two in-memory caches are maintained :

• _sgAsymCoeffCache keyed by (left, right, effectivePolyOrder) for smoothing (derivOrder = 0)
• _sgAsymDerivCoeffCache keyed by (left, right, effectivePolyOrder, derivOrder, deltaBits) for derivatives

Cache keys :

• Smoothing : (left, right, effPoly)
• Derivative : (left, right, effPoly, derivOrder, deltaBits) where deltaBits = BitConverter.DoubleToInt64Bits(delta)

These caches drastically reduce overhead on large datasets with repeated edge window shapes.

After filtering, the results array is handed to AddItemsInBatches, which inserts items into lbRefinedData in chunks. This avoids freezing the UI and allows incremental progress updates. Finally, controls are reset.

Batch updates and progress reporting keep the UI responsive. A finally block ensures the progressbar always resets on completion or error.

• Batch UI Update : Efficiently updates the list box.
• Progress Feedback : Shows operation progress to the user.
• Status Reporting : Updates labels and enables / disables controls.

lbRefinedData.BeginUpdate();
lbRefinedData.Items.Clear();

await AddItemsInBatches(lbRefinedData, results, progressReporter, 60);

lbRefinedData.EndUpdate();
lblRefCnt.Text = $"Count : {lbRefinedData.Items.Count}";

slblCalibratedType.Text = useRect ? "Rectangular Average"
                     : useMed ? "Weighted Median"
                     : useAvg ? "Binomial Average"
                     : useSG ? "Savitzky-Golay Filter"
                     : useGauss ? "Gaussian Filter"
                                : "Unknown";

slblKernelRadius.Text = r.ToString();

Buttons btnInitSelectSync and btnRefSelectSync synchronize selected indices and scroll positions between Initial and Refined datasets.

Enablement rule :

• Both listboxes must contain the same number of items.
• At least one item is selected in the source listbox.

Behavior :

• Clears target selection.
• Copies all selected indices.
• Sets TopIndex of target to match source for scroll alignment. Status label displays a synchronized item count message.

• Select All : updates pbMain from 0% - 100% using dynamic intervals

  • Report interval : reportInterval = max(1, count / 100)
  • UI yield interval : yieldInterval = max(1, count / 1000) with await Task.Yield()
  • Cancelable : a new Select All starts cancels the previous via _ctsInitSelectAll / _ctsRefSelectAll
  • Completion : briefly holds 100%, then resets to 0

• Deselect All : step‑based progress (0 → selectedCount)

  • Increments the progress bar per deselected item with a small delay (await Task.Delay(10))
  • Resets to 0 on completion

This keeps very large list operations smooth and clearly communicated without blocking the UI thread.

Clicking "Clear Refined" removes all entries from the Refined Dataset and resets status indicators :

• slblCalibratedType → "--"
• slblKernelRadius → "--"
• SG parameter labels hidden : tlblPolyOrder, slblPolyOrder, and the separator label; slblPolyOrder text is set to "--"

The progress bar briefly shows 100% and then returns to 0% to signal completion.

Calculates binomial coefficients for a given window size, which are used as weights in the binomial average and weighted median filters.

• Pascal's Triangle : Each coefficient is the sum of the two above it, or mathematically, C(n, k) = n! / (k!(n - k)!).
• Symmetry : The coefficients are symmetric and always sum to a power of two.

private static long[] CalcBinomialCoefficients(int length)
{
    if (length < 1)
        throw new ArgumentException("length must be ≥ 1", nameof(length));

    // Limit 'length' to ensure the sum can be safely calculated within the 64-bit long range
    // (Condition : 2 ^ (length - 1) ≤ 2 ^ 62)
    if (length > 63)
        throw new ArgumentOutOfRangeException(nameof(length),
            "length must be ≤ 63 to avoid 64-bit weight sum overflow (2 ^ (length - 1) <= 2 ^ 62). Reduce kernel radius.");

    var c = new long[length];
    c[0] = 1; // The first coefficient is always 1

    try
    {
        checked // Throw an exception if an overflow occurs
        {
            for (int i = 1; i < length; i++)
                c[i] = c[i - 1] * (length - i) / i;
        }
    }
    catch (OverflowException ex)
    {
        throw new InvalidOperationException(
            $"Binomial coefficient overflow for length = {length}. Try a smaller kernel radius.", ex);
    }
    return c;
}

• This function generates the coefficients for the (length - 1) th row of Pascal's triangle, which are used as weights for the filters.
• Maximum supported window length for binomial weighting is 63 (length ≤ 63) to prevent 64‑bit overflow of the cumulative weight (2^(length − 1) ≤ 2^62). Attempts above this throw an exception.

Constructs a Vandermonde matrix for the window, computes its normal equations, inverts the Gram matrix, and multiplies back by the transposed design matrix. The first row of the resulting "smoother matrix" yields the filter coefficients.

Savitzky-Golay filters derive from least‐squares polynomial fitting.

• Build matrix A where each row contains powers of the relative offset within the window.
• Form the normal equations (AᵀA), invert them, and multiply by Aᵀ to get the pseudoinverse.
• The convolution coefficients for smoothing (value at central point) are the first row of this pseudoinverse.

private static double[] ComputeSavitzkyGolayCoefficients(
    int windowSize,
    int polyOrder,
    int derivOrder,
    double delta)
{
    if (windowSize <= 0)
        throw new ArgumentOutOfRangeException(nameof(windowSize), "windowSize must be > 0.");

    if ((windowSize & 1) == 0)
        throw new ArgumentException("windowSize must be odd (2 * r + 1).", nameof(windowSize));

    if (polyOrder < 0)
        throw new ArgumentOutOfRangeException(nameof(polyOrder), "polyOrder must be ≥ 0.");

    if (polyOrder >= windowSize)
        throw new ArgumentException("polyOrder must be < windowSize.", nameof(polyOrder));

    if (derivOrder < 0)
        throw new ArgumentOutOfRangeException(nameof(derivOrder), "derivOrder must be ≥ 0.");

    if (derivOrder > polyOrder)
        throw new ArgumentException("derivOrder must be ≤ polyOrder.");

    if (delta <= 0)
        throw new ArgumentOutOfRangeException(nameof(delta), "delta must be > 0.");

    int m = polyOrder;
    int half = windowSize / 2;

    // Design matrix
    var A = new double[windowSize, m + 1];
    for (int i = -half; i <= half; i++)
    {
        double x = i;
        double p = 1.0;
        for (int j = 0; j <= m; j++)
        {
            A[i + half, j] = p;
            p *= x;
        }
    }

    // Normal equations (A^T A)
    var ATA = new double[m + 1, m + 1];
    for (int i = 0; i <= m; i++)
    {
        for (int j = 0; j <= m; j++)
        {
            double s = 0;
            for (int k = 0; k < windowSize; k++)
                s += A[k, i] * A[k, j];
            ATA[i, j] = s;
        }
    }

    var invATA = InvertMatrixStrict(ATA);

    // A^T
    var AT = new double[m + 1, windowSize];
    for (int i = 0; i <= m; i++)
    {
        for (int k = 0; k < windowSize; k++)
            AT[i, k] = A[k, i];
    }

    // Coefficient row for derivOrder
    var h = new double[windowSize];
    for (int k = 0; k < windowSize; k++)
    {
        double sum = 0;
        for (int j = 0; j <= m; j++)
            sum += invATA[derivOrder, j] * AT[j, k];
        h[k] = sum;
    }

    if (derivOrder == 0)
    {
        // DC normalization for smoothing
        double total = 0;
        for (int i = 0; i < windowSize; i++)
            total += h[i];

        if (Math.Abs(total) < 1e-20)
            throw new InvalidOperationException("Computed Savitzky-Golay coefficients sum to ~ 0.");

        for (int i = 0; i < windowSize; i++)
            h[i] /= total;
    }
    else
    {
        // Derivative scaling : factorial(d) / Δ^d
        double scale = FactorialAsDouble(derivOrder) / Math.Pow(delta, derivOrder);
        for (int i = 0; i < windowSize; i++)
            h[i] *= scale;
    }

    return h;
}