public static void Initialize_FFTW()
{
int proc = System.Environment.ProcessorCount;
FFT_ArrayIn8192 = new fftw_complexarray[proc];
FFT_ArrayOut8192 = new fftw_complexarray[proc];
FFT_Plan8192 = new fftw_plan[proc];
IFFT_ArrayIn8192 = new fftw_complexarray[proc];
IFFT_ArrayOut8192 = new fftw_complexarray[proc];
IFFT_Plan8192 = new fftw_plan[proc];
FFT_ArrayIn = new fftw_complexarray[proc];
FFT_ArrayOut = new fftw_complexarray[proc];
FFT_Plan = new fftw_plan[proc];
IFFT_ArrayIn = new fftw_complexarray[proc];
IFFT_ArrayOut = new fftw_complexarray[proc];
IFFT_Plan = new fftw_plan[proc];
for (int i = 0; i < proc; i++)
{
FFT_ArrayIn8192[i] = new fftw_complexarray(8192);
FFT_ArrayOut8192[i] = new fftw_complexarray(8192);
FFT_Plan8192[i] = fftw_plan.dft_1d(8192, FFT_ArrayIn8192[i], FFT_ArrayOut8192[i], fftw_direction.Forward, fftw_flags.Exhaustive);
IFFT_ArrayIn8192[i] = new fftw_complexarray(8192);
IFFT_ArrayOut8192[i] = new fftw_complexarray(8192);
IFFT_Plan8192[i] = fftw_plan.dft_1d(8192, IFFT_ArrayIn8192[i], IFFT_ArrayOut8192[i], fftw_direction.Forward, fftw_flags.Exhaustive);
}
Initialize_filter_functions();
}
public void Add(WaveStream waveStream)
{
var newFormat = new WaveFormat(_frequency, 16, 1);
using (var waveFormatConversionStream = new WaveFormatConversionStream(newFormat, waveStream))
{
var reader = new BinaryReader(waveFormatConversionStream);
try
{
for (;;)
{
var list = new List <Int16>();
for (int i = 0; i < _length; i++)
{
list.Add(reader.ReadInt16());
}
int count = list.Count;
double[] array = list.Select(x => (double)x).ToArray();
var input = new fftw_complexarray(array.Select(x => new Complex(x, 0)).ToArray());
var output = new fftw_complexarray(count);
fftw_plan.dft_1d(count, input, output, fftw_direction.Forward, fftw_flags.Estimate).Execute();
var data = output.GetData_Complex();
for (int i = 0; i < _length; i++)
{
_data[i] = Math.Max(_data[i], data[i].Magnitude);
}
}
}
catch
{
}
}
}
/// <summary>
/// Calculate function self-convolution values
/// </summary>
/// <param name="f">Function values</param>
/// <returns></returns>
public double[] Build(double[] f)
{
int length = (_functionType == FunctionType.Periodic) ? f.Length : (f.Length + f.Length - 1);
var input = new fftw_complexarray(length);
var output = new fftw_complexarray(length);
fftw_plan forward = fftw_plan.dft_1d(length, input, output,
fftw_direction.Forward,
fftw_flags.Estimate);
fftw_plan backward = fftw_plan.dft_1d(length, input, output,
fftw_direction.Backward,
fftw_flags.Estimate);
var complex = new Complex[length];
for (int i = 0; i < f.Length; i++)
{
complex[i] = f[i];
}
input.SetData(complex);
forward.Execute();
complex = output.GetData_Complex();
input.SetData(complex.Select(x => x * x / length).ToArray());
backward.Execute();
complex = output.GetData_Complex();
return(complex.Select(x => x.Magnitude).ToArray());
}
public static void Initialize_FFTW()
{
int proc = System.Environment.ProcessorCount;
FFT_ArrayIn4096 = new fftw_complexarray[proc];
FFT_ArrayOut4096 = new fftw_complexarray[proc];
FFT_Plan4096 = new fftw_plan[proc];
IFFT_ArrayIn4096 = new fftw_complexarray[proc];
IFFT_ArrayOut4096 = new fftw_complexarray[proc];
IFFT_Plan4096 = new fftw_plan[proc];
FFT_ArrayIn = new fftw_complexarray[proc];
FFT_ArrayOut = new fftw_complexarray[proc];
FFT_Plan = new fftw_plan[proc];
IFFT_ArrayIn = new fftw_complexarray[proc];
IFFT_ArrayOut = new fftw_complexarray[proc];
IFFT_Plan = new fftw_plan[proc];
for (int i = 0; i < proc; i++)
{
FFT_ArrayIn4096[i] = new fftw_complexarray(4096);
FFT_ArrayOut4096[i] = new fftw_complexarray(4096);
FFT_Plan4096[i] = fftw_plan.dft_1d(4096, FFT_ArrayIn4096[i], FFT_ArrayOut4096[i], fftw_direction.Forward, fftw_flags.Exhaustive);
IFFT_ArrayIn4096[i] = new fftw_complexarray(4096);
IFFT_ArrayOut4096[i] = new fftw_complexarray(4096);
IFFT_Plan4096[i] = fftw_plan.dft_1d(4096, IFFT_ArrayIn4096[i], IFFT_ArrayOut4096[i], fftw_direction.Forward, fftw_flags.Exhaustive);
}
Initialize_filter_functions();
}
private Complex FFTW(int index_Entry, int index_Value)
{
int SIZE = Convert.ToInt32(mCFGData.SamplingPoint / mCFGData.Hz);
double[] data = new double[SIZE];
Complex[] cdata = new Complex[SIZE];
for (int i = 0; i < SIZE; i++)
{
if ((index_Entry < SIZE / 2 && (i < SIZE / 2 - index_Entry)) || (i + index_Entry - (SIZE / 2 - 1)) > mCFGData.TotalPoint)
{
cdata[i] = new Complex(0, 0);
}
else
{
cdata[i] = new Complex(Convert.ToDouble(mDATData.arrData[i + index_Entry - SIZE / 2].value[index_Value]), 0);
}
}
fftw_complexarray input = new fftw_complexarray(SIZE);
fftw_complexarray ReData = new fftw_complexarray(SIZE);
input.SetData(cdata);
fftw_plan pf = fftw_plan.dft_1d(SIZE, input, ReData, fftw_direction.Forward, fftw_flags.Estimate);
pf.Execute();
var data_Complex = ReData.GetData_Complex();
return(data_Complex[1]);
}
// Initializes FFTW and all arrays
// n: Logical size of the transform
public FFTWtest(int n)
{
System.Console.WriteLine("Starting test with n = " + n + " complex numbers");
fftLength = n;
// create two unmanaged arrays, properly aligned
pin = fftwf.malloc(n * 8);
pout = fftwf.malloc(n * 8);
// create two managed arrays, possibly misalinged
// n*2 because we are dealing with complex numbers
fin = new float[n * 2];
fout = new float[n * 2];
// and two more for double FFTW
din = new double[n * 2];
dout = new double[n * 2];
// get handles and pin arrays so the GC doesn't move them
hin = GCHandle.Alloc(fin, GCHandleType.Pinned);
hout = GCHandle.Alloc(fout, GCHandleType.Pinned);
hdin = GCHandle.Alloc(din, GCHandleType.Pinned);
hdout = GCHandle.Alloc(dout, GCHandleType.Pinned);
// create a few test transforms
fplan1 = fftwf.dft_1d(n, pin, pout, fftw_direction.Forward, fftw_flags.Estimate);
fplan2 = fftwf.dft_1d(n, hin.AddrOfPinnedObject(), hout.AddrOfPinnedObject(),
fftw_direction.Forward, fftw_flags.Estimate);
fplan3 = fftwf.dft_1d(n, hout.AddrOfPinnedObject(), pin,
fftw_direction.Backward, fftw_flags.Measure);
// end with transforming back to original array
fplan4 = fftwf.dft_1d(n, hout.AddrOfPinnedObject(), hin.AddrOfPinnedObject(),
fftw_direction.Backward, fftw_flags.Estimate);
// and check a quick one with doubles, just to be sure
fplan5 = fftw.dft_1d(n, hdin.AddrOfPinnedObject(), hdout.AddrOfPinnedObject(),
fftw_direction.Backward, fftw_flags.Measure);
// create a managed plan as well
min = new fftw_complexarray(din);
mout = new fftw_complexarray(dout);
mplan = fftw_plan.dft_1d(n, min, mout, fftw_direction.Forward, fftw_flags.Estimate);
// fill our arrays with an arbitrary complex sawtooth-like signal
for (int i = 0; i < n * 2; i++)
{
fin[i] = i % 50;
}
for (int i = 0; i < n * 2; i++)
{
fout[i] = i % 50;
}
for (int i = 0; i < n * 2; i++)
{
din[i] = i % 50;
}
// copy managed arrays to unmanaged arrays
Marshal.Copy(fin, 0, pin, n * 2);
Marshal.Copy(fout, 0, pout, n * 2);
}
public SpectrumBuilder(int length, int frequency)
{
_length = length;
_frequency = frequency;
var fftw = new fftw_complexarray(_length);
fftw.SetZeroData();
_data = fftw.GetData_Real();
}
public static MathNet.Numerics.Complex[] FFT_General(Complex[] Signal, int threadid)
{
//FFTW.Net Setup//
FFT_ArrayIn[threadid] = new fftw_complexarray(Signal);
FFT_ArrayOut[threadid] = new fftw_complexarray(Signal.Length);
FFT_Plan[threadid] = fftw_plan.dft_1d(Signal.Length, FFT_ArrayIn[threadid], FFT_ArrayOut[threadid], fftw_direction.Forward, fftw_flags.Estimate);
FFT_Plan[threadid].Execute();
MathNet.Numerics.Complex[] Out = FFT_ArrayOut[threadid].GetData_Complex();
return(Out);
}
/// <summary>
/// Generate a spectrogram array spaced linearily
/// </summary>
/// <param name="samples">audio data</param>
/// <param name="fftWindowsSize">fft window size</param>
/// <param name="fftOverlap">overlap in number of samples (normaly half of the fft window size) [low number = high overlap]</param>
/// <returns>spectrogram jagged array</returns>
public static double[][] CreateSpectrogramFFTWLIB(float[] samples, int fftWindowsSize, int fftOverlap)
{
int numberOfSamples = samples.Length;
// overlap must be an integer smaller than the window size
// half the windows size is quite normal
double[] windowArray = FFTWindow.GetWindowFunction(FFTWindowType.HANNING, fftWindowsSize);
// width of the segment - e.g. split the file into 78 time slots (numberOfSegments) and do analysis on each slot
int numberOfSegments = (numberOfSamples - fftWindowsSize) / fftOverlap;
var frames = new double[numberOfSegments][];
// even - Re, odd - Img
var complexSignal = new double[2 * fftWindowsSize];
for (int i = 0; i < numberOfSegments; i++)
{
// apply Hanning Window
for (int j = 0; j < fftWindowsSize; j++)
{
// Weight by Hann Window
complexSignal[2 * j] = (double)(windowArray[j] * samples[i * fftOverlap + j]);
// need to clear out as fft modifies buffer (phase)
complexSignal[2 * j + 1] = 0;
}
// prepare the input arrays
var complexInput = new fftw_complexarray(complexSignal);
var complexOutput = new fftw_complexarray(complexSignal.Length / 2);
fftw_plan fft = fftw_plan.dft_1d(complexSignal.Length / 2, complexInput, complexOutput, fftw_direction.Forward, fftw_flags.Estimate);
// perform the FFT
fft.Execute();
// get the result
frames[i] = complexOutput.Abs;
// free up memory
complexInput = null;
complexOutput = null;
//GC.Collect();
}
return(frames);
}
public Complex[] GetData_Complex()
{
var length = (int)(_duration * _frequency);
using (var memoryStream = new MemoryStream())
{
var synthesizer = new SpeechSynthesizer();
synthesizer.SetOutputToWaveStream(memoryStream);
synthesizer.Speak(_phoneme);
memoryStream.Seek(0, SeekOrigin.Begin);
using (var waveFileReader = new WaveFileReader(memoryStream))
{
var newFormat = new WaveFormat(_frequency, 16, 1);
using (var waveFormatConversionStream = new WaveFormatConversionStream(newFormat, waveFileReader))
{
var reader = new BinaryReader(waveFormatConversionStream);
var list = new List <Int16>();
int i = 0;
try
{
for (; i < length; i++)
{
list.Add(reader.ReadInt16());
}
}
catch
{
for (; i < length; i++)
{
list.Add(0);
}
}
int count = list.Count;
double[] array = list.Select(x => (double)Math.Abs(x)).ToArray();
var input = new fftw_complexarray(array.Select(x => new Complex(x, 0)).ToArray());
var output = new fftw_complexarray(count);
fftw_plan.dft_1d(count, input, output, fftw_direction.Forward, fftw_flags.Estimate).Execute();
Complex[] data = output.GetData_Complex();
double s = Math.Sqrt(data.Select(x => x.Magnitude).Sum(x => x * x));
return(data.Select(x => x / s).ToArray());
}
}
}
}
public static MathNet.Numerics.Complex[] FFT_General(double[] Signal, int threadid)
{
double[] Sig_complex = new double[Signal.Length * 2];
for (int i = 0; i < Signal.Length; i++)
{
Sig_complex[i * 2] = Signal[i];
}
//FFTW.Net Setup//
FFT_ArrayIn[threadid] = new fftw_complexarray(Sig_complex);
FFT_ArrayOut[threadid] = new fftw_complexarray(Signal.Length);
FFT_Plan[threadid] = fftw_plan.dft_1d(Signal.Length, FFT_ArrayIn[threadid], FFT_ArrayOut[threadid], fftw_direction.Forward, fftw_flags.Estimate);
FFT_Plan[threadid].Execute();
MathNet.Numerics.Complex[] Out = FFT_ArrayOut[threadid].GetData_Complex();
return(Out);
}
public MaxLenSequenceBuilder(int nBits)
{
NumBits = nBits;
Feedback = 1 << (NumBits - 1);
Period = CalcPeriod(Feedback);
_testAray = new ulong[(Period >> 6) + 1]; //AllocMemory();
--Feedback;
FullPeriod = Period; //var N = Period * minDisc * nPer;
var ArrSz = ((FullPeriod + 1) / 2) * 2;
_mls = new double[ArrSz];
_correlations = new double[ArrSz];
_real = new fftw_complexarray(ArrSz / 2);
_complex = new fftw_complexarray(FullPeriod / 2 + 1);
_forward = fftw_plan.dft_r2c_1d(FullPeriod, _real, _complex, fftw_flags.Estimate | fftw_flags.DestroyInput);
_backward = fftw_plan.dft_c2r_1d(FullPeriod, _complex, _real, fftw_direction.Backward, fftw_flags.Estimate);
}
/// <summary>
/// Perform the Fast Fourier Transform utilisizing the FFTW library
/// </summary>
/// <param name="in">Input Signal</param>
/// <param name="out">Output Signal</param>
/// <param name="N">N</param>
/// <param name="method">FFT Method (DFT, IDFT, DHT)</param>
public static void FFT(ref double[] @in, ref double[] @out, int N, FFTMethod method)
{
var complexInput = new fftw_complexarray(@in);
var complexOutput = new fftw_complexarray(@out);
switch (method)
{
case FFTMethod.DFT:
// fftw_kind.R2HC: input is expected to be real while output is returned in the halfcomplex format
fftw_plan fft = fftw_plan.r2r_1d(N, complexInput, complexOutput, fftw_kind.R2HC, fftw_flags.Estimate);
fft.Execute();
@out = complexOutput.Values;
// free up memory
fft = null;
break;
case FFTMethod.IDFT:
// fftw_kind.HC2R: input is expected to be halfcomplex format while output is returned as real
fftw_plan ifft = fftw_plan.r2r_1d(N, complexInput, complexOutput, fftw_kind.HC2R, fftw_flags.Estimate);
ifft.Execute();
//@out = complexOutput.ValuesDividedByN; // dividing by N gives the correct scale
@out = complexOutput.Values;
// free up memory
ifft = null;
break;
case FFTMethod.DHT:
fftw_plan dht = fftw_plan.r2r_1d(N, complexInput, complexOutput, fftw_kind.DHT, fftw_flags.Estimate);
dht.Execute();
@out = complexOutput.Values;
// free up memory
dht = null;
break;
}
// free up memory
complexInput = null;
complexOutput = null;
GC.Collect();
}
public static Complex[] IFFT_General(MathNet.Numerics.Complex[] spectrum, int threadid)
{
double[] samplep = new double[spectrum.Length * 2];
for (int i = 0; i < spectrum.Length; i++)
{
samplep[2 * i] = spectrum[i].Real;
samplep[2 * i + 1] = spectrum[i].Imag;
}
//FFTW.Net Setup//
IFFT_ArrayIn[threadid] = new fftw_complexarray(samplep);
IFFT_ArrayOut[threadid] = new fftw_complexarray(spectrum.Length);
IFFT_Plan[threadid] = fftw_plan.dft_1d(spectrum.Length, IFFT_ArrayIn[threadid], IFFT_ArrayOut[threadid], fftw_direction.Backward, fftw_flags.Estimate);
IFFT_Plan[threadid].Execute();
MathNet.Numerics.Complex[] Out = IFFT_ArrayOut[threadid].GetData_Complex();
return(Out);
}
public double[] inverse(TFR tfr)
{
int nf = tfr.getTFRAsDoubleArray().Length - 1;
int nw = tfr.getTFRAsDoubleArray()[0].Length;
int ns = nf * hopSize + nw;
double[] output = new double[ns];
fftw_complexarray mdin = new fftw_complexarray(nw);
fftw_complexarray mdout = new fftw_complexarray(nw);
fftw_plan plan;
int hopInd = 0;
Complex[] buf = new Complex[nw];
try
{
for (int hop = 0; hop <= nf * hopSize; hop += hopSize)
{
mdout.SetData(buf);
mdin.SetData(tfr.getTFRAsDoubleArray()[hopInd++]);
plan = fftw_plan.dft_1d(winLength, mdin, mdout, fftw_direction.Backward, fftw_flags.Estimate);
plan.Execute();
buf = mdout.GetData_Complex();
for (int sample = 0; sample < nw; sample++)
{
output[sample + hop] = output[sample + hop] + (buf[sample].Real / nw) * win[sample].Real;
}
}
return(output);
}
catch (Exception)
{
return(output);
}
}
private void button5_Click(object sender, EventArgs e)
{
using (var waveBuilder = new WaveBuilder(MdiParent1.Duration, MdiParent1.Frequency))
{
foreach (string file in recordingPanel1.Files)
{
using (var waveFileReader = new WaveFileReader(Path.Combine(RecordingPanel.AudioFolder, file)))
waveBuilder.Add(waveFileReader);
}
Complex[] data = waveBuilder.GetData_Complex();
var soundCorrelations = new List <AudioForm.SoundCorrelation>();
foreach (var sound in MdiParent1.SoundsClassifier)
{
string phoneme = sound.Key;
int count = data.Length;
Complex[] complexs = data.Zip(sound.Value, (x, y) => (x * y)).ToArray();
var input = new fftw_complexarray(complexs);
var output = new fftw_complexarray(count);
fftw_plan.dft_1d(count, input, output, fftw_direction.Backward, fftw_flags.Estimate).Execute();
List <double> list = output.GetData_Complex().Select(x => x.Magnitude).ToList();
list.Sort();
if (list.Count > MdiParent1.SinglePhonemeCount)
{
list.RemoveRange(0, list.Count - MdiParent1.SinglePhonemeCount);
}
soundCorrelations.AddRange(
list.Select(value => new AudioForm.SoundCorrelation {
Phoneme = phoneme, Value = value
}));
soundCorrelations.Sort();
if (soundCorrelations.Count > MdiParent1.TotalPhonemeCount)
{
soundCorrelations.RemoveRange(MdiParent1.TotalPhonemeCount,
soundCorrelations.Count - MdiParent1.TotalPhonemeCount);
}
}
var listBoxForm = new ListBoxForm(soundCorrelations.Select(item => item.Phoneme).Cast <object>(),
soundCorrelations.Select(item => item.Value));
listBoxForm.ShowDialog();
}
}
static void Main(string[] args)
{
const int sampleSize = 1024;
double[] din = new double[sampleSize * 2];
double[] dout = new double[sampleSize * 2];
din[0] = 1;
fftw_complexarray mdin = new fftw_complexarray(din);
fftw_complexarray mdout = new fftw_complexarray(dout);
fftw_plan plan = fftw_plan.dft_1d(sampleSize, mdin, mdout, fftw_direction.Forward, fftw_flags.Estimate);
plan.Execute();
plan = fftw_plan.dft_1d(sampleSize, mdout, mdin, fftw_direction.Forward, fftw_flags.Estimate);
plan.Execute();
System.Numerics.Complex[] o = mdin.GetData_Complex();
}
private void button5_Click(object sender, EventArgs e)
{
Database database = MdiParent1.Database;
var list = new List <ClientCorrelation>();
Dictionary <int, Contact> dictionary =
database.Load(new Contact())
.ToDictionary(contact => Database.ConvertTo <int>(((Contact)contact).Id),
contact => (Contact)contact);
foreach (string file in recordingPanel1.Files)
{
using (var waveFileReader = new WaveFileReader(Path.Combine(RecordingPanel.AudioFolder, file)))
{
using (var waveBuilder = new WaveBuilder(MdiParent1.Duration, MdiParent1.Frequency))
{
waveBuilder.Add(waveFileReader);
Complex[] data = waveBuilder.GetData_Complex(true);
foreach (var audioFile in MdiParent1.AudioFileClassifier)
{
int count = data.Length;
var input = new fftw_complexarray(data.Zip(audioFile.Value, (x, y) => (x * y)).ToArray());
var output = new fftw_complexarray(count);
fftw_plan.dft_1d(count, input, output, fftw_direction.Forward, fftw_flags.Estimate)
.Execute();
double value = output.GetData_Complex().Select(x => x.Magnitude).Max();
list.Add(new ClientCorrelation
{
Id = audioFile.Key,
Value = value
});
}
}
}
}
list.Sort();
var listBoxForm = new ListBoxForm(list.Select(item => dictionary[item.Id]).Cast <object>(),
list.Select(item => item.Value));
listBoxForm.ShowDialog();
}
/// <summary>
/// Perform the Fast Fourier Transform utilisizing the FFTW library
/// </summary>
/// <param name="in">Input Signal</param>
/// <param name="out">Output Signal</param>
/// <param name="N">N</param>
/// <param name="method">FFT Method (DFT, IDFT, DHT)</param>
public static void FFT(ref double[] @in, ref double[] @out, int N, FFTMethod method)
{
fftw_complexarray complexInput = new fftw_complexarray(@in);
fftw_complexarray complexOutput = new fftw_complexarray(@out);
switch (method)
{
case FFTMethod.DFT:
fftw_plan fft = fftw_plan.r2r_1d(N, complexInput, complexOutput, fftw_kind.R2HC, fftw_flags.Estimate);
fft.Execute();
@out = complexOutput.Values;
// free up memory
fft = null;
break;
case FFTMethod.IDFT:
fftw_plan ifft = fftw_plan.r2r_1d(N, complexInput, complexOutput, fftw_kind.HC2R, fftw_flags.Estimate);
ifft.Execute();
@out = complexOutput.ValuesDividedByN;
// free up memory
ifft = null;
break;
case FFTMethod.DHT:
fftw_plan dht = fftw_plan.r2r_1d(N, complexInput, complexOutput, fftw_kind.DHT, fftw_flags.Estimate);
dht.Execute();
@out = complexOutput.Values;
// free up memory
dht = null;
break;
}
// free up memory
complexInput = null;
complexOutput = null;
GC.Collect();
}
public Complex[] GetData_Complex(bool reverse = false)
{
var length = (int)(_duration * _frequency);
_memoryStream.Seek(0, SeekOrigin.Begin);
var reader = new BinaryReader(_memoryStream);
var list = new List <Int16>();
int i = 0;
try
{
for (; i < length; i++)
{
list.Add(reader.ReadInt16());
}
}
catch
{
for (; i < length; i++)
{
list.Add(0);
}
}
if (reverse)
{
list.Reverse();
}
int count = list.Count;
double[] array = list.Select(x => (double)Math.Abs(x)).ToArray();
var input = new fftw_complexarray(array.Select(x => new Complex(x, 0)).ToArray());
var output = new fftw_complexarray(count);
fftw_plan.dft_1d(count, input, output, fftw_direction.Forward, fftw_flags.Estimate).Execute();
Complex[] data = output.GetData_Complex();
double s = Math.Sqrt(data.Select(x => x.Magnitude).Sum(x => x * x));
return(data.Select(x => x / s).ToArray());
}
public TFR forward(double[] input_signal)
{
int ns = input_signal.Length;
int nw = winLength;
fftw_complexarray mdin = new fftw_complexarray(winLength);
fftw_complexarray mdout = new fftw_complexarray(winLength);
fftw_plan plan;
int nf = (int)Math.Floor((double)(ns - nw) / (double)hopSize);
Complex[][] fframe = new Complex[nf + 1][];
for (int sample = 0; sample < fframe.Length; sample++)
{
fframe[sample] = new Complex[nw];
}
Complex[] buf = new Complex[nw];
Complex factor = new Complex(2.0 / 3.0, 0.0);
int hopInd = 0;
for (int hop = 0; hop <= nf * hopSize; hop += hopSize)
{
for (int sample = 0; sample < nw; sample++)
{
buf[sample] = new Complex(input_signal[hop + sample], 0.0) * factor * win[sample];
}
mdout.SetData(fframe[hopInd]);
mdin.SetData(buf);
plan = fftw_plan.dft_1d(winLength, mdin, mdout, fftw_direction.Forward, fftw_flags.Estimate);
plan.Execute();
fframe[hopInd++] = mdout.GetData_Complex();
}
return(new TFR(fframe));
}
public SearchPeak(SeqGen gen, int minDisc, int nPer, double tEnv, double dnl, int q, bool isFastMode = false)
{
_gen = gen;
_isFastMode = isFastMode;
if (isFastMode)
{
minDisc = nPer = 1;
}
N = _gen.Period * minDisc * nPer;
ArrSz = ((N + 1) / 2) * 2;
_minDisc = minDisc;
OnePer = _gen.Period * minDisc;
_q = q;
_exp = 1;
if (Math.Sign(tEnv) != 0)
{
_exp = 1 - Math.Exp(-1.0 / tEnv);
}
_aq = q * Math.Pow(q, 1.0 / (q - 1)) / (q - 1) * dnl;
Mls = new T[ArrSz];
if (!isFastMode)
{
Array.Clear(Mls, 0, Mls.Length);
ResponseE = new T[ArrSz];
CorrelationE = new T[ArrSz];
CorrelationNL = new T[ArrSz];
}
ResponseNL = new T[ArrSz];
real = new fftw_complexarray(ArrSz / 2);
complex = new fftw_complexarray(N / 2 + 1);
forward = fftw_plan.dft_r2c_1d(N, real, complex, fftw_flags.Estimate | fftw_flags.DestroyInput);
backward = fftw_plan.dft_c2r_1d(N, complex, real, fftw_direction.Backward, fftw_flags.Estimate);
}
// seem to the be the fastest FFT?
static double[] FFTWLIB(double[] signal)
{
var complexSignal = FFTUtils.DoubleToComplexDouble(signal);
// prepare the input arrays
var complexInput = new fftw_complexarray(complexSignal);
var complexOutput = new fftw_complexarray(complexSignal.Length / 2);
fftw_plan fft = fftw_plan.dft_1d(complexSignal.Length / 2, complexInput, complexOutput, fftw_direction.Forward, fftw_flags.Estimate);
// perform the FFT
fft.Execute();
// get the result
var spectrum_fft_abs = complexOutput.Abs;
//Export.ExportCSV("audio_buffer_padded2.csv", signal);
//Export.ExportCSV("spectrum_fft_abs2.csv", spectrum_fft_abs2, fftSize);
// free up memory
complexInput = null;
complexOutput = null;
return(spectrum_fft_abs);
}
public static System.Numerics.Complex[] FFT_General(double[] Signal, int threadid)
{
double[] Sig_complex = new double[Signal.Length * 2];
for (int i = 0; i < Signal.Length; i++) Sig_complex[i * 2] = Signal[i];
//FFTW.Net Setup//
FFT_ArrayIn[threadid] = new fftw_complexarray(Sig_complex);
FFT_ArrayOut[threadid] = new fftw_complexarray(Signal.Length);
FFT_Plan[threadid] = fftw_plan.dft_1d(Signal.Length, FFT_ArrayIn[threadid], FFT_ArrayOut[threadid], fftw_direction.Forward, fftw_flags.Estimate);
FFT_Plan[threadid].Execute();
System.Numerics.Complex[] Out = FFT_ArrayOut[threadid].GetData_Complex();
return Out;
}
public static System.Numerics.Complex[] FFT_General(Complex[] Signal, int threadid)
{
//FFTW.Net Setup//
FFT_ArrayIn[threadid] = new fftw_complexarray(Signal);
FFT_ArrayOut[threadid] = new fftw_complexarray(Signal.Length);
FFT_Plan[threadid] = fftw_plan.dft_1d(Signal.Length, FFT_ArrayIn[threadid], FFT_ArrayOut[threadid], fftw_direction.Forward, fftw_flags.Estimate);
FFT_Plan[threadid].Execute();
System.Numerics.Complex[] Out = FFT_ArrayOut[threadid].GetData_Complex();
return Out;
}
/// <summary>
/// Catch pattern bitmap with the Fastest Fourier Transform
/// </summary>
/// <returns>Matrix of values</returns>
private Matrix <double> Catch(Image <Gray, double> image)
{
const double f = 1.0;
int length = image.Data.Length;
int n0 = image.Data.GetLength(0);
int n1 = image.Data.GetLength(1);
int n2 = image.Data.GetLength(2);
Debug.Assert(n2 == 1);
// Allocate FFTW structures
var input = new fftw_complexarray(length);
var output = new fftw_complexarray(length);
fftw_plan forward = fftw_plan.dft_3d(n0, n1, n2, input, output,
fftw_direction.Forward,
fftw_flags.Estimate);
fftw_plan backward = fftw_plan.dft_3d(n0, n1, n2, input, output,
fftw_direction.Backward,
fftw_flags.Estimate);
var matrix = new Matrix <double>(n0, n1);
double[,,] patternData = _patternImage.Data;
double[,,] imageData = image.Data;
double[,] data = matrix.Data;
var doubles = new double[length];
// Calculate Divisor
Copy(patternData, data);
Buffer.BlockCopy(data, 0, doubles, 0, length * sizeof(double));
input.SetData(doubles.Select(x => new Complex(x, 0)).ToArray());
forward.Execute();
Complex[] complex = output.GetData_Complex();
Buffer.BlockCopy(imageData, 0, doubles, 0, length * sizeof(double));
input.SetData(doubles.Select(x => new Complex(x, 0)).ToArray());
forward.Execute();
input.SetData(complex.Zip(output.GetData_Complex(), (x, y) => x * y).ToArray());
backward.Execute();
IEnumerable <double> doubles1 = output.GetData_Complex().Select(x => x.Magnitude);
if (_fastMode)
{
// Fast Result
Buffer.BlockCopy(doubles1.ToArray(), 0, data, 0, length * sizeof(double));
return(matrix);
}
// Calculate Divider (aka Power)
input.SetData(doubles.Select(x => new Complex(x * x, 0)).ToArray());
forward.Execute();
complex = output.GetData_Complex();
CopyAndReplace(_patternImage.Data, data);
Buffer.BlockCopy(data, 0, doubles, 0, length * sizeof(double));
input.SetData(doubles.Select(x => new Complex(x, 0)).ToArray());
forward.Execute();
input.SetData(complex.Zip(output.GetData_Complex(), (x, y) => x * y).ToArray());
backward.Execute();
IEnumerable <double> doubles2 = output.GetData_Complex().Select(x => x.Magnitude);
// Result
Buffer.BlockCopy(doubles1.Zip(doubles2, (x, y) => (f + x * x) / (f + y)).ToArray(), 0, data, 0,
length * sizeof(double));
return(matrix);
}
public double[] inverse(TFR tfr, ref double[] output_signal_prev, bool last)
{
int nf = tfr.getTFRAsDoubleArray().Length - 1;
int nw = tfr.getTFRAsDoubleArray()[0].Length;
int ns = nf * hopSize + nw;
double[] output_signal_tmp = new double[ns];
double[] output_signal = new double[output_signal_tmp.Length - 3 * hopSize];
fftw_complexarray mdin = new fftw_complexarray(nw);
fftw_complexarray mdout = new fftw_complexarray(nw);
fftw_plan plan;
if (output_signal_prev == null)
{
output_signal_prev = new double[3 * hopSize];
}
for (int sample = 0; sample < hopSize * 3; sample++)
{
output_signal_tmp[sample] = output_signal_prev[sample];
}
int hopInd = 0;
Complex[] buf = new Complex[nw];
try
{
for (int hop = 0; hop <= nf * hopSize; hop += hopSize)
{
mdout.SetData(buf);
mdin.SetData(tfr.getTFRAsDoubleArray()[hopInd++]);
plan = fftw_plan.dft_1d(winLength, mdin, mdout, fftw_direction.Backward, fftw_flags.Estimate);
plan.Execute();
buf = mdout.GetData_Complex();
for (int sample = 0; sample < nw; sample++)
{
output_signal_tmp[sample + hop] = output_signal_tmp[sample + hop] + (buf[sample].Real / nw) * win[sample].Real;
}
}
for (int sample = 0; sample < hopSize * 3; sample++)
{
output_signal_prev[sample] = output_signal_tmp[output_signal_tmp.Length - hopSize * 3 + sample];
}
for (int sample = 0; sample < output_signal.Length; sample++)
{
output_signal[sample] = output_signal_tmp[sample];
}
if (last)
{
return(output_signal_tmp);
}
else
{
return(output_signal);
}
}
catch (Exception)
{
if (last)
{
return(output_signal_tmp);
}
else
{
return(output_signal);
}
}
}
public static Complex[] IFFT_General(System.Numerics.Complex[] spectrum, int threadid)
{
double[] samplep = new double[spectrum.Length * 2];
for (int i = 0; i < spectrum.Length; i++)
{
samplep[2 * i] = spectrum[i].Real;
samplep[2 * i + 1] = spectrum[i].Imaginary;
}
//FFTW.Net Setup//
IFFT_ArrayIn[threadid] = new fftw_complexarray(samplep);
IFFT_ArrayOut[threadid] = new fftw_complexarray(spectrum.Length);
IFFT_Plan[threadid] = fftw_plan.dft_1d(spectrum.Length, IFFT_ArrayIn[threadid], IFFT_ArrayOut[threadid], fftw_direction.Backward, fftw_flags.Estimate);
IFFT_Plan[threadid].Execute();
System.Numerics.Complex[] Out = IFFT_ArrayOut[threadid].GetData_Complex();
return Out;
}
/// <summary>
/// Blur bitmap with the Fastest Fourier Transform
/// </summary>
/// <returns>Blured bitmap</returns>
private double[,,] Blur(double[,,] imageData)
{
int length = imageData.Length;
int n0 = imageData.GetLength(0);
int n1 = imageData.GetLength(1);
int n2 = imageData.GetLength(2);
var input = new fftw_complexarray(length);
var output = new fftw_complexarray(length);
fftw_plan forward = fftw_plan.dft_3d(n0, n1, n2, input, output,
fftw_direction.Forward,
fftw_flags.Estimate);
fftw_plan backward = fftw_plan.dft_3d(n0, n1, n2, input, output,
fftw_direction.Backward,
fftw_flags.Estimate);
var doubles = new double[length];
Buffer.BlockCopy(imageData, 0, doubles, 0, length * sizeof(double));
double average = doubles.Average();
double delta = Math.Sqrt(doubles.Average(x => x * x) - average * average);
switch (_keepOption)
{
case KeepOption.AverageAndDelta:
break;
case KeepOption.Sum:
average = doubles.Sum();
break;
case KeepOption.Square:
average = Math.Sqrt(doubles.Sum(x => x * x));
break;
case KeepOption.AverageSquare:
average = Math.Sqrt(doubles.Average(x => x * x));
break;
default:
throw new NotImplementedException();
}
input.SetData(doubles.Select(x => new Complex(x, 0)).ToArray());
forward.Execute();
Complex[] complex = output.GetData_Complex();
var data = new Complex[n0, n1, n2];
var buffer = new double[length * 2];
GCHandle complexHandle = GCHandle.Alloc(complex, GCHandleType.Pinned);
GCHandle dataHandle = GCHandle.Alloc(data, GCHandleType.Pinned);
IntPtr complexPtr = complexHandle.AddrOfPinnedObject();
IntPtr dataPtr = dataHandle.AddrOfPinnedObject();
Marshal.Copy(complexPtr, buffer, 0, buffer.Length);
Marshal.Copy(buffer, 0, dataPtr, buffer.Length);
switch (_mode)
{
case Mode.BlinderSize:
Blind(data, _blinderSize);
break;
case Mode.FilterStep:
int filterStep = _filterStep;
var blinderSize = new Size(MulDiv(n1, filterStep, filterStep + 1),
MulDiv(n0, filterStep, filterStep + 1));
Blind(data, blinderSize);
break;
default:
throw new NotImplementedException();
}
Marshal.Copy(dataPtr, buffer, 0, buffer.Length);
Marshal.Copy(buffer, 0, complexPtr, buffer.Length);
complexHandle.Free();
dataHandle.Free();
input.SetData(complex);
backward.Execute();
doubles = output.GetData_Complex().Select(x => x.Magnitude).ToArray();
double average2 = doubles.Average();
double delta2 = Math.Sqrt(doubles.Average(x => x * x) - average2 * average2);
switch (_keepOption)
{
case KeepOption.AverageAndDelta:
break;
case KeepOption.Sum:
average2 = doubles.Sum();
break;
case KeepOption.Square:
average2 = Math.Sqrt(doubles.Sum(x => x * x));
break;
case KeepOption.AverageSquare:
average2 = Math.Sqrt(doubles.Average(x => x * x));
break;
default:
throw new NotImplementedException();
}
// a*average2 + b == average
// a*delta2 == delta
double a = (_keepOption == KeepOption.AverageAndDelta) ? (delta / delta2) : (average / average2);
double b = (_keepOption == KeepOption.AverageAndDelta) ? (average - a * average2) : 0;
Debug.Assert(Math.Abs(a * average2 + b - average) < 0.1);
doubles = doubles.Select(x => Math.Round(a * x + b)).ToArray();
Buffer.BlockCopy(doubles, 0, imageData, 0, length * sizeof(double));
return(imageData);
}
private void button4_Click(object sender, EventArgs e)
{
Database database = MdiParent1.Database;
Dictionary <int, Contact> dictionary =
database.Load(new Contact())
.ToDictionary(record => Database.ConvertTo <int>(((Contact)record).Id),
record => (Contact)record);
int id1;
int id2;
using (var spectrumBuilder = new SpectrumBuilder(MdiParent1.SpectrumLength, MdiParent1.Frequency))
{
foreach (string file in recordingPanel1.Files)
{
using (var waveFileReader = new WaveFileReader(Path.Combine(RecordingPanel.AudioFolder, file)))
spectrumBuilder.Add(waveFileReader);
}
List <ClientCorrelation> clientCorrelations =
MdiParent1.ContactClassifier.Select(character => new ClientCorrelation
{
Id = character.Key,
Value = new CorrelationBuilder(spectrumBuilder.GetData(), character.Value).GetValue()
}).ToList();
clientCorrelations.Sort();
id1 = clientCorrelations[0].Id;
}
var list = new List <ClientCorrelation>();
foreach (string file in recordingPanel1.Files)
{
using (var waveFileReader = new WaveFileReader(Path.Combine(RecordingPanel.AudioFolder, file)))
{
using (var waveBuilder = new WaveBuilder(MdiParent1.Duration, MdiParent1.Frequency))
{
waveBuilder.Add(waveFileReader);
Complex[] data = waveBuilder.GetData_Complex(true);
foreach (var audioFile in MdiParent1.AudioFileClassifier)
{
int count = data.Length;
var input = new fftw_complexarray(data.Zip(audioFile.Value, (x, y) => (x * y)).ToArray());
var output = new fftw_complexarray(count);
fftw_plan.dft_1d(count, input, output, fftw_direction.Forward, fftw_flags.Estimate)
.Execute();
double value = output.GetData_Complex().Select(x => x.Magnitude).Max();
list.Add(new ClientCorrelation
{
Id = audioFile.Key,
Value = value
});
}
}
}
}
list.Sort();
id2 = list.First().Id;
var contact = (Contact)database.Load(new Contact {
Id = id1
}).First();
var accessGrantedForm = new AccessGrantedForm(id1 == id2)
{
Id = Database.ConvertTo <int>(contact.Id),
FirstName = Database.ConvertTo <string>(contact.FirstName),
LastName = Database.ConvertTo <string>(contact.LastName),
Phone = Database.ConvertTo <string>(contact.Phone),
Email = Database.ConvertTo <string>(contact.Email),
};
accessGrantedForm.ShowDialog();
}
