/// <summary>
/// Constructs Hilbert transformer. Transform <paramref name="size"/> must be a power of 2.
/// </summary>
public HilbertTransform(int size = 512)
{
Size = size;
_fft = new Fft(size);
_re = new float[size];
_im = new float[size];
}
public FastDct4(int dctSize)
{
var halfSize = dctSize / 2;
_fft = new Fft(halfSize);
_temp = new float[halfSize];
_tempRe = new float[halfSize];
_tempIm = new float[halfSize];
}
/// <summary>
/// Constructor with necessary parameters
/// </summary>
/// <param name="cepstrumSize"></param>
/// <param name="fftSize"></param>
public CepstralTransform(int cepstrumSize, int fftSize = 512)
{
_fft = new Fft(fftSize);
Size = cepstrumSize;
_realSpectrum = new float[fftSize];
_imagSpectrum = new float[fftSize];
}
/// <summary>
/// Constructor with necessary parameters
/// </summary>
/// <param name="windowSize">Size of window</param>
/// <param name="hopSize">Hop (overlap) size</param>
/// <param name="window">Type of the window function to apply</param>
/// <param name="fftSize">Size of FFT</param>
public Stft(int windowSize = 1024, int hopSize = 256, WindowTypes window = WindowTypes.Hann, int fftSize = 0)
{
_fftSize = fftSize >= windowSize ? fftSize : MathUtils.NextPowerOfTwo(windowSize);
_fft = new Fft(_fftSize);
_hopSize = hopSize;
_windowSize = windowSize;
_window = window;
_windowSamples = Window.OfType(_window, _windowSize);
_gain = 1 / (_fftSize * _windowSamples.Select(w => w * w).Sum() / _hopSize);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="length">Size of Hilbert Transform</param>
/// <param name="doublePrecision"></param>
public HilbertTransform(int size = 1024, bool doublePrecision = true)
{
Size = size;
if (doublePrecision)
{
_fft64 = new Fft64(size);
}
else
{
_fft32 = new Fft(size);
}
}
/// <summary>
/// Constructor with necessary parameters
/// </summary>
/// <param name="windowSize">Size of window</param>
/// <param name="hopSize">Hop (overlap) size</param>
/// <param name="window">Type of the window function to apply</param>
/// <param name="fftSize">Size of FFT</param>
public Stft(int windowSize = 1024, int hopSize = 256, WindowTypes window = WindowTypes.Hann, int fftSize = 0)
{
_fftSize = fftSize >= windowSize ? fftSize : MathUtils.NextPowerOfTwo(windowSize);
_fft = new Fft(_fftSize);
_hopSize = hopSize;
_windowSize = windowSize;
_window = window;
_windowSamples = Window.OfType(_window, _windowSize);
_windowSquared = _windowSamples.Select(w => w * w).ToArray();
// TODO: pad center!
}
/// <summary>
/// Constructs cepstral transformer.
/// If <paramref name="cepstrumSize"/> exceeds <paramref name="fftSize"/>,
/// FFT size will be recalculated as the nearest power of 2 to cepstrum size.
/// </summary>
/// <param name="cepstrumSize">Cepstrum size</param>
/// <param name="fftSize">FFT size</param>
/// <param name="logBase">Logarithm base</param>
public CepstralTransform(int cepstrumSize, int fftSize = 0, double logBase = Math.E)
{
Size = cepstrumSize;
if (cepstrumSize > fftSize)
{
fftSize = MathUtils.NextPowerOfTwo(cepstrumSize);
}
_fft = new Fft(fftSize);
_logBase = logBase;
_re = new float[fftSize];
_im = new float[fftSize];
_unwrapped = new double[fftSize];
}
/// <summary>
/// Constructor with necessary parameters
/// </summary>
/// <param name="windowSize">Size of window</param>
/// <param name="hopSize">Hop (overlap) size</param>
/// <param name="window">Type of the window function to apply</param>
/// <param name="fftSize">Size of FFT</param>
public Stft(int windowSize = 1024, int hopSize = 256, WindowTypes window = WindowTypes.Hann, int fftSize = 0)
{
_fftSize = fftSize >= windowSize ? fftSize : MathUtils.NextPowerOfTwo(windowSize);
_fft = new Fft(_fftSize);
_hopSize = hopSize;
_windowSize = windowSize;
_window = window;
_windowSamples = Window.OfType(_window, _windowSize);
// TODO: pad center!
_norm = 2.0f / (_windowSamples.Sum(s => s * s) * _fftSize / _hopSize);
//_norm = 2.0 * Math.Sqrt((float)_fftSize / _hopSize));
//_norm = 2.0 / (_fftSize / 2 * (_fftSize / _hopSize));
}
public MellinTransform(int inputSize, int outputSize)
{
Guard.AgainstNotPowerOfTwo(outputSize, "Output size");
InputSize = inputSize;
OutputSize = outputSize;
_fft = new Fft(outputSize);
_linScale = Enumerable.Range(0, inputSize)
.Select(i => (float)i / inputSize)
.ToArray();
_expScale = new float[outputSize];
var cur = -(float)Math.Log(outputSize);
var step = -cur / outputSize;
for (var i = 0; i < _expScale.Length; i++, cur += step)
{
_expScale[i] = (float)Math.Exp(cur);
}
}
public FastDct2(int dctSize)
{
_fft = new Fft(dctSize);
_temp = new float[dctSize];
}
/// <summary>
/// Constructs Hartley transformer. Transform <paramref name="size"/> must be a power of 2.
/// </summary>
/// <param name="size">Size of Hartley transform</param>
public HartleyTransform(int size)
{
Size = size;
_fft = new Fft(size);
_im = new float[size];
}
