private void CopyFromDomain()
{
var audioBuffer = _gameBoy.APU.Buffer;
var sampleCount = _gameBoy.APU.SampleCount;
var complexBuffer = new Complex[_fftSize * 2];
var index = 0;
var originalIndex = 0;
foreach (var value in audioBuffer)
{
if (originalIndex % 2 == 0)
{
if (index >= sampleCount)
{
complexBuffer[index] = new Complex(0, 0);
}
else
{
complexBuffer[index] = new Complex(value, 0);
}
index++;
if (index == _fftSize * 2)
{
break;
}
}
originalIndex++;
}
FourierTransform.FFT(complexBuffer, FourierTransform.Direction.Forward);
CopyFFTToFrameColumn(complexBuffer);
Utils.TransferBytesToWriteableBitmap(_spectrogram, _spectrogramData);
}
protected BSDataObject ProcessUsingFourierDirection(BSDataObject iObject, FourierTransform.Direction iDir)
{
Complex[] complexDataArray = (from tmp in iObject.DataArray select new Complex(tmp, 0)).ToArray();
FourierTransform.DFT(complexDataArray, iDir);
double[] resultingArray = (from tmp in complexDataArray select Math.Sqrt(tmp.Re * tmp.Re + tmp.Im * tmp.Im)).ToArray();
return(new BSDataObject(resultingArray, iObject.ObjName + "_Fouirer"));
}
public void ReverseBitPasses()
{
Assert.AreEqual(0, FourierTransform.ReverseBit(0, 8));
Assert.AreEqual(4, FourierTransform.ReverseBit(1, 8));
Assert.AreEqual(2, FourierTransform.ReverseBit(2, 8));
Assert.AreEqual(6, FourierTransform.ReverseBit(3, 8));
Assert.AreEqual(1, FourierTransform.ReverseBit(4, 8));
Assert.AreEqual(5, FourierTransform.ReverseBit(5, 8));
Assert.AreEqual(3, FourierTransform.ReverseBit(6, 8));
Assert.AreEqual(7, FourierTransform.ReverseBit(7, 8));
Assert.AreEqual(0, FourierTransform.ReverseBit(0, 16));
Assert.AreEqual(8, FourierTransform.ReverseBit(1, 16));
Assert.AreEqual(4, FourierTransform.ReverseBit(2, 16));
Assert.AreEqual(12, FourierTransform.ReverseBit(3, 16));
Assert.AreEqual(2, FourierTransform.ReverseBit(4, 16));
Assert.AreEqual(10, FourierTransform.ReverseBit(5, 16));
Assert.AreEqual(6, FourierTransform.ReverseBit(6, 16));
Assert.AreEqual(14, FourierTransform.ReverseBit(7, 16));
Assert.AreEqual(1, FourierTransform.ReverseBit(8, 16));
Assert.AreEqual(9, FourierTransform.ReverseBit(9, 16));
Assert.AreEqual(5, FourierTransform.ReverseBit(10, 16));
Assert.AreEqual(13, FourierTransform.ReverseBit(11, 16));
Assert.AreEqual(3, FourierTransform.ReverseBit(12, 16));
Assert.AreEqual(11, FourierTransform.ReverseBit(13, 16));
Assert.AreEqual(7, FourierTransform.ReverseBit(14, 16));
Assert.AreEqual(15, FourierTransform.ReverseBit(15, 16));
}
private void TransformMethod()
{
if (SelectedSignal != null)
{
SampledSignal signal = new SampledSignal();
signal.PointsY = SelectedSignal.PointsY;
signal.Name = $"{SelectedSignal.Name} {SelectedTransform}";
Stopwatch timer = new Stopwatch();
timer.Start();
switch (SelectedTransform.Substring(1, 4))
{
case "F1.1":
signal.ComplexPoints = FourierTransform.Transform(signal.PointsY);
break;
case "F1.2":
FastFourierTransform fourierTransform = new FastFourierTransform();
signal.ComplexPoints = fourierTransform.Transform(signal.PointsY);
break;
case "F1.3":
signal.ComplexPoints = WaveletTransform.Transform(signal.PointsY);
break;
}
timer.Stop();
Time = timer.ElapsedMilliseconds;
SignalCreator.AddSignal(signal);
}
}
//public int[] FFT(int[] y)
public async Task <int[]> FFT(int[] y)
{
WvlLogger.Log(LogType.TraceAll, "FFT()");
var input = new AForge.Math.Complex[y.Length];
for (int i = 0; i < y.Length; i++)
{
input[i] = new AForge.Math.Complex(y[i], 0);
}
FourierTransform.FFT(input, FourierTransform.Direction.Forward);
var result = new int[y.Length / 2];
// getting magnitude
for (int i = 0; i < y.Length / 2 - 1; i++)
{
var current = Math.Sqrt(input[i].Re * input[i].Re + input[i].Im * input[i].Im);
current = Math.Log10(current) * 10;
result[i] = (int)current;
}
samplesUpdated(this, new SamplesUpdatedEventArgs(result));
//PrepareHeatmapDataSeries(result);
return(result);
}
private void OnDataReceiverEvent(int[] real, int[] imaginary, int length, rx_metadata_t md)
{
if (length < numberOfPoints) // Insufficient data for FFT
{
return;
}
for (int i = 0; i < numberOfPoints; i++)
{
data[i] = new AForge.Math.Complex(real[i], imaginary[i]);
}
FourierTransform.FFT(data, FourierTransform.Direction.Forward);
int count = 0;
for (int i = numberOfPoints / 2; i < numberOfPoints; i++)
{
testValues[i, 1] = data[count++].Magnitude;
}
for (int i = 0; i < numberOfPoints / 2; i++)
{
testValues[i, 1] = data[count++].Magnitude;
}
chart.UpdateDataSeries("Test", testValues);
//chart.RangeY = new AForge.Range(0, 2048);
}
public static float[] ConvertWav2FFTMag(string wavfile, string outfile)
{
WAVFile audioFile = new WAVFile();
String warning = audioFile.Open(wavfile, WAVFile.WAVFileMode.READ);
Complex[] indata = new Complex[MaxSamples];
int IterSamples = (audioFile.NumSamples < MaxSamples) ? audioFile.NumSamples : MaxSamples;
float[] indata_mag = null;
if (warning == "")
{
//short audioSample = 0;
for (int sampleNum = 0; sampleNum < IterSamples; ++sampleNum)
{
//audioSample = audioFile.GetNextSampleAs16Bit();
indata[sampleNum].Re = audioFile.GetNextSampleAs16Bit();
}
FourierTransform.FFT(indata, FourierTransform.Direction.Forward);
indata_mag = GetMagnitude(indata);
if (outfile != null)
{
WriteData(indata_mag, outfile);
}
}
audioFile.Close();
return(indata_mag);
}
// Moution Blur....................................
public static ByteBitmap WienerFilterFromMoution(ByteBitmap aBitmap, float Length, int Angle, float Nsr)
{
//make fft from abitmap
Point lStart;
ByteBitmap lLoc = FFTHelpers.FitByteBitmapForFFT2D(aBitmap, 10, out lStart, 255);
Complex[,] lFx = FFTHelpers.ByteBitmapToComplex(lLoc);
FourierTransform.FFT2(lFx, FourierTransform.Direction.Forward);
//make moution FFT
Complex[,] lHx = GetMotionComplexImage(new Size(lLoc.Width, lLoc.Height), Angle, Length);
FourierTransform.FFT2(lHx, FourierTransform.Direction.Forward);
//make wiener
Complex[,] lWR = WienerFilter(lFx, lHx, Nsr);
//backward result
FourierTransform.FFT2(lWR, FourierTransform.Direction.Backward);
//convert to bytebitmap
ByteBitmap lRes = FFTHelpers.ComplexToByteBitmap(lWR);
lRes = FFTHelpers.GetFittedByteBitmapFromFFT2D(lRes, lStart, new Size(aBitmap.Width, aBitmap.Height));
return(lRes);
}
public Form1()
{
InitializeComponent();
Bitmap bmp = Bitmap.FromFile("lenagr.png") as Bitmap;
pictureBox1.Image = bmp;
Complex[,] cImage = ToComplex(bmp);
for (int y = 0; y < cImage.GetLength(1); y++)
{
for (int x = 0; x < cImage.GetLength(0); x++)
{
if (((x + y) & 0x1) != 0)
{
double real = cImage[y, x].Real * (-1);
double imaginary = cImage[y, x].Imaginary * (-1);
cImage[y, x] = new Complex(real, imaginary);
}
}
}
FourierTransform.FFT2(cImage, FourierTransform.Direction.Forward);
double[,] intImage = ToDouble(cImage);
intImage = Limit(intImage);
Bitmap bmpMagImg = ToBitmap(intImage, PixelFormat.Format24bppRgb);
pictureBox2.Image = bmpMagImg;
}
private void button9_Click(object sender, EventArgs e)
{
var tmp = TestImageGenerator.GetTestPair(size0, size1, 5, 15);
image = tmp.Item1.images[0];
image_res = tmp.Item2;
fft_image = Complex.CreateComplexArray(image);
FourierTransform.FFT2(fft_image, FourierTransform.Direction.Forward);
CreateHilbertFilter();
Complex.ApplyFilter(fft_image, filter_image);
FourierTransform.FFT2(fft_image, FourierTransform.Direction.Backward);
image = Tools.CalculatePhaseImageByHilbert(fft_image);
unwrapper.UpdateParamsIfNeed(image);
unwrapper.UnwrapParallel(image, out var scr);
ImageSource.subtract_min(image);
ImageSource.subtract_min(image_res);
var d = ImageSource.diff(image, image_res);
label1.Text = Math.Round(ImageSource.max(d), 5).ToString();;
label2.Text = Math.Round(ImageSource.min(d), 5).ToString();;
label3.Text = Math.Round(ImageSource.std(image, image_res), 5).ToString();;
label1.Update();
label2.Update();
label3.Update();
plot(d);
}
/// <summary>
/// Two dimensional Fast Fourier Transform.
/// </summary>
///
/// <param name="data">Data to transform.</param>
/// <param name="direction">Transformation direction.</param>
///
/// <remarks><para><note>The method accepts <paramref name="data"/> array of 2<sup>n</sup> size
/// only in each dimension, where <b>n</b> may vary in the [1, 14] range. For example, 16x16 array
/// is valid, but 15x15 is not.</note></para></remarks>
///
/// <exception cref="ArgumentException">Incorrect data length.</exception>
///
public static void FFT2(Complex[,] data, Direction direction)
{
int k = data.GetLength(0);
int n = data.GetLength(1);
// check data size
//if (
// (!Tools.IsPowerOf2(k)) ||
// (!Tools.IsPowerOf2(n)) ||
// (k < minLength) || (k > maxLength) ||
// (n < minLength) || (n > maxLength)
// )
if (
(!Tools.IsPowerOf2(k)) ||
(!Tools.IsPowerOf2(n)) ||
(k < minLength) || (k > maxLength) ||
(n < minLength) || (n > maxLength)
)
{
throw new ArgumentException("Incorrect data length.");
}
// process rows
Complex[] row = new Complex[n];
for (int i = 0; i < k; i++)
{
// copy row
for (int j = 0; j < n; j++)
{
row[j] = data[i, j];
}
// transform it
FourierTransform.FFT(row, direction);
// copy back
for (int j = 0; j < n; j++)
{
data[i, j] = row[j];
}
}
// process columns
Complex[] col = new Complex[k];
for (int j = 0; j < n; j++)
{
// copy column
for (int i = 0; i < k; i++)
{
col[i] = data[i, j];
}
// transform it
FourierTransform.FFT(col, direction);
// copy back
for (int i = 0; i < k; i++)
{
data[i, j] = col[i];
}
}
}
private void bPFilterButton_Click(object sender, EventArgs e)
{
try
{
int threshold0 = (int)bPFilterNnumericUpDown0.Value;
int threshold1 = (int)bPFilterNumericUpDown1.Value;
if (bPFilterComboBox.Text == "Гц")
{
threshold0 = (int)(threshold0 / (signal.Hz / signal.Count));
threshold1 = (int)(threshold1 / (signal.Hz / signal.Count));
}
FilterType type = GetFourierTransformType();
double[] preparedData = FiltersUtils.PrepareDataToFilter(signal.Data, type);
var filteredData = FourierTransform.BPFilter(preparedData, threshold0, threshold1, type);
if (saveToFileCheckBox.Checked)
{
WriteDataToFile(filteredData);
}
var form = new ShowChartForm(filteredData, filePath + " полосовой фильтр", signal.Type, signal.Hz);
form.Show();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Ошибка!", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private void BuildAudioInChain(WaveFormat monoFormat)
{
filter = new ComplexFilter(
monoFormat,
new BlackmanHarrisWindowFunction(),
new FirFilter());
filter.Filters.Add(new DigitalFilter
{
FilterFunction = new LowPassFilterFunction(),
LowerCutOffFrequency = 10000f
});
filterNode = new MonoSignalNode(monoFormat, filter.FilterImplementation);
fourier = new FourierTransform(
new FastFourierTransformProvider(),
new BlackmanHarrisWindowFunction(),
2048);
fourierNode = new MonoSignalNode(monoFormat, fourier);
fourier.DataReady += fourierControl.fourier_DataReady;
flanger = new Flanger(new SineWave());
flangerNode = new MonoSignalNode(monoFormat, flanger);
flangerNode.CentreIn.Source = asioInput.Sources.First();
//flangerNode.CentreIn.Source = waveCard.Inputs.First();
filterNode.CentreIn.Source = flangerNode.CentreOut;
fourierNode.CentreIn.Source = filterNode.CentreOut;
asioOutput.Sinks.ElementAt(0).Source = filterNode.CentreOut;
asioOutput.Sinks.ElementAt(1).Source = filterNode.CentreOut;
//waveCard.Outputs.ElementAt(0).Source = filterNode.CentreOut;
//waveCard.Outputs.ElementAt(1).Source = filterNode.CentreOut;
}
public static WriteableBitmap MakeFFT(WriteableBitmap image)
{
Complex[,] grayImage = ToGrayScale(image);
FourierTransform.FFT2(grayImage, FourierTransform.Direction.Forward);
return(ComplexToMagnitude(grayImage, image.PixelHeight));
}
/// <summary>
/// Calculates the fourier transforms and updates the axis scales.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void BackgroundWorker_CalculateFourierTransforms(object sender, DoWorkEventArgs e)
{
BackgroundWorker worker = (BackgroundWorker)sender;
float[] pidFFTW = FourierTransform.CalculateFFTW(PIDOutput.ToArray());
float[] adrcFFTW = FourierTransform.CalculateFFTW(ADRCOutput.ToArray());
float[] pidAngleFFTW = FourierTransform.CalculateFFTW(PIDAngle.ToArray());
float[] adrcAngleFFTW = FourierTransform.CalculateFFTW(ADRCAngle.ToArray());
this.BeginInvoke((Action)(() =>
{
double pidMax, adrcMax;
pidMax = pidMaxValue.Filter((pidFFTW.Max() + Math.Abs(pidFFTW.Min())) / 2);
adrcMax = adrcMaxValue.Filter((adrcFFTW.Max() + Math.Abs(adrcFFTW.Min())) / 2);
pidScale.Text = "PID Scale: " + pidMax;
adrcScale.Text = "ADRC Scale: " + adrcMax;
chart3.ChartAreas[0].AxisY.Maximum = pidMax;
chart3.ChartAreas[0].AxisY.Minimum = -pidMax;
chart4.ChartAreas[0].AxisY.Maximum = adrcMax;
chart4.ChartAreas[0].AxisY.Minimum = -adrcMax;
}));
e.Result = new float[4][] { pidFFTW, adrcFFTW, pidAngleFFTW, adrcAngleFFTW };
}
static void Main(string[] args)
{
test1();
CaculateTimes caculate = new CaculateTimes();
caculate.StartTime();
//4 3 2 6 7 8 9 0
int[] nums = { 4, 3, 2, 6, 7, 8, 9, 0 };
int[] nums_2 = { 1, 2, 5, 4, 8, 6, 4, 5, 2, 3, 1 };
Complex[] complices = new Complex[nums.Length];
for (int i = 0; i < nums.Length; i++)
{
complices[i] = new Complex(nums[i], 0);
}
FourierTransform.DFT(complices, FourierTransform.Direction.Backward);
for (int i = 0; i < nums.Length; i++)
{
Console.WriteLine(complices[i].Re + " " + complices[i].Im);
}
Console.WriteLine();
Console.WriteLine("====================");
Console.WriteLine();
for (int i = 0; i < nums.Length; i++)
{
complices[i].Re = nums[i];
complices[i].Im = 0;
}
FourierTransform.FFT(complices, FourierTransform.Direction.Backward);
for (int i = 0; i < nums.Length; i++)
{
Console.WriteLine(complices[i].Re + " " + complices[i].Im);
}
Console.WriteLine(caculate.EndTime());
Console.ReadKey();
}
internal unsafe static Image <Complex, TDepth> FFT <TDepth>(this Image <Complex, TDepth> image, FourierTransform.Direction direction, bool inPlace = false)
where TDepth : struct
{
Image <Complex, TDepth> dest = null;
if (inPlace)
{
dest = image;
}
else
{
dest = image.Clone();
}
if (typeof(TDepth).Equals(typeof(float)))
{
FourierTransform.FFT2((ComplexF *)dest.ImageData, dest.Width, dest.Height, dest.Stride, direction);
}
else if (typeof(TDepth).Equals(typeof(double)))
{
throw new NotImplementedException(); //TODO: implement for double
//FourierTransform.FFT2((Complex*)dest.ImageData, dest.Width, dest.Height, dest.Stride, direction);
}
else
{
throw new NotSupportedException();
}
return(dest);
}
public static double[] Transform(double[] functionPoints, string transformate)
{
var copyofFunctionsPoints = functionPoints;
switch (transformate)
{
case "FFT":
var complexArray = Array.ConvertAll(copyofFunctionsPoints, x => new Complex(x, 0));
FourierTransform.DFT(complexArray, FourierTransform.Direction.Forward);
copyofFunctionsPoints = Array.ConvertAll(complexArray, z => z.Real);
break;
case "IFFT":
var complexArray2 = Array.ConvertAll(copyofFunctionsPoints, x => new Complex(x, 0));
FourierTransform.DFT(complexArray2, FourierTransform.Direction.Backward);
copyofFunctionsPoints = Array.ConvertAll(complexArray2, z => z.Real);
break;
case "DST":
SineTransform.DST(copyofFunctionsPoints);
break;
case "IDST":
SineTransform.IDST(copyofFunctionsPoints);
break;
case "DCT":
CosineTransform.DCT(copyofFunctionsPoints);
break;
case "IDCT":
CosineTransform.IDCT(copyofFunctionsPoints);
break;
case "DHT":
HartleyTransform.DHT(copyofFunctionsPoints);
break;
case "FHT":
HilbertTransform.FHT(copyofFunctionsPoints,
FourierTransform.Direction.Forward);
break;
case "IFHT":
HilbertTransform.FHT(copyofFunctionsPoints,
FourierTransform.Direction.Backward);
break;
default:
throw new ArgumentException("Unknown transformation!");
}
return(copyofFunctionsPoints); //athenia programuje//dididididi//di/kocham PaciA// JJKAKAKK K
}
public override void FFT(bool forward)
{
data.CopyTo(copy, 0);
FourierTransform.FFT(copy, forward ?
FourierTransform.Direction.Forward :
FourierTransform.Direction.Backward);
}
public (double[] real, double[] imaginary) CalculateDFT()
{
var data = GetComplexData().ToArray();
FourierTransform.DFT(data, FourierTransform.Direction.Forward);
return(data.Re(), data.Im());
}
public static void FastDFT(Complex[] x, int mode = 1)
{
var dir = FourierTransform.Direction.Forward;
if (mode == -1)
{
dir = FourierTransform.Direction.Backward;
}
FourierTransform.FFT(x, dir);
}
/// <summary>
/// Initializes short-time Fourier transform.
/// </summary>
/// <param name="function">Windows function</param>
/// <param name="normalized">Normalized transform or not</param>
/// <param name="direction">Processing direction</param>
public ShortTimeFourierTransform(IWindow function, bool normalized = true, Direction direction = Direction.Vertical)
{
// fourier transform initialization:
this.FFT = new FourierTransform(normalized, direction);
Direction = direction;
Window = function;
// sampling window function:
this.coefs = function.GetWindow().Add(1e-64f);
}
public void Proceed()
{
if (IsAllChecked())
{
PreviousMethod = CurrentMethod;
IsBuilded = true;
OutputString = "";
var InputSignal = ComplexConverter.FromList(Signal);
if (CurrentMethod == Methods.FFT)
{
if (IsForward)
{
Result = FourierTransform.ForwardFourierTransform(InputSignal);
}
else
{
Result = FourierTransform.InverseFourierTransform(InputSignal);
}
}
else
{
if (IsForward)
{
Result = FourierTransform.ForwardDiscreteFourierTransform(InputSignal);
}
else
{
Result = FourierTransform.InverseDiscreteFourierTransform(InputSignal);
}
}
foreach (var item in Result)
{
if (CurrentChartType == Charts.Signal)
{
OutputString += " " + item.ToString() + "\n";
}
else if (CurrentChartType == Charts.Magnitude)
{
OutputString += $" {item.Magnitude:F3}\n";
}
else if (CurrentChartType == Charts.Phase)
{
OutputString += $" {item.Phase:F3}\n";
}
}
BindSeries();
Output.Text = OutputString;
}
}
public void IFFTPasses()
{
var input = Enumerable.Range(0, 8)
.Select(_i => new Complex(SoundUtils.CalSinWave(_i, 0.25f, 250f, 8000), 0))
.ToArray();
var fft = new FourierTransform();
var output = fft.FFT(input);
var gots = fft.IFFT(output);
AssertionUtils.AreEqualComplexArray(input, gots, "逆変換に失敗しています", EPSILON);
}
/// <summary>
/// Performs the Fast Hilbert Transform over a double[] array.
/// </summary>
///
public static void FHT(double[] data, FourierTransform.Direction direction)
{
int N = data.Length;
// Forward operation
if (direction == FourierTransform.Direction.Forward)
{
// Copy the input to a complex array which can be processed
// in the complex domain by the FFT
Complex[] cdata = new Complex[N];
for (int i = 0; i < N; i++)
cdata[i].Re = data[i];
// Perform FFT
FourierTransform.FFT(cdata, FourierTransform.Direction.Forward);
//double positive frequencies
for (int i = 1; i < (N/2); i++)
{
cdata[i].Re *= 2.0;
cdata[i].Im *= 2.0;
}
// zero out negative frequencies
// (leaving out the dc component)
for (int i = (N/2)+1; i < N; i++)
{
cdata[i].Re = 0.0;
cdata[i].Im = 0.0;
}
// Reverse the FFT
FourierTransform.FFT(cdata, FourierTransform.Direction.Backward);
// Convert back to our initial double array
for (int i = 0; i < N; i++)
data[i] = cdata[i].Im;
}
else // Backward operation
{
// The inverse Hilbert can be calculated by
// negating the transform and reapplying the
// transformation.
//
// H^–1{h(t)} = –H{h(t)}
FHT(data, FourierTransform.Direction.Forward);
for (int i = 0; i < data.Length; i++)
data[i] = -data[i];
}
}
public double[] Equalize(double[] gains, WavData wavData)
{
var n = FourierHelper.GetExpandedPow2(_windowLength + _filterLength - 1);
var size = wavData.Samples.Length + n - _windowLength;
var result = new double[size];
var windows = new double[size / _windowHopSize][];
var windowsComplex = new Complex[size / _windowHopSize][];
for (int i = 0; i < windows.Length; i++)
{
windows[i] = new double[n];
windowsComplex[i] = new Complex[n];
}
var windowFactors = _window.WindowFactors(_windowLength);
var gainsComplex = GenerateGains(gains, wavData.FormatChunk.SampleRate, n);
for (int i = 0; i < windows.Length; i++)
{
for (int j = 0; j < _windowLength; j++)
{
if (i * _windowHopSize + j < wavData.Samples.Length)
{
windows[i][j] = windowFactors[j] * wavData.Samples[i * _windowHopSize + j];
}
else
{
windows[i][j] = 0;
}
}
for (int j = _windowLength; j < n; j++)
{
windows[i][j] = 0;
}
windowsComplex[i] = FourierTransform.FFT(windows[i]);
windowsComplex[i] = AdjustGain(gainsComplex, windowsComplex[i]);
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 * _windowHopSize + j < wavData.Samples.Length)
{
result[i * _windowHopSize + j] += windows[i][j];
}
}
}
return(result);
}
/// <summary>
/// Converts a frame to log-power-spectrum bins.
/// </summary>
///
private double[] frame2logspec(params Int16[] p_frame)
{
double[] w_preEmp = pre_emphasis(p_frame);
double[] w_win = new double[m_win.Length];
for (int w_i = 0; w_i < m_win.Length; w_i++)
{
w_win[w_i] = m_win[w_i];
}
// Each frame has to be multiplied with a hamming window in order to keep
// the continuity of the first and the last points in the frame.
double[] w_frame = new double[w_win.Length];
for (int w_i = 0; w_i < w_win.Length; w_i++)
{
w_frame[w_i] = w_preEmp[w_i] * w_win[w_i];
}
Complex[] w_complexFrame = new Complex[m_nfft];
for (int w_i = 0; w_i < w_frame.Length && w_i < m_nfft; w_i++)
{
w_complexFrame[w_i] = w_frame[w_i];
}
for (int w_i = w_frame.Length; w_i < m_nfft; w_i++)
{
w_complexFrame[w_i] = 0;
}
// Compute the one-dimensional discrete Fourier Transform for real input.
FourierTransform.FFT(w_complexFrame, FourierTransform.Direction.Backward);
// Square of absolute value
double[] w_power = new double[m_nfft / 2 + 1];
for (int w_i = 0; w_i < m_nfft / 2 + 1; w_i++)
{
w_power[w_i] = w_complexFrame[w_i].Real * w_complexFrame[w_i].Real
+ w_complexFrame[w_i].Imaginary * w_complexFrame[w_i].Imaginary;
}
double[] w_dotMat = Matrix.Dot(w_power, m_filters);
double[] w_ret = new double[w_dotMat.Length];
for (int w_i = 0; w_i < w_ret.Length; w_i++)
{
if (w_dotMat[w_i] < 1.0f / 100000.0f)
{
w_ret[w_i] = System.Math.Log(1.0f / 100000.0f);
}
else
{
w_ret[w_i] = System.Math.Log(w_dotMat[w_i]);
}
}
return(w_ret);
}
/// <summary>
/// One dimensional Fast Fourier Transform.
/// </summary>
///
/// <param name="data">Data to transform.</param>
/// <param name="direction">Transformation direction.</param>
///
/// <remarks><para><note>The method accepts <paramref name="data"/> array of 2<sup>n</sup> size
/// only, where <b>n</b> may vary in the [1, 14] range.</note></para></remarks>
///
/// <exception cref="ArgumentException">Incorrect data length.</exception>
///
public static void FFT(Complex[] data, Direction direction)
{
int n = data.Length;
int m = Tools.Log2(n);
// reorder data first
ReorderData(data);
// compute FFT
int tn = 1, tm;
for (int k = 1; k <= m; k++)
{
Complex[] rotation = FourierTransform.GetComplexRotation(k, direction);
tm = tn;
tn <<= 1;
for (int i = 0; i < tm; i++)
{
Complex t = rotation[i];
for (int even = i; even < n; even += tn)
{
int odd = even + tm;
Complex ce = data[even];
Complex co = data[odd];
double tr = co.Real * t.Real - co.Imaginary * t.Imaginary;
double ti = co.Real * t.Imaginary + co.Imaginary * t.Real;
//data[even].Real+= tr;
//data[even].Imaginary += ti;
data[even] += new Complex(tr, ti);
//data[odd].Real= ce.Real- tr;
//data[odd].Imaginary = ce.Imaginary - ti;
data[odd] = new Complex((ce.Real - tr), (ce.Imaginary - ti));
}
}
}
if (direction == Direction.Forward)
{
for (int i = 0; i < n; i++)
{
//data[i].Real/= (double)n;
//data[i].Imaginary /= (double)n;
data[i] /= new Complex((double)n, (double)n);
}
}
}
public void FFT2_test1()
{
var tuple = TestImageGenerator.GetTestPair(1024, 1024, 4);
Complex[,] test_image = Complex.CreateComplexArray(tuple.Item1.images[0]);
FourierTransform.FFT2(test_image, FourierTransform.Direction.Forward);
Complex[,] reserv = (Complex[, ])test_image.Clone();
FourierTransform.FFT2(test_image, FourierTransform.Direction.Backward);
double[,] inverse_result = Complex.CreateDoubleArray(test_image);
double std = ImageSource.std(tuple.Item1.images[0], inverse_result);
Assert.IsTrue(std < ImageSource.mean(tuple.Item1.images[0]) / 1000);
}
public void TestOneSignal()
{
var data = new double[4096];
for (var i = 0; i < data.Length; i++)
{
var alpha = i * 180 / System.Math.PI;
var signal = System.Math.Cos(alpha) + 100;
data[i] = signal;
}
var ampls = FourierTransform.Transform(data);
}
/// <summary>
/// Applies backward fast Fourier transformation to the complex signal.
/// </summary>
///
public void BackwardFourierTransform()
{
if (status == ComplexSignalStatus.FourierTransformed)
{
for (int i = 0; i < Channels; i++)
{
Complex[] channel = GetChannel(i);
FourierTransform.FFT(channel, FourierTransform.Direction.Backward);
SetChannel(i, channel);
}
status = ComplexSignalStatus.Normal;
}
}
private void backToSpatialDomainToolStripMenuItem_Click(object sender, EventArgs e)
{
try
{
FourierTransform t = new FourierTransform();
ImageForm frmImg = new ImageForm(Facilities.ToImage(Facilities.ToBitmap(t.ApplyReverseTransform(_complex))));
frmImg.MdiParent = this.MdiParent;
frmImg.Show();
}
catch (Exception ex)
{
MessageBox.Show(ex.GetType().FullName, ex.Message);
}
}
/// <summary>
/// Performs the transformation over a complex[] array.
/// </summary>
///
public static void FHT(Complex[] data, FourierTransform.Direction direction)
{
int N = data.Length;
// Forward operation
if (direction == FourierTransform.Direction.Forward)
{
// Makes a copy of the data so we don't lose the
// original information to build our final signal
Complex[] shift = (Complex[])data.Clone();
// Perform FFT
FourierTransform.FFT(shift, FourierTransform.Direction.Backward);
//double positive frequencies
for (int i = 1; i < (N/2); i++)
{
shift[i].Re *= 2.0;
shift[i].Im *= 2.0;
}
// zero out negative frequencies
// (leaving out the dc component)
for (int i = (N/2)+1; i < N; i++)
{
shift[i].Re = 0.0;
shift[i].Im = 0.0;
}
// Reverse the FFT
FourierTransform.FFT(shift, FourierTransform.Direction.Forward);
// Put the Hilbert transform in the Imaginary part
// of the input signal, creating a Analytic Signal
for (int i = 0; i < N; i++)
data[i].Im = shift[i].Im;
}
else // Backward operation
{
// Just discard the imaginary part
for (int i = 0; i < data.Length; i++)
data[i].Im = 0.0;
}
}
private void fourierTransformToolStripMenuItem_Click(object sender, EventArgs e)
{
try
{
FourierTransform t = new FourierTransform();
FourierForm frm = new FourierForm(
t.ApplyTransform(
Facilities.To8bppGreyScale(
Facilities.ToBitmap(pictureBoxImage.Image))));
frm.MdiParent = MdiParent;
frm.Show();
}
catch (Exception ex)
{
MessageBox.Show(ex.GetType().FullName, ex.Message);
}
}
/// <summary>
///
/// </summary>
/// <param name="img"></param>
/// <param name="configs"></param>
/// <returns></returns>
public override byte[,] ApplyFilter(byte[,] img, SortedDictionary<string, object> configs)
{
byte[,] ret = null; FourierTransform ft = new FourierTransform();
// Preprocess image.
int width = img.GetLength(0), height = img.GetLength(1), x, y;
double[,] imgProcessed = new double[width, height];
const double magic = 0.5;
//double min = double.MaxValue;
//// Find min.
//for (x = 0; x < width; ++x)
//{
// for (y = 0; y < height; ++y)
// {
// min = Math.Min(img[x, y], min);
// }
//}
// "normalize"
for (x = 0; x < width; ++x)
{
for (y = 0; y < height; ++y)
{
imgProcessed[x, y] = Math.Log(img[x, y] + magic, Math.E);
}
}
// Take fourier transform.
ComplexImage homomorph = ft.ApplyTransformBase(imgProcessed);
// (x)(a) Perform butterworth high pass to select reflectance;
// perform butterworth low pass to select illuminance.
// **** OR ****
// (b) Apply butterworth-generated weigth to select reflectance (1.0 in center)
// Apply (1.0 - butterworth-generated weigth) to select illuminance (0.0 in center)
// **** OR ****
// (c) Apply high pass buttwerworth. only.
SortedDictionary<string, object> hConfigs = reflectGetter.GetDefaultConfigs();
hConfigs["D0"] = configs["Butterworth-D0"];
hConfigs["n"] = configs["Butterworth-n"];
ComplexImage reflect = reflectGetter.ApplyFilter(homomorph, hConfigs);
ComplexImage illumin = illuminGetter.ApplyFilter(homomorph, hConfigs);
// (1, 1) = imagem original
// (1, 0) = high pass
// (0, 1) = low pass
double alpha = double.Parse(configs["Alpha"].ToString());
double beta = double.Parse(configs["Beta"].ToString());
// Generate new, Homomorphic-treated image
//(c)
//homomorph = illumin;
// Split into reflectance and illuminance
// - Sharp reflectance, smooth illuminance
// - sum
for (x = 0; x < homomorph.Width; ++x)
{
for (y = 0; y < homomorph.Height; ++y)
{
//(a)
homomorph[x, y] = new Complex(
reflect[x, y].real * beta + // Reflectance part
illumin[x, y].real * alpha // Illuminance part
,
reflect[x, y].imag * beta + // Reflectance part
illumin[x, y].imag * alpha // Illuminance part
);
}
}
// ... back to spatial domain.
imgProcessed = ft.ApplyReverseTransformBase(homomorph);
// Pos-process image.
ret = new byte[width, height];
for (x = 0; x < width; ++x)
{
for (y = 0; y < height; ++y)
{
ret[x, y] = (byte)Math.Max(byte.MinValue, Math.Min(byte.MaxValue, Math.Exp(imgProcessed[x, y]) - magic));
}
}
return ret;
}
public double[] Extract(float[] frame, out bool isEmpty)
{
HammingWindowDef.HammingWindow hammingWindow;
if (!_hammingWindows.TryGetValue(frame.Length, out hammingWindow))
{
hammingWindow = new HammingWindowDef.HammingWindow(new HammingWindowDef(), frame.Length);
_hammingWindows.Add(frame.Length, hammingWindow);
}
var windowedSample = hammingWindow.Apply(frame);
FourierTransform ft = new FourierTransform();
var nummberOfCoeff = ft.ComputeFft(windowedSample, _numberOfFftCoeff);
double frameEnergy;
var result = ft.GetMagnitudeSquared(nummberOfCoeff, out frameEnergy);
if (_filterBankCoefficients == null)
{
_filterBankCoefficients = ComputeMelFilterBank(result.Length, _lowerfrequency, _higherfrequency,
_samplingRate, _numberOfFilterBanks + 2);
}
var cepstra = ApplyFilterbankFilter(result, _filterBankCoefficients);
var ret = _dct.Apply(cepstra);
ret[0] = Utils.Log(frameEnergy);
isEmpty = false;
return ret;
}