Module_SignalProcessing_Windowing - vorcyc/Vorcyc.Mathematics GitHub Wiki

Location: Home / Signal processing / Windowing

Signal Processing Module

Windowing

The Vorcyc.Mathematics.SignalProcessing.Windowing namespace contains window computation and application classes: WindowApplier, WindowBuilder, and WindowBuilderExtensions. WindowApplier provides rectangular, triangular, Hamming, Blackman, Hann, Gaussian, Kaiser, KBD, Bartlett-Hann, Lanczos, power-of-sine, flat-top, liftering, and Blackman-Harris windows. WindowBuilder generates window coefficient arrays. WindowBuilderExtensions applies windows to signals and sample arrays.

WindowType enum (in this namespace) lists the available window kinds used by WindowBuilder.OfType and the ApplyWindow overloads: Rectangular, Triangular, Hamming, HammingPeriodic, Blackman, BlackmanPeriodic, Hann, HannPeriodic, Gaussian, Kaiser, Kbd, BartlettHann, Lanczos, PowerOfSine, Flattop, Liftering, BlackmanHarris.

All types below are in namespace: Vorcyc.Mathematics.SignalProcessing.Windowing

📒 Contents

All types below are in Vorcyc.Mathematics.SignalProcessing.Windowing namespace。

Vorcyc.Mathematics.SignalProcessing.Windowing.WindowApplier class

Vorcyc.Mathematics.SignalProcessing.Windowing.WindowApplier provides multiple window computation methods.

Methods

1. Rectangular

  • public static void Rectangular(Span<ComplexFp32> values)
    • Computes rectangular window.
    • Parameters:
      • values: Input data.

2. Triangular

  • public static void Triangular(Span<ComplexFp32> values)
    • Computes triangular window.
    • Parameters:
      • values: Input data.

3. Hamming

  • public static void Hamming(Span<ComplexFp32> values)
    • Computes Hamming window.
    • Parameters:
      • values: Input data.

4. Blackman

  • public static void Blackman(Span<ComplexFp32> values)
    • Computes Blackman window.
    • Parameters:
      • values: Input data.

5. Hann

  • public static void Hann(Span<ComplexFp32> values)
    • Computes Hann window.
    • Parameters:
      • values: Input data.

6. Gaussian

  • public static void Gaussian(Span<ComplexFp32> values)
    • Computes Gaussian window.
    • Parameters:
      • values: Input data.

7. Kaiser

  • public static void Kaiser(Span<ComplexFp32> values, float alpha = 12f)
    • Computes Kaiser window.
    • Parameters:
      • values: Input data.
      • alpha: Alpha parameter.

8. Kbd

  • public static void Kbd(Span<ComplexFp32> values, float alpha = 4f)
    • Computes Kaiser-Bessel derived (KBD) window.
    • Parameters:
      • values: Input data.
      • alpha: Alpha parameter.

9. Bartlett_Hann

  • public static void Bartlett_Hann(Span<ComplexFp32> values)
    • Computes Bartlett-Hann window.
    • Parameters:
      • values: Input data.

10. Lanczos

  • public static void Lanczos(Span<ComplexFp32> values)
    • Computes Lanczos window.
    • Parameters:
      • values: Input data.

11. PowerOfSine

  • public static void PowerOfSine(Span<ComplexFp32> values, float alpha = 1.5f)
    • Computes power-of-sine window.
    • Parameters:
      • values: Input data.
      • alpha: Alpha parameter.

12. Flattop

  • public static void Flattop(Span<ComplexFp32> values)
    • Computes flat-top window.
    • Parameters:
      • values: Input data.

13. Liftering

  • public static void Liftering(Span<ComplexFp32> values, int l = 22)
    • Computes liftering window.
    • Parameters:
      • values: Input data.
      • l: L parameter.

14. Blackman_Harris

  • public static void Blackman_Harris(Span<ComplexFp32> values)
    • Computes Blackman-Harris window.
    • Parameters:
      • values: Input data.

15. Apply

  • public static void Apply(Span<ComplexFp32> values, WindowType windowType)
    • Applies the specified window.
    • Parameters:
      • values: Input data.
      • windowType: Window type。

Code example

The following example uses WindowApplier with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Windowing;
using Vorcyc.Mathematics.Numerics;

