// <copyright file="Window.cs" company="Math.NET">
|
// Math.NET Numerics, part of the Math.NET Project
|
// http://numerics.mathdotnet.com
|
// http://github.com/mathnet/mathnet-numerics
|
//
|
// Copyright (c) 2009-2013 Math.NET
|
//
|
// Permission is hereby granted, free of charge, to any person
|
// obtaining a copy of this software and associated documentation
|
// files (the "Software"), to deal in the Software without
|
// restriction, including without limitation the rights to use,
|
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
// copies of the Software, and to permit persons to whom the
|
// Software is furnished to do so, subject to the following
|
// conditions:
|
//
|
// The above copyright notice and this permission notice shall be
|
// included in all copies or substantial portions of the Software.
|
//
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
// OTHER DEALINGS IN THE SOFTWARE.
|
// </copyright>
|
|
using System;
|
|
namespace IStation.Numerics
|
{
|
public static class Window
|
{
|
/// <summary>
|
/// Hamming window. Named after Richard Hamming.
|
/// Symmetric version, useful e.g. for filter design purposes.
|
/// </summary>
|
public static double[] Hamming(int width)
|
{
|
const double a = 0.53836;
|
const double b = -0.46164;
|
|
double phaseStep = (2.0*Math.PI)/(width - 1.0);
|
|
var w = new double[width];
|
for (int i = 0; i < w.Length; i++)
|
{
|
w[i] = a + b*Math.Cos(i*phaseStep);
|
}
|
return w;
|
}
|
|
/// <summary>
|
/// Hamming window. Named after Richard Hamming.
|
/// Periodic version, useful e.g. for FFT purposes.
|
/// </summary>
|
public static double[] HammingPeriodic(int width)
|
{
|
const double a = 0.53836;
|
const double b = -0.46164;
|
|
double phaseStep = (2.0*Math.PI)/width;
|
|
var w = new double[width];
|
for (int i = 0; i < w.Length; i++)
|
{
|
w[i] = a + b*Math.Cos(i*phaseStep);
|
}
|
return w;
|
}
|
|
/// <summary>
|
/// Hann window. Named after Julius von Hann.
|
/// Symmetric version, useful e.g. for filter design purposes.
|
/// </summary>
|
public static double[] Hann(int width)
|
{
|
double phaseStep = (2.0*Math.PI)/(width - 1.0);
|
|
var w = new double[width];
|
for (int i = 0; i < w.Length; i++)
|
{
|
w[i] = 0.5 - 0.5*Math.Cos(i*phaseStep);
|
}
|
return w;
|
}
|
|
/// <summary>
|
/// Hann window. Named after Julius von Hann.
|
/// Periodic version, useful e.g. for FFT purposes.
|
/// </summary>
|
public static double[] HannPeriodic(int width)
|
{
|
double phaseStep = (2.0*Math.PI)/width;
|
|
var w = new double[width];
|
for (int i = 0; i < w.Length; i++)
|
{
|
w[i] = 0.5 - 0.5*Math.Cos(i*phaseStep);
|
}
|
return w;
|
}
|
|
/// <summary>
|
/// Cosine window.
|
/// Symmetric version, useful e.g. for filter design purposes.
|
/// </summary>
|
public static double[] Cosine(int width)
|
{
|
double phaseStep = Math.PI/(width - 1.0);
|
|
var w = new double[width];
|
for (int i = 0; i < w.Length; i++)
|
{
|
w[i] = Math.Sin(i*phaseStep);
|
}
|
return w;
|
}
|
|
/// <summary>
|
/// Cosine window.
|
/// Periodic version, useful e.g. for FFT purposes.
|
/// </summary>
|
public static double[] CosinePeriodic(int width)
|
{
|
double phaseStep = Math.PI/width;
|
|
var w = new double[width];
|
for (int i = 0; i < w.Length; i++)
|
{
|
w[i] = Math.Sin(i*phaseStep);
|
}
|
return w;
|
}
|
|
/// <summary>
|
/// Lanczos window.
|
/// Symmetric version, useful e.g. for filter design purposes.
|
/// </summary>
|
public static double[] Lanczos(int width)
|
{
|
double phaseStep = 2.0/(width - 1.0);
|
|
var w = new double[width];
|
for (int i = 0; i < w.Length; i++)
|
{
|
w[i] = Trig.Sinc(i*phaseStep - 1.0);
|
}
|
return w;
|
}
|
|
/// <summary>
|
/// Lanczos window.
|
/// Periodic version, useful e.g. for FFT purposes.
|
/// </summary>
|
public static double[] LanczosPeriodic(int width)
|
{
|
double phaseStep = 2.0/width;
|
|
var w = new double[width];
|
for (int i = 0; i < w.Length; i++)
|
{
|
w[i] = Trig.Sinc(i*phaseStep - 1.0);
|
}
|
return w;
|
}
|
|
/// <summary>
|
/// Gauss window.
|
/// </summary>
|
public static double[] Gauss(int width, double sigma)
|
{
|
double a = (width - 1)/2.0;
|
|
var w = new double[width];
|
for (int i = 0; i < w.Length; i++)
|
{
|
double exponent = (i - a)/(sigma*a);
|
w[i] = Math.Exp(-0.5*exponent*exponent);
|
}
|
return w;
|
}
|
|
/// <summary>
|
/// Blackman window.
|
/// </summary>
|
public static double[] Blackman(int width)
|
{
|
const double alpha = 0.16;
|
const double a = 0.5 - 0.5*alpha;
|
const double b = 0.5*alpha;
|
|
int last = width - 1;
|
double c = 2.0*Math.PI/last;
|
double d = 2.0*c;
|
|
var w = new double[width];
|
for (int i = 0; i < w.Length; i++)
|
{
|
w[i] = a
|
- 0.5*Math.Cos(i*c)
|
+ b*Math.Cos(i*d);
|
}
|
return w;
|
}
|
|
/// <summary>
|
/// Blackman-Harris window.
|
/// </summary>
|
public static double[] BlackmanHarris(int width)
|
{
|
const double a = 0.35875;
|
const double b = -0.48829;
|
const double c = 0.14128;
|
const double d = -0.01168;
|
|
int last = width - 1;
|
double e = 2.0*Math.PI/last;
|
double f = 2.0*e;
|
double g = 3.0*e;
|
|
var w = new double[width];
|
for (int i = 0; i < w.Length; i++)
|
{
|
w[i] = a
|
+ b*Math.Cos(e*i)
|
+ c*Math.Cos(f*i)
|
+ d*Math.Cos(g*i);
|
}
|
return w;
|
}
|
|
/// <summary>
|
/// Blackman-Nuttall window.
|
/// </summary>
|
public static double[] BlackmanNuttall(int width)
|
{
|
const double a = 0.3635819;
|
const double b = -0.4891775;
|
const double c = 0.1365995;
|
const double d = -0.0106411;
|
|
int last = width - 1;
|
double e = 2.0*Math.PI/last;
|
double f = 2.0*e;
|
double g = 3.0*e;
|
|
var w = new double[width];
|
for (int i = 0; i < w.Length; i++)
|
{
|
w[i] = a
|
+ b*Math.Cos(e*i)
|
+ c*Math.Cos(f*i)
|
+ d*Math.Cos(g*i);
|
}
|
return w;
|
}
|
|
/// <summary>
|
/// Bartlett window.
|
/// </summary>
|
public static double[] Bartlett(int width)
|
{
|
int last = width - 1;
|
double a = 2.0/last;
|
double b = last/2.0;
|
|
var w = new double[width];
|
for (int i = 0; i < w.Length; i++)
|
{
|
w[i] = a*(b - Math.Abs(i - b));
|
}
|
return w;
|
}
|
|
/// <summary>
|
/// Bartlett-Hann window.
|
/// </summary>
|
public static double[] BartlettHann(int width)
|
{
|
const double a = 0.62;
|
const double b = -0.48;
|
const double c = -0.38;
|
|
int last = width - 1;
|
double d = 1.0/last;
|
double e = 2.0*Math.PI/last;
|
|
var w = new double[width];
|
for (int i = 0; i < w.Length; i++)
|
{
|
w[i] = a
|
+ b*Math.Abs(i*d - 0.5)
|
+ c*Math.Cos(i*e);
|
}
|
return w;
|
}
|
|
/// <summary>
|
/// Nuttall window.
|
/// </summary>
|
public static double[] Nuttall(int width)
|
{
|
const double a = 0.355768;
|
const double b = -0.487396;
|
const double c = 0.144232;
|
const double d = -0.012604;
|
|
int last = width - 1;
|
double e = 2.0*Math.PI/last;
|
double f = 2.0*e;
|
double g = 3.0*e;
|
|
var w = new double[width];
|
for (int i = 0; i < w.Length; i++)
|
{
|
w[i] = a
|
+ b*Math.Cos(e*i)
|
+ c*Math.Cos(f*i)
|
+ d*Math.Cos(g*i);
|
}
|
return w;
|
}
|
|
/// <summary>
|
/// Flat top window.
|
/// </summary>
|
public static double[] FlatTop(int width)
|
{
|
const double a = 1.0;
|
const double b = -1.93;
|
const double c = 1.29;
|
const double d = -0.388;
|
const double e = 0.032;
|
|
int last = width - 1;
|
double f = 2.0*Math.PI/last;
|
double g = 2.0*f;
|
double h = 3.0*f;
|
double k = 4.0*f;
|
|
double[] w = new double[width];
|
for (int i = 0; i < w.Length; i++)
|
{
|
w[i] = a
|
+ b*Math.Cos(f*i)
|
+ c*Math.Cos(g*i)
|
+ d*Math.Cos(h*i)
|
+ e*Math.Cos(k*i);
|
}
|
return w;
|
}
|
|
/// <summary>
|
/// Uniform rectangular (Dirichlet) window.
|
/// </summary>
|
public static double[] Dirichlet(int width)
|
{
|
var w = new double[width];
|
for (int i = 0; i < w.Length; i++)
|
{
|
w[i] = 1.0;
|
}
|
return w;
|
}
|
|
/// <summary>
|
/// Triangular window.
|
/// </summary>
|
public static double[] Triangular(int width)
|
{
|
double a = 2.0/width;
|
double b = width/2.0;
|
double c = (width - 1)/2.0;
|
|
var w = new double[width];
|
for (int i = 0; i < w.Length; i++)
|
{
|
w[i] = a*(b - Math.Abs(i - c));
|
}
|
return w;
|
}
|
|
/// <summary>
|
/// Tukey tapering window. A rectangular window bounded
|
/// by half a cosine window on each side.
|
/// </summary>
|
/// <param name="width">Width of the window</param>
|
/// <param name="r">Fraction of the window occupied by the cosine parts</param>
|
public static double[] Tukey(int width, double r = 0.5)
|
{
|
|
if (r <= 0)
|
{
|
return Generate.Repeat(width, 1.0);
|
}
|
else if (r >= 1)
|
{
|
return Hann(width);
|
}
|
|
var w = new double[width];
|
var period = (width - 1) * r;
|
var step = 2* Math.PI / period;
|
var b1 = (int)Math.Floor((width - 1) * r * 0.5 + 1);
|
var b2 = width - b1;
|
for (var i = 0; i < b1; i++)
|
{
|
w[i] = (1 - Math.Cos(i * step)) * 0.5;
|
}
|
for (var i = b1; i < b2; i++)
|
{
|
w[i] = 1;
|
}
|
for (var i = b2; i < width; i++)
|
{
|
w[i] = w[width-i-1];
|
}
|
return w;
|
}
|
}
|
}
|
