private void Add(float value)
{
if (PerformFFT && FftCalculated != null)
{
int currentFFTPos = fftPos[currentFilter];
fftBuffer[currentFilter][currentFFTPos].X = (float)(value * FastFourierTransform.HammingWindow(currentFFTPos, fftLength));
fftBuffer[currentFilter][currentFFTPos].Y = 0;
currentFFTPos++;
if (currentFFTPos >= fftBuffer[currentFilter].Length)
{
currentFFTPos = 0;
// 1024 = 2^10
FastFourierTransform.FFT(true, m, fftBuffer[currentFilter]);
fftArgs.currentFilterIndex = currentFilter;
fftArgs.Result = fftBuffer[currentFilter];
FftCalculated(this, fftArgs);
}
fftPos[currentFilter] = currentFFTPos;
}
/*maxValue = Math.Max(maxValue, value);
* minValue = Math.Min(minValue, value);
* count++;
* if (count >= NotificationCount && NotificationCount > 0)
* {
* if (MaximumCalculated != null)
* {
* MaximumCalculated(this, new MaxSampleEventArgs(minValue, maxValue));
* }
* Reset();
* } */
}
public void Load(string path)
{
FourierSounds = new List <Complex[]>();
using (var reader = new WaveFileReader(path))
{
SampleRate = reader.WaveFormat.SampleRate;
Ts = 1.0 / SampleRate;
FftLength = 4096;
//FftLength = 2048;
//FftLength = 1024;
Time = reader.TotalTime.TotalSeconds;
var channels = reader.WaveFormat.Channels;
var m = (int)Math.Log(FftLength, 2.0);
var readBuffer = new byte[reader.Length];
reader.Read(readBuffer, 0, readBuffer.Length);
var data = ConvertByteToFloat(readBuffer, readBuffer.Length);
for (var j = 0; j < data.Length / FftLength; j++)
{
var sampleBuffer = data.Skip(j * FftLength).Take(FftLength).ToList();
var fftBuffer = new Complex[FftLength];
var fftPos = 0;
for (var i = 0; i < FftLength; i++)
{
fftBuffer[fftPos].X = (float)(sampleBuffer[i] * FastFourierTransform.HammingWindow(i, FftLength));
fftBuffer[fftPos].Y = 0;
fftPos++;
}
FastFourierTransform.FFT(true, m, fftBuffer);
FourierSounds.Add(fftBuffer);
}
}
}
private void Add(float value)
{
if (PerformFFT && FftCalculated != null)
{
fftBuffer[fftPos].X = (float)(value * FastFourierTransform.HammingWindow(fftPos, fftLength));
//fftBuffer[fftPos].X = (float)(value * FastFourierTransform.BlackmannHarrisWindow(fftPos, fftLength));
//fftBuffer[fftPos].X = value;
fftBuffer[fftPos].Y = 0;
fftPos++;
if (fftPos >= fftBuffer.Length)
{
fftPos = 0;
//var copyBuffer = new Complex[fftBuffer.Length];
//fftPos = fftBuffer.Length / 2;
//for (int i = 0; i < fftBuffer.Length / 2; i++)
//{
// copyBuffer[i] = fftBuffer[fftBuffer.Length / 2 + i].Clone();
//}
// nadav - copy ffts
var newFFT = new Complex[fftBuffer.Length];
for (int i = 0; i < fftBuffer.Length; i++)
{
newFFT[i] = fftBuffer[i].Clone();
}
FFTDataCalculated.Add(newFFT);
// 1024 = 2^10
FastFourierTransform.FFT(false, m, fftBuffer);
FftCalculated(this, new FftEventArgs(fftBuffer));
//fftBuffer = copyBuffer;
if (fftBuffer.Any(c => c.X != 0 || c.Y != 0))
{
var firstNotNul = fftBuffer.FirstOrDefault(c => c.X != 0 || c.Y != 0);
var x = firstNotNul.X;
var y = firstNotNul.Y;
}
}
}
maxValue = Math.Max(maxValue, value);
minValue = Math.Min(minValue, value);
count++;
if (count >= NotificationCount && NotificationCount > 0)
{
if (MaximumCalculated != null)
{
MaximumCalculated(this, new MaxSampleEventArgs(minValue, maxValue));
}
Reset();
}
}
private void Add(float r, float i)
{
_count++;
if (FftCalculated != null)
{
_fftBuffer[_fftPos].X = (float)(r * FastFourierTransform.HammingWindow(_fftPos, _fftLength));
_fftBuffer[_fftPos].Y = (float)(i * FastFourierTransform.HammingWindow(_fftPos, _fftLength));
_fftPos++;
if (_fftPos >= _fftBuffer.Length)
{
CalculateFft();
}
}
_maxValue = Math.Max(_maxValue, r);
_minValue = Math.Min(_minValue, r);
if (_count < _notificationCount || _notificationCount <= 0)
{
return;
}
if (MaximumCalculated != null)
{
MaximumCalculated(this, new MaxSampleEventArgs(_minValue, _maxValue));
}
Reset();
}
public void Add(float value)
{
if (PerformFFT && FftCalculated != null)
{
Complex tempcomplex;
tempcomplex.X = (float)(value * FastFourierTransform.HammingWindow(fftPos, fftBuffer.Length));
tempcomplex.Y = 0;
fftBufferQueue.Enqueue(tempcomplex);
// fftBuffer[fftPos].X = (float)(value * FastFourierTransform.HammingWindow(fftPos, fftBuffer.Length));
// fftBuffer[fftPos].Y = 0;
if (fftPos < fftBuffer.Length)
{
fftPos++;
}
else
{
fftBuffer = fftBufferQueue.ToArray();
FastFourierTransform.FFT(true, m, fftBuffer);
FftCalculated(this, fftArgs);
fftBufferQueue.Dequeue();
}
}
maxValue = Math.Max(maxValue, value);
minValue = Math.Min(minValue, value);
count++;
if (count >= NotificationCount && NotificationCount > 0)
{
if (MaximumCalculated != null)
{
MaximumCalculated(this, new MaxSampleEventArgs(minValue, maxValue));
}
Reset();
}
}
private void Add(float value)
{
if (PerformFFT && FftCalculated != null)
{
fftBuffer[fftPos].X = (float)(value * FastFourierTransform.HammingWindow(fftPos, fftLength));
fftBuffer[fftPos].Y = 0;
fftPos++;
if (fftPos >= fftBuffer.Length)
{
fftPos = 0;
// 1024 = 2^10
FastFourierTransform.FFT(true, m, fftBuffer);
FftCalculated(this, fftArgs);
}
}
maxValue = Math.Max(maxValue, value);
minValue = Math.Min(minValue, value);
count++;
if (count >= NotificationCount && NotificationCount > 0)
{
MaximumCalculated?.Invoke(this, new MaxSampleEventArgs(minValue, maxValue));
Reset();
}
}
private void FFTWindowChange(Complex[] channelData, FFTWindow window)
{
switch (window)
{
case FFTWindow.HannWindow:
for (int i = 0; i < channelData.Length; i++)
{
channelData[i].X = (float)(channelData[i].X * FastFourierTransform.HannWindow(i, bufferSize));
}
break;
case FFTWindow.HammingWindow:
for (int i = 0; i < channelData.Length; i++)
{
channelData[i].X = (float)(channelData[i].X * FastFourierTransform.HammingWindow(i, bufferSize));
}
break;
case FFTWindow.BlackmannHarrisWindow:
for (int i = 0; i < channelData.Length; i++)
{
channelData[i].X = (float)(channelData[i].X * FastFourierTransform.BlackmannHarrisWindow(i, bufferSize));
}
break;
}
FastFourierTransform.FFT(false, binaryExponentitation, channelData);
}
private void Add(float value)
{
if (PerformFFT && FftCalculated != null)
{
_fftBuffer[_fftPos].X = (float)(value * FastFourierTransform.HammingWindow(_fftPos, _fftLength));
_fftBuffer[_fftPos].Y = 0;
_fftPos++;
if (_fftPos >= _fftBuffer.Length)
{
_fftPos = 0;
FastFourierTransform.FFT(true, _dim, _fftBuffer);
FftCalculated(this, _fftArgs);
}
}
_maxValue = Math.Max(_maxValue, value);
_minValue = Math.Min(_minValue, value);
_count++;
if (_count >= NotificationCount && NotificationCount > 0)
{
MaximumCalculated?.Invoke(this, new MaxSampleEventArgs(_minValue, _maxValue));
Reset();
}
}
public static void AddSample(float value)
{
switch (Window)
{
case FFTWindow.BlackmannHarris:
_fftBuffer[_fftPos].X = (float)(value * FastFourierTransform.BlackmannHarrisWindow(_fftPos, _fftLength));
break;
case FFTWindow.Hamming:
_fftBuffer[_fftPos].X = (float)(value * FastFourierTransform.HammingWindow(_fftPos, _fftLength));
break;
case FFTWindow.Hann:
_fftBuffer[_fftPos].X = (float)(value * FastFourierTransform.HannWindow(_fftPos, _fftLength));
break;
}
_fftBuffer[_fftPos].Y = 0;
_fftPos++;
if (_fftPos >= _fftLength)
{
_fftPos = 0;
FastFourierTransform.FFT(true, _m, _fftBuffer);
FftCalculated();
}
}
private static double[] calculateFFT(short[] dataPcm)
{
// the PCM size to be analyzed with FFT must be a power of 2
int fftPoints = 2;
while (fftPoints * 2 <= dataPcm.Length)
{
fftPoints *= 2;
}
// apply a Hamming window function as we load the FFT array then calculate the FFT
Complex[] fftFull = new Complex[fftPoints];
for (int i = 0; i < fftPoints; i++)
{
fftFull[i].X = (float)(dataPcm[i] * FastFourierTransform.HammingWindow(i, fftPoints));
}
FastFourierTransform.FFT(true, (int)Math.Log(fftPoints, 2.0), fftFull);
// copy the complex values into the double array that will be plotted
double[] dataFft = new double[fftPoints / 2];
for (int i = 0; i < fftPoints / 2; i++)
{
double fftLeft = Math.Abs(fftFull[i].X + fftFull[i].Y);
double fftRight = Math.Abs(fftFull[fftPoints - i - 1].X + fftFull[fftPoints - i - 1].Y);
dataFft[i] = fftLeft + fftRight;
}
return(dataFft);
}
public void Add(float value)
{
//Console.WriteLine("added");
if (FftCalculated != null)
{
// Remember the window function! There are many others as well.
fftBufferDoubled[fftPos].X = (float)(value * FastFourierTransform.HammingWindow(fftPos, fftLength));
fftBufferDoubled[fftPos].Y = 0; // This is always zero with audio.
fftPos++;
if (fftPos >= fftLength && fftPos % (fftLength / timeScaleFactor) == 0)
{
for (int i = fftPos - fftLength, j = 0; i < fftPos; i++, j++)
{
fftBuffer[j] = fftBufferDoubled[i];
}
FastFourierTransform.FFT(true, m, fftBuffer);
FftCalculated(this, fftArgs);
//fftPos = 0;
}
if (fftPos == 2 * fftLength)
{
for (int i = fftLength, j = 0; j < fftLength; i++, j++)
{
fftBufferDoubled[j] = fftBufferDoubled[i];
}
fftPos = fftLength;
}
}
}
private void GenerateFFTWindow()
{
for (int i = 0; i < size; i++)
{
fftWindowShape[i] = (float)FastFourierTransform.HammingWindow(i, size);
//fftWindowShape[i] = (float)FastFourierTransform.BlackmannHarrisWindow(i, size);
//fftWindowShape[i] = (float)FastFourierTransform.HannWindow(i, size);
}
}
public void bufferFFT()
{
indata = new ComplexF[buffersize * 2];
for (int i = 0; i < buffersize * 2; i++)
{
indata[i].Re = sampledata[i] * (float)FastFourierTransform.HammingWindow(i, buffersize * 2);
indata[i].Im = 0;
}
Exocortex.DSP.Fourier.FFT(indata, buffersize * 2, Exocortex.DSP.FourierDirection.Forward);
filteredindata = filterMean(indata, 1.5);
}
public static Complex[] ToComplex(this float[] samples)
{
var result = new Complex[samples.Length];
for (int i = 0; i < samples.Length; i++)
{
result[i].X = (float)(samples[i] * FastFourierTransform.HammingWindow(i, result.Length));
result[i].Y = 0;
}
return(result);
}
private void addToBuffer(float value)
{
// Remember the window function! There are many others as well.
this.fftBuffer[this.fftPos].X = (float)(value * FastFourierTransform.HammingWindow(this.fftPos, this.fftLength));
this.fftBuffer[this.fftPos].Y = 0; // This is always zero with audio.
this.fftPos++;
if (this.fftPos >= this.fftLength)
{
this.fftPos = 0;
FastFourierTransform.FFT(true, this.m, this.fftBuffer);
FftCalculated(this, this.fftArgs);
}
}
public void bufferFFT()
{
indata = new ComplexF[buffersize * 2];
for (int i = 0; i < buffersize * 2; i++)
{
indata[i].Re = sampledata[i] * (float)FastFourierTransform.HammingWindow(i, buffersize * 2);
indata[i].Im = 0;
}
Exocortex.DSP.Fourier.FFT(indata, buffersize * 2, Exocortex.DSP.FourierDirection.Forward);
// The factor may need to be tuned (1.8 works on SP3).
filteredindata = filterMean(indata, 1.8);
}
private void Add(float value)
{
fftBuffer[fftPos].X = (float)(value * FastFourierTransform.HammingWindow(fftPos, fftLength));
fftBuffer[fftPos].Y = 0;
fftPos++;
if (fftPos >= fftBuffer.Length)
{
fftPos = 0;
FastFourierTransform.FFT(true, m, fftBuffer);
fftArgs = new FftEventArgs(fftBuffer, NotificationCount * 100);
FftCalculated(this, fftArgs);
}
}
public Complex[] GetTargetDat(float[] dat, int index)
{
var fftsample = new Complex[fftsampleRange];
for (int i = 0; i < fftsampleRange; i++)
{
float d = i + index < dat.Length ? dat[i + index] : 0;
fftsample[i].X = (float)(d * FastFourierTransform.HammingWindow(i, fftsampleRange));
fftsample[i].Y = 0;
}
return(fftsample);
}
public void AddSample(float sample)
{
SampleProcessed++;
if (Samples.Count < FFTLength)
{
Enqueue(sample);
}
else
{
Enqueue(sample);
CurrentGap++;
if (CurrentGap < SampleGap && SampleProcessed != SampleCount)
{
return;
}
CurrentGap = 0;
if (Samples.Count == FFTLength)
{
Complex[] fft = new Complex[FFTLength];
int i = 0;
foreach (var s in Samples)
{
fft[i].X = (float)(s * FastFourierTransform.HammingWindow(i, FFTLength));
fft[i].Y = 0;
i++;
}
FastFourierTransform.FFT(true, m, fft);
SampleAnalysis[] result = new SampleAnalysis[FFTLength];
for (int n = 0; n < fft.Length; n++)
{
result[n].Frequency = Physics.GetFrequency(n, AudioReader.WaveFormat.SampleRate, FFTLength);
result[n].Amplitude = Physics.GetAmplitude(fft[n]);
}
Processed?.Invoke(result);
}
}
}
public void Add(float value)
{
if (PerformFFT && FftCalculated != null)
{
fftBuffer[fftPos].X = (float)(5 + value * FastFourierTransform.HammingWindow(fftPos, fftLength));
fftBuffer[fftPos].Y = 0;
fftPos++;
if (fftPos >= fftLength)
{
fftPos = 0;
FastFourierTransform.FFT(true, m, fftBuffer);
FftCalculated(this, fftArgs);
}
}
}
void AnalyzeChunk()
{
// fill data with FFT info
var data = new short[FFT_SIZE];
data = unanalyzed_values.GetRange(0, FFT_SIZE).ToArray();
// remove the left-most (oldest) column of data
spectrogram_data.RemoveAt(0);
// insert new data to the right-most (newest) position
var newData = new List <double>();
// prepare the complex data which will be FFT'd
Complex[] fft_buffer = new Complex[FFT_SIZE];
for (int i = 0; i < FFT_SIZE; i++)
{
//fft_buffer[i].X = (float)unanalyzed_values[i]; // no window
fft_buffer[i].X = (float)(unanalyzed_values[i] * FastFourierTransform.HammingWindow(i, FFT_SIZE)); // Hamming Window
fft_buffer[i].Y = 0;
}
// perform the FFT
FastFourierTransform.FFT(true, (int)Math.Log(FFT_SIZE, 2.0), fft_buffer);
// fill that new data list with fft values
for (int i = 0; i < spectrogram_data[spectrogram_data.Count - 1].Count; i++)
{
// sqrt(X^2+Y^2)
//var val = (double)fft_buffer[i].X + (double)fft_buffer[i].Y;
var val = Math.Sqrt(Math.Pow(fft_buffer[i].X, 2) + Math.Pow(fft_buffer[i].Y, 2));
//val = Math.Abs(val);
if (checkBox1.Checked)
{
val = Math.Log(val);
}
newData.Add(val);
}
ProccessNotes(newData);
//newData.Reverse();
spectrogram_data.Insert(spectrogram_data.Count, newData);
// remove a certain amount of unanalyzed data
unanalyzed_values.RemoveRange(0, FFT_SIZE / _pixelsPerBuffer);
}
public void Add(float value)
{
if (PerformFFT && FftCalculated != null)
{
// Remember the window function! There are many others as well.
fftBuffer[fftPos].X = (float)(value * FastFourierTransform.HammingWindow(fftPos, fftLength));
fftBuffer[fftPos].Y = 0; // This is always zero with audio.
fftPos++;
if (fftPos >= fftLength)
{
fftPos = 0;
FastFourierTransform.FFT(true, m, fftBuffer);
FftCalculated(this, fftArgs);
}
}
}
public void Add(float value)
{
// Remember the window function! There are many others as well.
_fftBuffer[_fftPos].X = (float)(value * FastFourierTransform.HammingWindow(_fftPos, _fftLength));
_fftBuffer[_fftPos].Y = 0; // This is always zero with audio.
_fftPos++;
if (_fftPos >= _fftLength)
{
_fftPos = 0;
FastFourierTransform.FFT(true, _m, _fftBuffer);
if (FftCalculated != null)
{
FftCalculated(this, _fftArgs);
}
}
}
/// <summary>
/// break-off the first chunk of unanalyzed_values and analyze it
/// </summary>
void Analyze_chunk()
{
// fill data with FFT info
short[] data = new short[fft_size];
data = unanalyzed_values.GetRange(0, fft_size).ToArray();
// remove the left-most (oldest) column of data
spec_data.RemoveAt(0);
// insert new data to the right-most (newest) position
List <double> new_data = new List <double>();
// prepare the complex data which will be FFT'd
Complex[] fft_buffer = new Complex[fft_size];
for (int i = 0; i < fft_size; i++)
{
//fft_buffer[i].X = (float)unanalyzed_values[i]; // no window
fft_buffer[i].X = (float)(unanalyzed_values[i] * FastFourierTransform.HammingWindow(i, fft_size));
fft_buffer[i].Y = 0;
}
// perform the FFT
FastFourierTransform.FFT(true, (int)Math.Log(fft_size, 2.0), fft_buffer);
// fill that new data list with fft values
for (int i = 0; i < spec_data[spec_data.Count - 1].Count; i++)
{
// should this be sqrt(X^2+Y^2)?
double val;
val = (double)fft_buffer[i].X + (double)fft_buffer[i].Y;
val = Math.Abs(val);
if (checkBox1.Checked)
{
val = Math.Log(val);
}
new_data.Add(val);
}
new_data.Reverse();
spec_data.Insert(spec_data.Count, new_data); // replaces, doesn't append!
// remove a certain amount of unanalyzed data
unanalyzed_values.RemoveRange(0, fft_size / pixelsPerBuffer);
}
private void Add(float value)
{
if (FftCalculated == null)
{
return;
}
fftBuffer[_fftBufferPosition].X = (float)(value * FastFourierTransform.HammingWindow(_fftBufferPosition, FftSize));
fftBuffer[_fftBufferPosition].Y = 0;
_fftBufferPosition++;
if (_fftBufferPosition >= fftBuffer.Length)
{
_fftBufferPosition = 0;
// 1024 = 2^10
FastFourierTransform.FFT(true, _mFactor, fftBuffer);
ConvertComplexToAmplitude();
FftCalculated(_resultBuffer);
}
}
void Analyze_chunk()
{
short[] data = new short[fft_size];
data = unanalyzed_values.GetRange(0, fft_size).ToArray();
// usun kolumne najbardziej po lewo
spec_data.RemoveAt(0);
// dodaj nowa kolumne po prawo
List <double> new_data = new List <double>();
// przygotuj dane do FFT
Complex[] fft_buffer = new Complex[fft_size];
for (int i = 0; i < fft_size; i++)
{
fft_buffer[i].X = (float)(unanalyzed_values[i] * FastFourierTransform.HammingWindow(i, fft_size));
fft_buffer[i].Y = 0;
}
// FFT
FastFourierTransform.FFT(true, (int)Math.Log(fft_size, 2.0), fft_buffer);
// wypelnij liste wartosciami fft
for (int i = 0; i < spec_data[spec_data.Count - 1].Count; i++)
{
double val;
val = (double)fft_buffer[i].X + (double)fft_buffer[i].Y;
val = Math.Abs(val);
if (checkBox1.Checked)
{
val = Math.Log(val);
}
new_data.Add(val);
}
new_data.Reverse();
spec_data.Insert(spec_data.Count, new_data);
// usun nieanalizowane dane
unanalyzed_values.RemoveRange(0, fft_size / pixelsPerBuffer);
}
/// <summary>
/// break-off the first chunk of unanalyzed_values and analyze it
/// Взять первый чанк unanalyzed_values и проанализировать его
/// </summary>
void Analyze_chunk()
{
// remove the left-most (oldest) column of data
_specData.RemoveAt(0);
// insert new data to the right-most (newest) position
List <double> newData = new List <double>();
// prepare the complex data which will be FFT'd
Complex[] fft_buffer = new Complex[_fftSize];
for (int i = 0; i < _fftSize; i++)
{
//fft_buffer[i].X = (float)unanalyzed_values[i]; // no window
fft_buffer[i].X = (float)(_unanalyzedValues[i] * FastFourierTransform.HammingWindow(i, _fftSize));
fft_buffer[i].Y = 0;
}
// perform the FFT
FastFourierTransform.FFT(true, (int)Math.Log(_fftSize, 2.0), fft_buffer);
// fill that new data list with fft values
for (int i = 0; i < _specData[_specData.Count - 1].Count; i++)
{
// should this be sqrt(X^2+Y^2)?
double val;
val = (double)fft_buffer[i].X + (double)fft_buffer[i].Y;
val = Math.Abs(val);
if (numericUpDown1.Value == 0)
{
val = Math.Log(val);
}
//if (checkBox1.Checked) val = Math.Log(val);
newData.Add(val);
}
newData.Reverse();
_specData.Insert(_specData.Count, newData); // replaces, doesn't append
// remove a certain amount of unanalyzed data
_unanalyzedValues.RemoveRange(0, _fftSize / _pixelsPerBuffer);
}
private void OnSample(object sender, SampleEventArgs e)
{
FFTBuffer[FFTPosition].X = (float)(e.Right * FastFourierTransform.HammingWindow(FFTPosition, FFTLength)); // e.Right ? seems equal to e.Left in this case (mono?)
FFTBuffer[FFTPosition].Y = 0;
FFTPosition++;
if (FFTPosition >= FFTBuffer.Length)
{
FastFourierTransform.FFT(true, (int)Math.Log(FFTLength, 2.0), FFTBuffer);
FFTPosition = 0;
SampleAnalysis[] result = new SampleAnalysis[FFTLength];
for (int n = 0; n < FFTBuffer.Length; n++)
{
result[n].Frequency = Physics.GetFrequency(n, AudioReader.WaveFormat.SampleRate, FFTLength);
result[n].Amplitude = Physics.GetAmplitude(FFTBuffer[n]);
}
Processed?.Invoke(result);
}
}
public float[] FFTProcess(float[] sdata, int index)
{
var fftsample = new Complex[fftsampleRange];
var res = new float[fftsampleRange / 2];
for (int i = 0; i < fftsampleRange; i++)
{
float d = i + index < sdata.Length ? sdata[i + index] : 0;
fftsample[i].X = (float)(d * FastFourierTransform.HammingWindow(i, fftsampleRange));
fftsample[i].Y = 0;
}
FastFourierTransform.FFT(true, (int)Math.Log(fftsampleRange, 2), fftsample);
for (int i = 0; i < fftsampleRange / 2; i++)
{
//res[i] = 10 * (float)Math.Log(Math.Sqrt(fftsample[i].X * fftsample[i].X + fftsample[i].Y * fftsample[i].Y));//Dbに変換
res[i] = (float)Math.Sqrt(fftsample[i].X * fftsample[i].X + fftsample[i].Y * fftsample[i].Y);//パワースペクトル
}
return(res);
}
public void AnalyzeValues()
{
if (WaveFileReader.Samples.Count == 0)
{
return;
}
var audioBatches = SplitIntoChunks(WaveFileReader.Samples, FftLength);
foreach (var batch in audioBatches)
{
var samples = (List <float>)batch;
if (samples.Count < FftLength)
{
continue;
}
LastFftSamples = new Complex[FftLength];
foreach (var sample in samples)
{
var i = samples.IndexOf(sample);
LastFftSamples[i].X = (float)(sample * FastFourierTransform.HammingWindow(i, FftLength));
LastFftSamples[i].Y = 0;
}
FastFourierTransform.FFT(true, (int)Math.Log(FftLength, 2.0), LastFftSamples);
var specDataColumn = new List <double>();
foreach (var sampleAfterFFT in LastFftSamples)
{
var magnitude = 2 * Math.Sqrt(sampleAfterFFT.X * sampleAfterFFT.X + sampleAfterFFT.Y * sampleAfterFFT.Y) / FftLength;
var amplitudeInDb = 10 * Math.Log10(magnitude);
specDataColumn.Add(amplitudeInDb);
}
specDataColumn.Reverse();
SpecData.Add(specDataColumn);
}
}