public class WindowApplierExample
{
    public static void Main()
    {
        // Define input data
        var values = new ComplexFp32[] { new ComplexFp32(1.0f, 0.0f), new ComplexFp32(2.0f, 0.0f), new ComplexFp32(3.0f, 0.0f), new ComplexFp32(4.0f, 0.0f), new ComplexFp32(5.0f, 0.0f), new ComplexFp32(6.0f, 0.0f), new ComplexFp32(7.0f, 0.0f), new ComplexFp32(8.0f, 0.0f) };

        // Apply triangular window
        WindowApplier.Triangular(values);
        Console.WriteLine("Triangular Window:");

        foreach (var value in values)
        {
            Console.WriteLine(value);
        }

        // Apply Hamming window
        WindowApplier.Hamming(values);
        Console.WriteLine("Hamming Window:");

        foreach (var value in values)
        {
            Console.WriteLine(value);
        }

        // Apply Blackman window
        WindowApplier.Blackman(values);
        Console.WriteLine("Blackman Window:");

        foreach (var value in values)
        {
            Console.WriteLine(value);
        }

        // Apply Hann window
        WindowApplier.Hann(values);
        Console.WriteLine("Hann Window:");

        foreach (var value in values)
        {
            Console.WriteLine(value);
        }

        // Apply Gaussian window
        WindowApplier.Gaussian(values);
        Console.WriteLine("Gaussian Window:");

        foreach (var value in values)
        {
            Console.WriteLine(value);
        }

        // Apply Kaiser window
        WindowApplier.Kaiser(values);
        Console.WriteLine("Kaiser Window:");

        foreach (var value in values)
        {
            Console.WriteLine(value);
        }

        // Apply KBD window
        WindowApplier.Kbd(values);
        Console.WriteLine("Kbd Window:");

        foreach (var value in values)
        {
            Console.WriteLine(value);
        }

        // Apply Bartlett-Hann window
        WindowApplier.Bartlett_Hann(values);
        Console.WriteLine("Bartlett-Hann Window:");

        foreach (var value in values)
        {
            Console.WriteLine(value);
        }

        // Apply Lanczos window
        WindowApplier.Lanczos(values);
        Console.WriteLine("Lanczos Window:");

        foreach (var value in values)
        {
            Console.WriteLine(value);
        }

        // Apply power-of-sine window
        WindowApplier.PowerOfSine(values);
        Console.WriteLine("PowerOfSine Window:");

        foreach (var value in values)
        {
            Console.WriteLine(value);
        }

        // Apply flat-top window
        WindowApplier.Flattop(values);
        Console.WriteLine("Flattop Window:");

        foreach (var value in values)
        {
            Console.WriteLine(value);
        }

        // Apply liftering window
        WindowApplier.Liftering(values);
        Console.WriteLine("Liftering Window:");

        foreach (var value in values)
        {
            Console.WriteLine(value);
        }

        // Apply Blackman-Harris window
        WindowApplier.Blackman_Harris(values);
        Console.WriteLine("Blackman-Harris Window:");

        foreach (var value in values)
        {
            Console.WriteLine(value);
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Windowing.WindowBuilder class

Vorcyc.Mathematics.SignalProcessing.Windowing.WindowBuilder provides methods to generate window coefficients of various types.

Methods

1. OfType

  • public static float[] OfType(WindowType type, int length, params object[] parameters)
    • Generates window coefficients of the given type and length.
    • Parameters:
      • type: Window type。
      • length: Window length。
      • parameters: Additional optional parameters.
    • Returns: Window coefficient array。

2. Rectangular

  • public static float[] Rectangular(int length)
    • Generates rectangular window.
    • Parameters:
      • length: Window length。
    • Returns: Window coefficient array。

3. Triangular

  • public static float[] Triangular(int length)
    • Generates triangular window.
    • Parameters:
      • length: Window length。
    • Returns: Window coefficient array。

4. Hamming

  • public static float[] Hamming(int length)
    • Generates Hamming window.
    • Parameters:
      • length: Window length。
    • Returns: Window coefficient array。

5. Blackman

  • public static float[] Blackman(int length)
    • Generates Blackman window.
    • Parameters:
      • length: Window length。
    • Returns: Window coefficient array。

6. Hann

  • public static float[] Hann(int length)
    • Generates Hann window.
    • Parameters:
      • length: Window length。
    • Returns: Window coefficient array。

7. Gaussian

  • public static float[] Gaussian(int length)
    • Generates Gaussian window. The window is symmetric for every length (including even lengths); a length of 1 returns [1].
    • Parameters:
      • length: Window length。
    • Returns: Window coefficient array。

8. Kaiser

  • public static float[] Kaiser(int length, double alpha = 12.0)
    • Generates Kaiser window of given length and alpha.
    • Parameters:
      • length: Window length。
      • alpha: Alpha parameter.
    • Returns: Window coefficient array。

9. Kbd

  • public static float[] Kbd(int length, double alpha = 4.0)
    • Generates KBD window of given length and alpha.
    • Parameters:
      • length: Window length。
      • alpha: Alpha parameter.
    • Returns: Window coefficient array。

10. BartlettHann

  • public static float[] BartlettHann(int length)
    • Generates Bartlett-Hann window.
    • Parameters:
      • length: Window length。
    • Returns: Window coefficient array。

11. Lanczos

  • public static float[] Lanczos(int length)
    • Generates Lanczos window.
    • Parameters:
      • length: Window length。
    • Returns: Window coefficient array。

12. PowerOfSine

  • public static float[] PowerOfSine(int length, double alpha = 1.5)
    • Generates power-of-sine window of given length and alpha.
    • Parameters:
      • length: Window length。
      • alpha: Alpha parameter.
    • Returns: Window coefficient array。

13. Flattop

  • public static float[] Flattop(int length)
    • Generates flat-top window.
    • Parameters:
      • length: Window length。
    • Returns: Window coefficient array。

14. Liftering

  • public static float[] Liftering(int length, int l = 22)
    • Generates liftering window of given length and l parameter.
    • Parameters:
      • length: Window length。
      • l: L parameter.
    • Returns: Window coefficient array。

15. Blackman_Harris

  • public static float[] Blackman_Harris(int length)
    • Generates Blackman-Harris window.
    • Parameters:
      • length: Window length。
    • Returns: Window coefficient array。

Code example

The following example uses WindowBuilder with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Windowing;

public class WindowBuilderExample
{
    public static void Main()
    {
        // Define window length
        int length = 8;

        // Generate triangular window coefficients
        var triangular = WindowBuilder.Triangular(length);
        Console.WriteLine("Triangular Window:");

        foreach (var value in triangular)
        {
            Console.WriteLine(value);
        }

        // Generate Hamming window coefficients
        var hamming = WindowBuilder.Hamming(length);
        Console.WriteLine("Hamming Window:");

        foreach (var value in hamming)
        {
            Console.WriteLine(value);
        }

        // Generate Blackman window coefficients
        var blackman = WindowBuilder.Blackman(length);
        Console.WriteLine("Blackman Window:");

        foreach (var value in blackman)
        {
            Console.WriteLine(value);
        }

        // Generate Hann window coefficients
        var hann = WindowBuilder.Hann(length);
        Console.WriteLine("Hann Window:");

        foreach (var value in hann)
        {
            Console.WriteLine(value);
        }

        // Generate Gaussian window coefficients
        var gaussian = WindowBuilder.Gaussian(length);
        Console.WriteLine("Gaussian Window:");

        foreach (var value in gaussian)
        {
            Console.WriteLine(value);
        }

        // Generate Kaiser window coefficients
        var kaiser = WindowBuilder.Kaiser(length);
        Console.WriteLine("Kaiser Window:");

        foreach (var value in kaiser)
        {
            Console.WriteLine(value);
        }

        // Generate KBD window coefficients
        var kbd = WindowBuilder.Kbd(length);
        Console.WriteLine("Kbd Window:");

        foreach (var value in kbd)
        {
            Console.WriteLine(value);
        }

        // Generate Bartlett-Hann window coefficients
        var bartlettHann = WindowBuilder.BartlettHann(length);
        Console.WriteLine("Bartlett-Hann Window:");

        foreach (var value in bartlettHann)
        {
            Console.WriteLine(value);
        }

        // Generate Lanczos window coefficients
        var lanczos = WindowBuilder.Lanczos(length);
        Console.WriteLine("Lanczos Window:");

        foreach (var value in lanczos)
        {
            Console.WriteLine(value);
        }

        // Generate power-of-sine window coefficients
        var powerOfSine = WindowBuilder.PowerOfSine(length);
        Console.WriteLine("PowerOfSine Window:");

        foreach (var value in powerOfSine)
        {
            Console.WriteLine(value);
        }

        // Generate flat-top window coefficients
        var flattop = WindowBuilder.Flattop(length);
        Console.WriteLine("Flattop Window:");

        foreach (var value in flattop)
        {
            Console.WriteLine(value);
        }

        // Generate liftering window coefficients
        var liftering = WindowBuilder.Liftering(length);
        Console.WriteLine("Liftering Window:");

        foreach (var value in liftering)
        {
            Console.WriteLine(value);
        }

        // Generate Blackman-Harris window coefficients
        var blackmanHarris = WindowBuilder.Blackman_Harris(length);
        Console.WriteLine("Blackman-Harris Window:");

        foreach (var value in blackmanHarris)
        {
            Console.WriteLine(value);
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Windowing.WindowBuilderExtensions class

Vorcyc.Mathematics.SignalProcessing.Windowing.WindowBuilderExtensions provides extension methods to apply windows to signals and sample arrays.

Methods

1. ApplyWindow (float[])

  • public static void ApplyWindow(this float[] samples, float[] windowSamples)
    • Applies window to sample array.
    • Parameters:
      • samples: Sample array.
      • windowSamples: Window coefficients.

2. ApplyWindow (double[])

  • public static void ApplyWindow(this double[] samples, double[] windowSamples)
    • Applies window to sample array.
    • Parameters:
      • samples: Sample array.
      • windowSamples: Window coefficients.

3. ApplyWindow (Signal)

  • public static void ApplyWindow(this Signal signal, float[] windowSamples)
    • Applies window to signal.
    • Parameters:
      • signal: Signal.
      • windowSamples: Window coefficients.

4. ApplyWindow (float[], WindowType)

  • public static void ApplyWindow(this float[] samples, WindowType window, params object[] parameters)
    • Applies window of specified type to sample array.
    • Parameters:
      • samples: Sample array.
      • window: Window type。
      • parameters: Window parameters.

5. ApplyWindow (double[], WindowType)

  • public static void ApplyWindow(this double[] samples, WindowType window, params object[] parameters)
    • Applies window of specified type to sample array.
    • Parameters:
      • samples: Sample array.
      • window: Window type。
      • parameters: Window parameters.

6. ApplyWindow (Signal, WindowType)

  • public static void ApplyWindow(this Signal signal, WindowType window, params object[] parameters)
    • Applies window of specified type to signal.
    • Parameters:
      • signal: Signal.
      • window: WindowType。
      • parameters: Window parameters.

7. ApplyWindow (Span)

  • public static void ApplyWindow(this Span<float> samples, float[] windowSamples)
    • Applies window in-place to a span of samples.
    • Parameters:
      • samples: Sample span.
      • windowSamples: Window coefficients.

Code example

The following example uses WindowBuilderExtensions with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Windowing;
using Vorcyc.Mathematics.SignalProcessing.Signals;
public class WindowBuilderExtensionsExample
{
    public static void Main()
    {
        // Define sample array
        var samples = new float[] { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f };

        // Define window coefficients
        var windowSamples = WindowBuilder.Hamming(samples.Length);

        // Apply window to sample array
        samples.ApplyWindow(windowSamples);
        Console.WriteLine("Samples after applying Hamming window:");

        foreach (var sample in samples)
        {
            Console.WriteLine(sample);
        }

        // Apply window of specified type to sample array
        samples.ApplyWindow(WindowType.Blackman);
        Console.WriteLine("Samples after applying Blackman window:");

        foreach (var sample in samples)
        {
            Console.WriteLine(sample);
        }

        // Define signal
        var signal = Signal.FromCopy(samples, 8000f);

        // Apply window to signal
        signal.ApplyWindow(windowSamples);
        Console.WriteLine("Signal after applying Hamming window:");

        foreach (var sample in signal.Samples)
        {
            Console.WriteLine(sample);
        }

        // Apply window of specified type to signal
        signal.ApplyWindow(WindowType.Blackman);
        Console.WriteLine("Signal after applying Blackman window:");

        foreach (var sample in signal.Samples)
        {
            Console.WriteLine(sample);
        }
    }
}
⚠️ **GitHub.com Fallback** ⚠️