private void FilterWithFiniteImpluseResponseInTheTimeDomain(object o)
{
Stopwatch sw = new Stopwatch();
sw.Start();
try
{
int L = int.Parse(this.FilterLength);
int Fc = int.Parse(this.CutoffFrequency);
int Fs = this.SampleRate;
double[] filter = FilterWithFiniteImpulseResponse.GetFilterValues(Fc, Fs, L);
double[] filtered = FourierWindows.MultiplyByWindowFunction(filter, this.SelectedWindowType);
double[] result = FilterWithFiniteImpulseResponse.FilterInTheTimeDomain(this.SignalData.Samples, filtered, L);
this.FilterResultInTheTimeDomain = result;
}
catch (Exception e)
{
Notify.Error(e.Message);
}
sw.Stop();
this.FilterTimeInTheTimeDomain = sw.ElapsedMilliseconds.ToString();
}
private void Autocorrelation(object o)
{
double[] autocorrelation = Models.Autocorrelation.CalculateAutocorrelation(this.Channel);
List <DataPoint> signal = new List <DataPoint>();
for (int i = 0; i < autocorrelation.Length; i++)
{
signal.Add(new DataPoint(i, autocorrelation[i]));
}
this.AutocorrelationData = signal;
double[][] data = FourierWindows.SplitData(this.Channel, 2048);
this.AutocorrelationFreq = Models.Autocorrelation.CalculateFrequencies(data, this.SampleRate);
}
private void FilterWithFiniteImpluseResponseInTheFrequencyDomain(object o)
{
Stopwatch sw = new Stopwatch();
sw.Start();
try
{
int L = int.Parse(this.FilterLength);
int Fc = int.Parse(this.CutoffFrequency);
int Fs = this.SampleRate;
int R = int.Parse(this.HopSize);
int M = int.Parse(this.WindowSize);
int n = GetExpandedPow2(M + L - 1);
int size = this.SignalData.Samples.Length + n - L;
double[] result = new double[size];
double[][] windows = new double[size / R][];
Complex[][] windowsComplex = new Complex[size / R][];
for (int i = 0; i < windows.Length; i++)
{
windows[i] = new double[n];
windowsComplex[i] = new Complex[n];
}
double[] windowFactors = FourierWindows.GetWindowFactors(M, this.SelectedWindowType);
for (int i = 0; i < windows.Length; i++)
{
for (int j = 0; j < M; j++)
{
if (i * R + j < this.SignalData.Samples.Length)
{
windows[i][j] = windowFactors[j] * this.SignalData.Samples[i * R + j];
}
else
{
windows[i][j] = 0;
}
}
for (int j = M; j < n; j++)
{
windows[i][j] = 0;
}
}
double[] windowFilterFactors = FourierWindows.GetWindowFactors(L, this.SelectedWindowType);
double[] filterFactors = FilterWithFiniteImpulseResponse.GetFilterValues(Fc, Fs, L);
double[] filtered = new double[n];
for (int i = 0; i < L; i++)
{
filtered[i] = windowFilterFactors[i] * filterFactors[i];
}
for (int i = L; i < n; i++)
{
filtered[i] = 0;
}
if (this.SelectedZeroFillingMethod == ZeroFillingMethod.CauselessFilter)
{
int shiftNumberFilter = (L - 1) / 2;
IEnumerable <double> shiftedFilter = filtered.Take(shiftNumberFilter);
List <double> filteredTemp = filtered.Skip(shiftNumberFilter).ToList();
filteredTemp.AddRange(shiftedFilter);
filtered = filteredTemp.ToArray();
}
Complex[] filteredComplex = FourierTransform.FFT(filtered);
for (int i = 0; i < windows.Length; i++)
{
windowsComplex[i] = FourierTransform.FFT(windows[i]);
for (int j = 0; j < windowsComplex[i].Length; j++)
{
windowsComplex[i][j] *= filteredComplex[j];
}
windows[i] = FourierTransform.IFFT(windowsComplex[i]);
}
for (int i = 0; i < windows.Length; i++)
{
for (int j = 0; j < windows[i].Length; j++)
{
if (i * R + j < this.SignalData.Samples.Length)
{
result[i * R + j] += windows[i][j];
}
}
}
this.FilterResultInTheFrequencyDomain = result;
}
catch (Exception e)
{
Notify.Error(e.Message);
}
sw.Stop();
this.FilterTimeInTheFrequencyDomain = sw.ElapsedMilliseconds.ToString();
}
private void FourierSpectrumAnalysis(object o)
{
try
{
double[][] data = FourierWindows.Calculate(FourierWindows.SplitData(this.Channel, 2048), this.SelectedWindowType, float.Parse(this.Sigma));
int[] freq = new int[data.Length];
for (int i = 0; i < freq.Length; i++)
{
double[] data2 = new double[data[i].Length];
for (int j = 0; j < data[i].Length; j++)
{
if (j != 0)
{
data2[j] = data[i][j] - 0.94 * data[i][j - 1];
}
else
{
data2[j] = data[i][j];
}
}
List <Complex> signal = new List <Complex>();
for (int j = 0; j < data2.Length; j++)
{
signal.Add(new Complex(data2[j], 0));
}
List <Complex> dft = AMath.CalculateFastTransform(signal, AMath.CalculateWCoefficients(data2.Length, false), 0);
dft.RemoveRange(dft.Count / 2, dft.Count / 2);
double[] spectrum = new double[dft.Count];
for (int j = 0; j < spectrum.Length; j++)
{
spectrum[j] = Math.Sqrt((dft[j].Re * dft[j].Re) + (dft[j].Im * dft[j].Im));
}
List <int> max = new List <int>();
for (int j = 1; j < spectrum.Length - 1; j++)
{
if (spectrum[j - 1] < spectrum[j] && spectrum[j + 1] < spectrum[j])
{
max.Add(j);
}
}
int globalMax = 0;
double globalMaxVal = 0;
for (int j = 0; j < max.Count; j++)
{
int index = max[j];
double value = spectrum[index];
if (value > globalMaxVal)
{
globalMax = index;
globalMaxVal = value;
}
}
double border = 0.2 * globalMaxVal;
List <int> bordered = new List <int>();
for (int j = 0; j < max.Count; j++)
{
if (spectrum[max[j]] >= border)
{
bordered.Add(max[j]);
}
}
double median;
if (bordered.Count > 1)
{
List <double> differences = new List <double>();
for (int j = 0; j < max.Count - 1; j++)
{
for (int k = j + 1; k < max.Count; k++)
{
differences.Add(Math.Abs(max[j] - max[k]));
}
}
differences.Sort();
if (differences.Count != 1)
{
if (differences.Count % 2 == 0)
{
median = differences[differences.Count / 2];
}
else
{
int half = (differences.Count - 1) / 2;
median = (differences[half] + differences[half + 1]) / 2;
}
}
else
{
median = differences[0];
}
}
else
{
median = bordered[0];
}
freq[i] = Convert.ToInt32((this.SampleRate / data[i].Length) * median);
}
this.FourierFreq = freq;
}
catch (Exception e)
{
Notify.Error(e.Message);
}
}
