public static fftw_plan dft_c2r(int rank, int[] n, fftw_complexarray input, fftw_complexarray output, fftw_direction direction, fftw_flags flags) { fftw_plan p = new fftw_plan(); p.handle = fftw.dft_c2r(rank, n, input.Handle, output.Handle, flags); return(p); }
public static fftw_plan r2r_2d(int nx, int ny, fftw_complexarray input, fftw_complexarray output, fftw_kind kindx, fftw_kind kindy, fftw_flags flags) { fftw_plan p = new fftw_plan(); p.handle = fftw.r2r_2d(nx, ny, input.Handle, output.Handle, kindx, kindy, flags); return(p); }
public static fftw_plan dft_r2c_2d(int nx, int ny, fftw_complexarray input, fftw_complexarray output, fftw_flags flags) { fftw_plan p = new fftw_plan(); p.handle = fftw.dft_r2c_2d(nx, ny, input.Handle, output.Handle, flags); return(p); }
public static fftw_plan dft_c2r_3d(int nx, int ny, int nz, fftw_complexarray input, fftw_complexarray output, fftw_direction direction, fftw_flags flags) { fftw_plan p = new fftw_plan(); p.handle = fftw.dft_c2r_3d(nx, ny, nz, input.Handle, output.Handle, flags); return(p); }
//Complex<->Complex transforms public static fftw_plan dft_1d(int n, fftw_complexarray input, fftw_complexarray output, fftw_direction direction, fftw_flags flags) { fftw_plan p = new fftw_plan(); p.handle = fftw.dft_1d(n, input.Handle, output.Handle, direction, flags); return(p); }
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(); }
public static fftw_plan r2r(int rank, int[] n, fftw_complexarray input, fftw_complexarray output, fftw_kind[] kind, fftw_flags flags) { fftw_plan p = new fftw_plan(); p.handle = fftw.r2r(rank, n, input.Handle, output.Handle, kind, flags); return(p); }
public static fftw_plan dft_3d(int nx, int ny, int nz, fftw_complexarray input, fftw_complexarray output, fftw_direction direction, fftw_flags flags) { FFTW_Semaphore.WaitOne(); fftw_plan p = new fftw_plan(); p.handle = fftw.dft_3d(nx, ny, nz, input.Handle, output.Handle, direction, flags); FFTW_Semaphore.Release(); return(p); }
public static fftw_plan dft_r2c_3d(int nx, int ny, int nz, fftw_complexarray input, fftw_complexarray output, fftw_flags flags) { FFTW_Lock.WaitOne(); fftw_plan p = new fftw_plan(); p.handle = fftw.dft_r2c_3d(nx, ny, nz, input.Handle, output.Handle, flags); FFTW_Lock.ReleaseMutex(); return(p); }
public static fftw_plan dft_c2r(int rank, int[] n, fftw_complexarray input, fftw_complexarray output, fftw_direction direction, fftw_flags flags) { FFTW_Lock.WaitOne(); fftw_plan p = new fftw_plan(); p.handle = fftw.dft_c2r(rank, n, input.Handle, output.Handle, flags); FFTW_Lock.ReleaseMutex(); return(p); }
public static fftw_plan r2r_2d(int nx, int ny, fftw_complexarray input, fftw_complexarray output, fftw_kind kindx, fftw_kind kindy, fftw_flags flags) { FFTW_Lock.WaitOne(); fftw_plan p = new fftw_plan(); p.handle = fftw.r2r_2d(nx, ny, input.Handle, output.Handle, kindx, kindy, flags); FFTW_Lock.ReleaseMutex(); return(p); }
// 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); }
/// <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 fftw_plan r2r(int rank, int[] n, fftw_complexarray input, fftw_complexarray output, fftw_kind[] kind, fftw_flags flags) { fftw_plan p = new fftw_plan(); p.handle = fftw.r2r(rank, n, input.Handle, output.Handle, kind, flags); return p; }
//Real<->Real public static fftw_plan r2r_1d(int n, fftw_complexarray input, fftw_complexarray output, fftw_kind kind, fftw_flags flags) { fftw_plan p = new fftw_plan(); p.handle = fftw.r2r_1d(n, input.Handle, output.Handle, kind, flags); return p; }
public static fftw_plan dft_r2c(int rank, int[] n, fftw_complexarray input, fftw_complexarray output, fftw_flags flags) { fftw_plan p = new fftw_plan(); p.handle = fftw.dft_r2c(rank, n, input.Handle, output.Handle, flags); return p; }
public static fftw_plan dft_r2c_3d(int nx, int ny, int nz, fftw_complexarray input, fftw_complexarray output, fftw_flags flags) { fftw_plan p = new fftw_plan(); p.handle = fftw.dft_r2c_3d(nx, ny, nz, input.Handle, output.Handle, flags); return p; }
public static fftw_plan dft_3d(int nx, int ny, int nz, fftw_complexarray input, fftw_complexarray output, fftw_direction direction, fftw_flags flags) { FFTW_Semaphore.WaitOne(); fftw_plan p = new fftw_plan(); p.handle = fftw.dft_3d(nx, ny, nz, input.Handle, output.Handle, direction,flags); FFTW_Semaphore.Release(); return p; }
public static fftw_plan dft_c2r_2d(int nx, int ny, fftw_complexarray input, fftw_complexarray output, fftw_direction direction, fftw_flags flags) { fftw_plan p = new fftw_plan(); p.handle = fftw.dft_c2r_2d(nx, ny, input.Handle, output.Handle, flags); return p; }
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> /// Sharp bitmap with the Fastest Fourier Transform /// </summary> /// <returns>Sharped bitmap</returns> private double[, ,] Sharp(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(); Complex level = complex[0]; 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(); complex[0] = level; 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; }
public static fftw_plan r2r_3d(int nx, int ny, int nz, fftw_complexarray input, fftw_complexarray output, fftw_kind kindx, fftw_kind kindy, fftw_kind kindz, fftw_flags flags) { FFTW_Lock.WaitOne(); fftw_plan p = new fftw_plan(); p.handle = fftw.r2r_3d(nx, ny, nz, input.Handle, output.Handle, kindx, kindy, kindz, flags); FFTW_Lock.ReleaseMutex(); return p; }
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 fftw_plan r2r(int rank, int[] n, fftw_complexarray input, fftw_complexarray output, fftw_kind[] kind, fftw_flags flags) { FFTW_Lock.WaitOne(); fftw_plan p = new fftw_plan(); p.handle = fftw.r2r(rank, n, input.Handle, output.Handle, kind, flags); FFTW_Lock.ReleaseMutex(); return p; }
public static fftw_plan dft_r2c_2d(int nx, int ny, fftw_complexarray input, fftw_complexarray output, fftw_flags flags) { FFTW_Lock.WaitOne(); fftw_plan p = new fftw_plan(); p.handle = fftw.dft_r2c_2d(nx, ny, input.Handle, output.Handle, flags); FFTW_Lock.ReleaseMutex(); return p; }
/// <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 static fftw_plan r2r_3d(int nx, int ny, int nz, fftw_complexarray input, fftw_complexarray output, fftw_kind kindx, fftw_kind kindy, fftw_kind kindz, fftw_flags flags) { fftw_plan p = new fftw_plan(); p.handle = fftw.r2r_3d(nx, ny, nz, input.Handle, output.Handle, kindx, kindy, kindz, flags); return p; }
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; }
//Complex->Real public static fftw_plan dft_c2r_1d(int n, fftw_complexarray input, fftw_complexarray output, fftw_direction direction, fftw_flags flags) { FFTW_Lock.WaitOne(); fftw_plan p = new fftw_plan(); p.handle = fftw.dft_c2r_1d(n, input.Handle, output.Handle, flags); FFTW_Lock.ReleaseMutex(); return p; }
private double[] DoFFT(double[] signalHisto) { //Stopwatch timer = new Stopwatch(); //timer.Start(); //long inittime, ffttime, histocalctime; double[] fourierHisto = new double[sampLength/2]; fftw_complexarray fourierComplex = new fftw_complexarray(sampLength); GCHandle fin = GCHandle.Alloc(signalHisto, GCHandleType.Pinned); IntPtr fout = fourierComplex.Handle; //inittime = timer.ElapsedTicks; IntPtr plan = fftw.dft_r2c(1, new int[] { sampLength }, fin.AddrOfPinnedObject(), fout, fftw_flags.Estimate); fftw.execute(plan); //ffttime = timer.ElapsedTicks - inittime; //Managed FFT /* fftw_complexarray signalComplex = new fftw_complexarray(signalHisto); // Make input complexarray from signalHisto fftw_complexarray fourierComplex = new fftw_complexarray(sampLength * 2); // Make new output complexarray fftw_plan mplan = fftw_plan.dft_r2c_1d(sampLength, signalComplex, fourierComplex, fftw_flags.Estimate); mplan.Execute(); */ double[] fourierOut = fourierComplex.GetData_double(); double re, im; for (int i = 0; i < sampLength / 2; i++) { re = fourierOut[2 * i]; im = fourierOut[2 * i + 1]; fourierHisto[i] = Math.Sqrt(re * re + im * im); } //histocalctime = timer.ElapsedTicks - inittime - ffttime; //timer.Stop(); //Console.WriteLine(String.Format("{0} - {1} - {2}", 100 * inittime / timer.ElapsedTicks, 100 * ffttime / timer.ElapsedTicks, 100* histocalctime / timer.ElapsedTicks)); return fourierHisto; }