public Spectrogram(float[] sound)
{
Sound = sound;
complexInput = new Complex[sound.Length];
for (int i = 0; i < complexInput.Length; i++)
{
Complex tmp = new Complex(Sound[i], 0);
complexInput[i] = tmp;
}
Fourier.BluesteinForward(complexInput, FourierOptions.NoScaling);
//Fourier.Forward(complexInput);
//Do something
//Fourier.BluesteinInverse(complexInput, MathNet.Numerics.IntegralTransforms.FourierOptions.Default);
float[] outSamples = new float[complexInput.Length];
for (int i = 0; i < outSamples.Length; i++)
{
outSamples[i] = (float)complexInput[i].Real;
}
Console.WriteLine(outSamples[0]);
}
/// <summary>
/// Compute a FFT (Fast Fourier Transform).
/// </summary>
/// <param name="real">An array of real values to calculate the FFT from.</param>
/// <returns>An array of complex data (real amplitude and imaginary phase) or "FAILED".
/// For each complex pair the index is the real part and the value is the imaginary part.</returns>
public static Primitive FFTForward(Primitive real)
{
try
{
Type PrimitiveType = typeof(Primitive);
Dictionary <Primitive, Primitive> dataMap;
dataMap = (Dictionary <Primitive, Primitive>)PrimitiveType.GetField("_arrayMap", BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.IgnoreCase | BindingFlags.Instance).GetValue(real);
int length = dataMap.Count;
Complex[] complex = new Complex[length];
int i = 0;
foreach (KeyValuePair <Primitive, Primitive> kvp in dataMap)
{
double realData = double.Parse(kvp.Value);
complex[i++] = new Complex(realData, 0);
}
Fourier.BluesteinForward(complex, FourierOptions.Default);
string result = "";
for (i = 0; i < length; i++)
{
result += (i + 1).ToString() + "=" + (complex[i].Real.ToString(CultureInfo.InvariantCulture) + "\\=" + complex[i].Imaginary.ToString(CultureInfo.InvariantCulture) + "\\;") + ";";
}
return(Utilities.CreateArrayMap(result));
}
catch (Exception ex)
{
Utilities.OnError(Utilities.GetCurrentMethod(), ex);
return("FAILED");
}
}
public void FourierBluesteinIsReversible(FourierOptions options)
{
var samples = Generate.RandomComplex(0x7FFF, GetUniform(1));
var work = new Complex[samples.Length];
samples.CopyTo(work, 0);
Fourier.BluesteinForward(work, options);
Assert.IsFalse(work.ListAlmostEqual(samples, 6));
Fourier.BluesteinInverse(work, options);
AssertHelpers.AlmostEqual(samples, work, 10);
}
public void Forward(Complex[] samples, FourierTransformScaling scaling)
{
switch (scaling)
{
case FourierTransformScaling.SymmetricScaling:
Fourier.BluesteinForward(samples, FourierOptions.Default);
break;
case FourierTransformScaling.ForwardScaling:
// Only backward scaling can be expressed with options, hence the double-inverse
Fourier.BluesteinInverse(samples, FourierOptions.AsymmetricScaling | FourierOptions.InverseExponent);
break;
default:
Fourier.BluesteinForward(samples, FourierOptions.NoScaling);
break;
}
}
/// <summary>
/// tekee Fourier-muunnoksen
/// </summary>
/// <returns></returns>
private List <DataPoint> FFT(List <DataPoint> list, double setfreq, bool autosample, LineSeries series1)
{
int N = list.Count;
double L = Math.Abs(list[0].X - list[N - 1].X);
double Fs = 1000; ///Sampling frequency
if (setfreq != 0)
{
Fs = (double)setfreq;
}
if (autosample)
{
Fs = N / L * 1000.0;
}
Complex[] samples = new Complex[N];
for (int i = 0; i < N; i++)
{
samples[i] = new Complex((float)list[i].Y, 0);
}
Fourier.BluesteinForward(samples, FourierOptions.Default); ///FFT
List <DataPoint> tulos = new List <DataPoint>();
double[] freq = new double[N / 2];
for (int j = 0; j < N / 2; j++)
{
freq[j] = Fs * j / L;
}
for (int i = 1; i < N / 2; i++)
{
tulos.Add(new DataPoint(freq[i], Math.Abs(samples[i].Real) / L));
}
series1.XAxis.Title = "Frequency(Hz)";
series1.YAxis.Title = "Amplitude";
series1.LineStyle = LineStyle.Solid;
return(tulos);
}
private static double[] RunRoy1(double [] signal_real, int chop_size)
{
Complex [] signal = MakeComplex(signal_real);
Complex[][] signals = ChopWindow(signal, chop_size);
//ImageRaster3D<float> image = new ImageRaster3D<float>( signals.Length, chop_size, 1);
double[] speed = new double[signals.Length];
double[] FrequencyScale = Fourier.FrequencyScale(chop_size, 30);
for (int singal_index = 0; singal_index < signals.Length; singal_index++)
{
Fourier.BluesteinForward(signals[singal_index], FourierOptions.Matlab);
double[] magnitude = SelectMagnitude(signals[singal_index]);
//for (int element_index = 0; element_index < magnitude.Length /2; element_index++)
//{
// image.SetElementValue(singal_index, element_index, 0, (float)magnitude[element_index]);
//}
speed[singal_index] = magnitude[1] * FrequencyScale[1] + magnitude[2] * FrequencyScale[2] + magnitude[3] * FrequencyScale[3] + magnitude[4] * FrequencyScale[4];
//Console.WriteLine(speed);
}
//Fourier.BluesteinForward(signal, FourierOptions.Default);
//Console.WriteLine(ToolsCollection.ToString(FrequencyScale));
return(speed);
//RendererImageRaster3DToBitmapZMIP<float> renderer_histogram = new RendererImageRaster3DToBitmapZMIP<float>(new FunctionFloat32ToColorASIST(0, 1), new ComparerNatural<float>());
//renderer_histogram.Render(image).Save(@"D:\Dropbox\TestData\ML6\data_3.png", ImageFormat.Png);
}
