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;
}
