private void FillResultImages(Bitmap bitmap)
{
var phaseInterval = MathHelper.CalculateMinMax(ComplexData, Spectrum.Phase);
var magnitudeInterval = MathHelper.CalculateMinMax(ComplexData, Spectrum.Magnitude);
FourierHelper.SwapQuadrants(ComplexData);
using (var phaseBitmapData = new SingleBitmapData(bitmap, PixelFormat.Format8bppIndexed))
using (var magnitudeBitmapData = new SingleBitmapData(bitmap, PixelFormat.Format8bppIndexed))
{
for (int y = 0; y < phaseBitmapData.HeightInPixels; y++)
{
for (int x = 0;
x < phaseBitmapData.WidthInBytes;
x += phaseBitmapData.BytesPerPixel)
{
var index = x + y * phaseBitmapData.WidthInBytes;
phaseBitmapData.FirstPixelPtr[index] = (byte)FourierHelper.LogNormalize(ComplexData[y][x].Phase, phaseInterval.Max, 255);
magnitudeBitmapData.FirstPixelPtr[index] = (byte)FourierHelper.LogNormalize(ComplexData[y][x].Magnitude, magnitudeInterval.Max, 255);
}
}
PhaseImage = phaseBitmapData.Bitmap;
MagnitudeImage = magnitudeBitmapData.Bitmap;
}
FourierHelper.SwapQuadrants(ComplexData);
}
public static double[] IFFT(Complex[] complexData)
{
FourierHelper.Conjugate(complexData);
FFT1D(complexData);
FourierHelper.Conjugate(complexData);
return(complexData.Select(c => (c / complexData.Length).Real).ToArray());
}
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);
}
public static unsafe ImageComponents ProcessFourierImage(
ImageComponents imageComponents,
IProcessingFourierOperation fourierOperation)
{
var clonedData = CollectionHelper.Clone(imageComponents.ComplexData);
FourierHelper.SwapQuadrants(clonedData);
fourierOperation.ProcessImage(clonedData);
FourierHelper.SwapQuadrants(clonedData);
var processedData = CollectionHelper.Clone(clonedData);
var bitmap = FastFourierTransform.IFFT2D(processedData, imageComponents.Image);
return(new ImageComponents(clonedData, bitmap));
}
public void Test()
{
var points = GetComponent <PointsHolder>().Points;
//var interpolatedPoints = Data.drawing.Where((d, i) => i%10==0).Select(d => new ComplexNumber(d.x, -d.y)).ToList();
var interpolatedPoints = new List <ComplexNumber>();
for (var i = 0; i < takePoints; i++)
{
var v = GetComponent <PointsHolder>().GetPoint(i / (float)takePoints);
interpolatedPoints.Add(new ComplexNumber(v.x, v.y));
}
/*
* var interpolatedPoints = new List<ComplexNumber>(points.Count * 2);
* for (var i = 0; i < points.Count; i++)
* {
* interpolatedPoints.Add(points[i]);
* interpolatedPoints.Add((points[i] + points[(i + 1) % points.Count]) / 2f);
* }
*/
//var interpolatedPoints = GetComponent<PointsHolder>().Points;
res.Clear();
restored.Clear();
res.AddRange(FourierHelper.DFT(interpolatedPoints).OrderByDescending(d => d.amplitude));
for (var tn = 0; tn < 500; tn++)
{
var time = tn / 500f * 2f * Mathf.PI;
var pos = Vector2.zero;
for (var i = 0; i < res.Count; i++)
{
var t = res[i].frequency * time + res[i].phase;
pos += new Vector2(Mathf.Cos(t), Mathf.Sin(t)) * res[i].amplitude;
}
restored.Add(pos);
}
ExportString();
}
public List <Sound> Calculate(WavData wavData)
{
var frequencies = new List <Sound>();
for (int i = 0; i < wavData.ChunkedSamples.Length; i++)
{
var samples = wavData.ChunkedSamples[i];
var reducedSamples = FourierHelper.ReduceToPow2(samples);
reducedSamples = FourierHelper.PreEmphasis(reducedSamples);
reducedSamples = _fourierWindow.Windowing(reducedSamples);
var complexSamples = FourierTransform.FFT(reducedSamples);
complexSamples = complexSamples.Take(complexSamples.Length / 2).ToArray();
var threshold = complexSamples.Max(c => c.Magnitude) / 10;
var localMax = 0;
for (int j = 1; j < complexSamples.Length; j++)
{
if (complexSamples[j].Magnitude > threshold && complexSamples[j].Magnitude > complexSamples[j - 1].Magnitude && complexSamples[j].Magnitude > complexSamples[j + 1].Magnitude)
{
localMax = j;
break;
}
}
var frequency = (wavData.FormatChunk.SampleRate / (complexSamples.Length * 2)) * localMax;
if (frequencies.Any() && frequencies.Last().Frequency == frequency)
{
frequencies.Last().EndTime += 50;
}
else
{
frequencies.Add(new Sound
{
StartTime = i * 50,
EndTime = i * 50 + 50,
Frequency = frequency,
Result = complexSamples.Select(c => c.Magnitude).ToArray()
});
}
}
return(frequencies);
}
public static Bitmap IFFT2D(Complex[][] data, Bitmap originalBitmap)
{
FourierHelper.Conjugate(data);
for (int i = 0; i < data.Length; i++)
{
FFT1D(data[i]);
}
FourierHelper.Conjugate(data);
CollectionHelper.ApplyOperation(data, c => c / data[0].Length);
var swappedData = CollectionHelper.SwapRowColumn(data);
FourierHelper.Conjugate(swappedData);
for (int i = 0; i < swappedData.Length; i++)
{
FFT1D(swappedData[i]);
}
FourierHelper.Conjugate(swappedData);
CollectionHelper.ApplyOperation(swappedData, c => c / swappedData[0].Length);
using (var bitmapData = new SingleBitmapData(originalBitmap, PixelFormat.Format8bppIndexed))
{
for (int y = 0; y < bitmapData.HeightInPixels; y++)
{
for (int x = 0;
x < bitmapData.WidthInBytes;
x += bitmapData.BytesPerPixel)
{
bitmapData.FirstPixelPtr[x + y * bitmapData.WidthInBytes] = (byte)ImageHelper.FixOverflow(swappedData[y][x].Real);
}
}
return(bitmapData.Bitmap);
}
}
public double[] Process(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];
}
if (_gain < 0)
{
_gain = 1 / Math.Abs(_gain) - 1;
}
var windowFactors = _window.WindowFactors(_windowLength);
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;
}
}
var freq = wavData.FormatChunk.SampleRate / _lfo;
var filterSize = _endBandFreq - _bandSize - _startBandFreq;
for (int i = 0; i < windows.Length; i++)
{
var highPass = (Math.Sin(2 * Math.PI * i * _windowHopSize / freq) * 0.5 + 0.5) * filterSize + _startBandFreq;
var lowPass = highPass + _bandSize;
var bandFilterFactors = BasicFilter.BandPassFilterFactors(lowPass, highPass, wavData.FormatChunk.SampleRate, _filterLength, n);
windowsComplex[i] = FourierTransform.FFT(windows[i]);
for (int j = 0; j < windowsComplex[i].Length; j++)
{
windowsComplex[i][j] += windowsComplex[i][j] * bandFilterFactors[j] * _gain;
}
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);
}
