private void FftAnalyzerIf_FftCalculated(object sender, FftEventArgs e)
{
var bin = new FrequencyBins(e,
new BinParameters
{
MinimumIntensityDb = _model.Settings.IfParameter.MinimumIntensityDb,
SamplingRate = 100000000,
BinsPerPoint = IfSpectrumView.SelectedResolution.Resolution,
CalibrationAmplitude = _model.Settings.IfParameter.CalibrationAmplitude,
CalibrationOffset = _model.Settings.IfParameter.CalibrationOffset
});
if (SpectrumAnalyzerIf != null)
{
SpectrumAnalyzerIf.Update(bin);
}
if (Waterfall != null)
{
Waterfall.Update(bin);
}
/*
* if (!VideoFilter)
* bin = new FrequencyBins(e, _model.Radio.BinParametersDefault());
* else
* bin = new FrequencyBins(e, _model.Radio.BinParametersVideoFilter(_model.FftAnalyzerIf.FftLength, VideoPoints));
*/
/*
* FrequencyBins bin = new FrequencyBins(e, new BinParameters
* {
* BinsPerPoint = 4,
* CalibrationAmplitude = 1.1, //1.5,//1.0 in sweeper is better
* CalibrationOffset = 20,//8,
* MinimumIntensityDb = -150,
* Relative = true,
* SamplingRate = 100000000
* });
*/
/*
* if (_model.Settings.AsyncAnalyze)
* TaskUtility.Run(() => Analyze(e, bin));
* else
* Analyze(e, bin);
*
* UpdateSquelch();
*
* if (AutoStep)
* FrequencyStep = (uint)Math.Abs(MeterView.FrequencyErrorValue * 500000);
*
* if (AfcState)
* {
* if (Math.Abs(MeterView.FrequencyErrorValue * 1000000) > _model.Settings.AfcThreshold) //1000 as default
* FrequencyValue = (uint)(MeterView.PeakFrequencyValue * 1000000);
* }
* RecordingView.Tick();
*/
}
private void FftCalculated(object sender, FftEventArgs e)
{
xPos += _horizontalScale;
int resultsPerBin = (int)Math.Ceiling(e.Result.Length * 1.0 / (_canvas.ActualHeight - VERTICAL_SCALE));
double[] singleBin = new double[resultsPerBin];
int binIndex = 0;
int yPos = 0;
foreach (Complex complex in e.Result)
{
double intensity = GetIntensity(complex);
singleBin[binIndex] = intensity;
if (binIndex >= resultsPerBin - 1)
{
double average = singleBin.Average();
byte rgb = (byte)(255 - (average * 255));
var color = new Color {
R = rgb, G = rgb, B = rgb
};
DrawPixel(xPos, yPos, color);
yPos++;
binIndex = 0;
}
else
{
binIndex++;
}
}
}
public static void DrawFFT(object sender, FftEventArgs e)
{
Application.Current.Dispatcher.Invoke(() =>
{
ViewModelManager.MainWindowViewModel.Points = new PointCollection();
for (int i = 0; i <= e.Result.Length / 4; i++)
{
double intensityDB = 10 * Math.Log10(Math.Sqrt(e.Result[i].X * e.Result[i].X + e.Result[i].Y * e.Result[i].Y));
double minDB = -90;
if (intensityDB < minDB)
{
intensityDB = minDB;
}
double percent = intensityDB / minDB;
double y = 100 * (1 - percent);
if (i < e.Result.Length / 8)
{
y *= (double)i * 8 / e.Result.Length;
}
else
{
y *= 2 - (double)i * 8 / e.Result.Length;
}
ViewModelManager.MainWindowViewModel.Points.Add(new Point(i * 4, 68 - y));
}
ViewModelManager.MainWindowViewModel.Points.Add(new Point(1024, 68));
ViewModelManager.MainWindowViewModel.Points.Add(new Point(0, 68));
});
}
private void _sampleAggregator_FftCalculated(object sender, FftEventArgs e)
{
// _spectrumAnalyser.CalculateFFT(e.Result);
// for (int i = 0; i < _spectrumAnalyser.SpecturmValue.Length; i++)
// {
// this._wave.Wave[i] = (byte)(_spectrumAnalyser.SpecturmValue[i] / _spectrumAnalyser.MaxSpectrumValue * 256);
// }
var point = this._analyser.GetPoint(e.Result);
int step = point.Count / SPECTRUM_BIN_SIZE;
for (int i = 0; i < SPECTRUM_BIN_SIZE; i++)
{
this._wave.Wave[i] = 0;
}
for (int i = 0; i < point.Count; i++)
{
this._wave.Wave[i / step] += (byte)(point[i].Y / step * 256);
}
this._wave.CurrentTime = this._mediaFoundationReader.CurrentTime;
this._wave.TotalTime = this._mediaFoundationReader.TotalTime;
//for (int i = 0; i < point.Count; i++)
//{
// this._wave.Wave[i] = (byte)(point[i].Y * 256);
//}
}
public void SendFTTArgs(FftEventArgs fttData)
{
Task.Run(() =>
{
ControlPanelViewModel.CatcherCallBackFftEvent(fttData);
});
}
void OnAudioGraphFftCalculated(object sender, FftEventArgs e)
{
if (SelectedVisualization != null)
{
SelectedVisualization.OnFftCalculated(e.Result);
}
}
void FftCalculated(object sender, FftEventArgs fftEvent)
{
double[] spectrumData = CalculateSpectrum(fftEvent.Result);
dataBuffer.Enqueue(spectrumData);
if (dataBuffer.Count <double[]>() >= bufferLenght)
{
double[] average = new double[spectrumData.Length];
for (int i = 0; i < spectrumData.Length; i++)
{
average[i] = dataBuffer.Sum <double[]>((x) => x[i]) / dataBuffer.Count <double[]>();
//if (average.Max((x) => Math.Abs(x)) > temp)
//{
// temp = average.Max((x) => Math.Abs(x));
//}
}
while (dataBuffer.Count <double[]>() != bufferLenght)
{
dataBuffer.Dequeue();
}
//double[] spectrumBars = SpectrumBars(average);
SpectrumCalculated.Invoke(average);
}
}
void audioGraph_FftCalculated(object sender, FftEventArgs e)
{
if (this.SelectedVisualization != null)
{
this.SelectedVisualization.OnFftCalculated(e.Result);
}
}
void LiveIf_FftCalculated(object sender, FftEventArgs e)
{
var bin = new FrequencyBins(e, _model.Radio.BinParametersDefault());
Debug.Print("peak at:{0}", bin.MaxIntensityAt());
spectrumAnalyzer.Update(bin);
}
public void SetFFT(FFTInfo Info)
{
this.Info = Info;
m = (int)Math.Log(Info.Length, 2.0);
fftBuffer = new Complex[Info.Length];
fftArgs = new FftEventArgs(fftBuffer);
}
private void Analyze(FftEventArgs e, FrequencyBins bin)
{
var detailedBin = _model.Settings.DetailedAnalyze
? new FrequencyBins(e, _model.Radio.BinParametersDetailed())
: bin;
UpdateMeterView(detailedBin);
}
private void FftCalculated(object sender, FftEventArgs e)
{
Bass = 0f;
Complex[] res = e.Result;
for(int i = 20; i < 60; i++) {
Bass += res[i].X;
Bass /= 2;
}
}
protected virtual void OnFftCalculated(FftEventArgs e)
{
EventHandler <FftEventArgs> handler = FftCalculated;
if (handler != null)
{
handler(this, e);
}
}
public SampleAggregator(int fftLength)
{
if (!IsPowerOfTwo(fftLength)) {
throw new ArgumentException("FFT Length must be a power of two");
}
this.m = (int)Math.Log(fftLength, 2.0);
this.fftLength = fftLength;
this.fftBuffer = new Complex[fftLength];
this.fftArgs = new FftEventArgs(fftBuffer);
}
private void FftCalculated(object sender, FftEventArgs e)
{
Bass = 0f;
Complex[] res = e.Result;
for (int i = 20; i < 60; i++)
{
Bass += res[i].X;
Bass /= 2;
}
}
public SampleAggregator(int fftLength)
{
if (!IsPowerOfTwo(fftLength))
{
throw new ArgumentException("Wielokrotność 2 !!!");
}
this.m = (int)Math.Log(fftLength, 2.0);
this.fftLength = fftLength;
this.fftBuffer = new Complex[fftLength];
this.fftArgs = new FftEventArgs(fftBuffer);
}
public SampleAggregator(int fftLength)
{
if (!IsPowerOfTwo(fftLength))
{
throw new ArgumentException("Wielokrotność 2 !!!");
}
this.m = (int)Math.Log(fftLength, 2.0);
this.fftLength = fftLength;
this.fftBuffer = new Complex[fftLength];
this.fftArgs = new FftEventArgs(fftBuffer);
}
private void FftAnalyzerDdc2_FftCalculated(object sender, FftEventArgs e)
{
var bin = new FrequencyBins(e,
new BinParameters
{
MinimumIntensityDb = _model.Settings.Ddc2Parameter.MinimumIntensityDb,
SamplingRate = _model.Radio.Ddc2(0).DdcArgs().Info.SampleRate,
// CarrierFrequency = (uint)Ddc2AbsoluteFrequency,
BinsPerPoint = Ddc2SpectrumView.SelectedResolution.Resolution,
CalibrationAmplitude = _model.Settings.Ddc2Parameter.CalibrationAmplitude,
CalibrationOffset = _model.Settings.Ddc2Parameter.CalibrationOffset
}, false);
if (SpectrumAnalyzerDdc2 != null)
{
SpectrumAnalyzerDdc2.Update(bin);
}
/*
* FrequencyBins bin = new FrequencyBins(e, new BinParameters
* {
* MinimumIntensityDb = -150,
* SamplingRate = _model.Radio.Ddc2(_index).DdcArgs().Info.SampleRate,
* Relative = true,
* CarrierFrequency = _model.Ddc1Frequency,
* BinsPerPoint = 4,
* CalibrationAmplitude = 1.1, //1.5,//1.0 in sweeper is better
* CalibrationOffset = 20,//8,
* });
*/
// MeterViewDemodulator.Update(e, bin);
MeterViewDemodulator.Update(bin);
SquelchView.UpdateSquelch(MeterViewDemodulator.RmsDbm);
UpdateVolume();
if (AutoStep)
{
FrequencyStep = (uint)Math.Abs(MeterViewDemodulator.FrequencyErrorValue * 500000);
}
if (AfcState)
{
if (Math.Abs(MeterViewDemodulator.FrequencyErrorValue * 1000000) > _model.Settings.AfcThreshold) //1000 as default
{
DemodulatorFrequency = (int)(MeterViewDemodulator.PeakFrequency * 1000000);
}
}
/*
* RecordingView.Tick();
*/
}
void audioGraph_FftCalculated(object sender, FftEventArgs e)
{
//Dispatcher.BeginInvoke(new Action<object, FftEventArgs>((s, args) =>
//{
// //if (this.selectedVisualization != null)
// //{
// // this.selectedVisualization.OnFftCalculated(e.Result);
// //}
// //spectrumAnalyser.Update(e.Result);
//}), sender, e);
}
public SampleAggregator(int fftLength)
{
if (!IsPowerOfTwo(fftLength))
{
throw new ArgumentException("FFT Length must be a power of two");
}
this.m = (int)Math.Log(fftLength, 2.0);
this.fftLength = fftLength;
this.fftBuffer = new Complex[fftLength];
this.fftArgs = new FftEventArgs(fftBuffer);
}
public void Update(FftEventArgs e, FrequencyBins bin)
{
if (_model.Settings.AsyncAnalyze)
{
TaskUtility.Run(() => Analyze(e, bin));
}
else
{
Analyze(e, bin);
}
}
public SampleWaveProvider(ISampleProvider source, int fftLength = 1024)
{
channels = source.WaveFormat.Channels;
if (!IsPowerOfTwo(fftLength))
{
throw new ArgumentException("FFT Length must be a power of two");
}
this.m = (int)Math.Log(fftLength, 2.0);
this.fftLength = fftLength;
this.fftBuffer = new Complex[fftLength];
this.fftArgs = new FftEventArgs(fftBuffer);
this.source = source;
}
private void Add(float value)
{
fftBuffer[fftPos].X = (float)(value * FastFourierTransform.HammingWindow(fftPos, fftLength));
fftBuffer[fftPos].Y = 0;
fftPos++;
if (fftPos >= fftBuffer.Length)
{
fftPos = 0;
FastFourierTransform.FFT(true, m, fftBuffer);
fftArgs = new FftEventArgs(fftBuffer, NotificationCount * 100);
FftCalculated(this, fftArgs);
}
}
public SampleAggregator(ISampleProvider source, int fftLength = 1024)
{
channels = source.WaveFormat.Channels;
if (!IsPowerOfTwo(fftLength))
{
throw new ArgumentException("FFT Length must be a power of two");
}
m = (int)Math.Log(fftLength, 2.0);
this.fftLength = fftLength;
fftBuffer = new Complex[fftLength];
_spectrum = new float[fftLength];
fftArgs = new FftEventArgs(fftBuffer);
downspeed = (1f / source.WaveFormat.SampleRate) * (1f / 0.4f) * fftLength;
this.source = source;
}
private static void fft(object sender, FftEventArgs e)
{
float binSize = 44100 / fftLengthDefault;
int minBin = ((int)(minHz / (binSize * Lightning.delay * 4)));
if (minBin < 1)
{
minBin = 1;
}
int maxBin = (int)(maxHz / (binSize * Lightning.delay * 4));
float[] intensity = new float[1 + maxBin - minBin];
float[] frequency = new float[1 + maxBin - minBin];
float v = (float)Volume.volumeIs();
for (int bin = minBin; bin <= maxBin; bin++)
{
float real = e.Result[bin * 2].X;
float imaginary = e.Result[bin * 2 + 1].Y;
intensity[bin - minBin] = (real * real + imaginary * imaginary) * 100_000_000f;
frequency[bin - minBin] = binSize * bin;
}
//binSize * bin - frequency; intensity - power
float groupSize = (1 + maxBin - minBin) / kbw;
float[] intensityAverage = new float[kbw];
float[] frequencyAverage = new float[kbw];
float sumF = 0;
float sumI = 0;
int averageIndex = 0;
for (int i = 0; i < frequency.Length; i++)
{
sumF += frequency[i];
sumI += intensity[i];
if ((i + 1) % groupSize == 0 && (i + 1) / groupSize <= kbw)
{
frequencyAverage[averageIndex] = sumF / groupSize;
intensityAverage[averageIndex] = sumI / groupSize * frequencyAverage[averageIndex];
averageIndex++;
sumF = 0;
sumI = 0;
}
}
toMatrixColor(intensityAverage);
//toMatrixLight(intensityAverage);
}
private void FftCalculated(object sender, FftEventArgs e)
{
if (_lines == 0)
{
return;
}
lock (SpectrumData)
{
int x;
var b0 = 0;
SpectrumData.Clear();
for (x = 0; x < _lines; x++)
{
float peak = 0;
var b1 = (int)Math.Pow(2, x * 10.0 / (_lines - 1));
if (b1 > 2047)
{
b1 = 2047;
}
if (b1 <= b0)
{
b1 = b0 + 1;
}
for (; b0 < b1; b0++)
{
if (peak < e.Result[1 + b0].X)
{
peak = e.Result[1 + b0].X;
}
}
var y = (int)(Math.Sqrt(peak) * 3 * 255 - 4);
if (y > 255)
{
y = 255;
}
if (y < 0)
{
y = 0;
}
SpectrumData.Add((byte)y);
}
}
}
private void FftAnalyzer_FftCalculated(object sender, FftEventArgs e)
{
FrequencyBins bin;
// _spectrumAnalyzer.Clear();
if (!VideoFilter)
{
bin = new FrequencyBins(e, _model.Radio.BinParametersDefault());
}
else
{
bin = new FrequencyBins(e,
_model.Radio.BinParametersVideoFilter(_model.FftAnalyzer.FftLength, VideoPoints));
}
SpectrumAnalyzer.Update(bin);
if (_model.Settings.AsyncAnalyze)
{
TaskUtility.Run(() => Analyze(e, bin));
}
else
{
Analyze(e, bin);
}
UpdateSquelch();
if (AutoStep)
{
FrequencyStep = (uint)Math.Abs(MeterView.FrequencyErrorValue * 500000);
}
if (AfcState)
{
if (Math.Abs(MeterView.FrequencyErrorValue * 1000000) > _model.Settings.AfcThreshold) //1000 as default
{
FrequencyValue = (uint)(MeterView.PeakFrequencyValue * 1000000);
}
}
RecordingView.Tick();
}
private void SweepBins(FftEventArgs e)
{
//mark frequencies based on current IF2 in [-10Khz, 10KHz] domain
var bin = new FrequencyBins(e, /*_radio.BinParametersDefault()*/ _radio.BinParametersWideSpectrum());
var frequency = _radio.Frequency();
var minFrequency = frequency - _sweepParameters.SweepSpan;
var maxFrequency = frequency + _sweepParameters.SweepSpan;
var sweeped = new List <SweepedFrequency>();
var frequnecies = bin.Frequencies();
foreach (var f in frequnecies)
{
if (f > _lastFrequency && f >= minFrequency && f <= maxFrequency)
{
_lastFrequency = f;
var data = SweepFrequency(bin, f);
sweeped.Add(data);
}
}
OnFrequencySweeped(sweeped, frequency, _sweepParameters.Precision);
}
private void FftAnalyzer_FftCalculated(object sender, FftEventArgs e)
{
FrequencyBins bin;
spectrumAnalyzer.Clear();
if (!_model.VideoFilter)
{
bin = new FrequencyBins(e, _model.Radio.BinParametersDefault());
}
else
{
bin = new FrequencyBins(e,
_model.Radio.BinParametersVideoFilter(_model.FftAnalyzer.FftLength, _model.VideoPoints));
}
Debug.Print("peak at:{0}: {1}", bin.MaxIntensityAt(), bin.MaxIntensity());
spectrumAnalyzer.Update(bin);
TaskUtility.Run(() =>
{
Invoke(new Action(() =>
{
try
{
labelPeakFrequency.Text = (bin.MaxIntensityAt() / 1000000).ToString();
labelFrequenccyError.Text =
((bin.MaxIntensityAt() - (double)numericUpDownFrequency.Value) / 1000000).ToString();
labelPowerDbm.Text = _model.Radio.Demodulator().SignalStrength().ToString();
labelPowerUVolt.Text =
RfMath.DbmToMicroVolts(_model.Radio.Demodulator().SignalStrength()).ToString();
}
catch
{
}
}));
});
}
void FftCalculated(object sender, FftEventArgs e)
{
double sumFreq1 = 0;
double sumFreq2 = 0;
double sumFreq3 = 0;
double temp = 0;
FftChart.Series[fft].Points.Clear();
for (var i = 0; i < e.Result.Length/2; i++)
{
temp = Math.Sqrt(e.Result[i].X * e.Result[i].X + e.Result[i].Y * e.Result[i].Y);
if (i < 3)
{
sumFreq1 = sumFreq1 + temp;
}else if(i<10){
sumFreq2 = sumFreq2 + temp;
}
else
{
sumFreq3 = sumFreq3 + temp;
}
FftChart.Series[fft].Points.AddY(temp);
}
if (counter2 > 100)
{
SumFreq1Chart.Series[sumFreq1series].Points.Remove(SumFreq1Chart.Series[sumFreq1series].Points.First());
SumFreq2Chart.Series[sumFreq2series].Points.Remove(SumFreq2Chart.Series[sumFreq2series].Points.First());
SumFreq3Chart.Series[sumFreq3series].Points.Remove(SumFreq3Chart.Series[sumFreq3series].Points.First());
}
else
{
counter2++;
}
SumFreq1Chart.Series[sumFreq1series].Points.AddY(sumFreq1);
SumFreq2Chart.Series[sumFreq2series].Points.AddY(sumFreq2);
SumFreq3Chart.Series[sumFreq3series].Points.AddY(sumFreq3);
}
void FftCalculated(object sender, FftEventArgs fftEvent)
{
double[] spectrumData = CalculateSpectrum(fftEvent.Result);
dataBuffer.Enqueue(spectrumData);
if (dataBuffer.Count<double[]>() >= bufferLenght)
{
double[] average = new double[spectrumData.Length];
for (int i = 0; i < spectrumData.Length; i++)
{
average[i] = dataBuffer.Sum<double[]>( (x) => x[i] ) / dataBuffer.Count<double[]>();
//if (average.Max((x) => Math.Abs(x)) > temp)
//{
// temp = average.Max((x) => Math.Abs(x));
//}
}
while (dataBuffer.Count<double[]>() != bufferLenght) dataBuffer.Dequeue();
//double[] spectrumBars = SpectrumBars(average);
SpectrumCalculated.Invoke(average);
}
}
void audioGraph_FftCalculated(object sender, FftEventArgs e)
{
this.visualizations.OnFftCalculated(e.Result);
}
void audioGraph_FftCalculated(object sender, FftEventArgs e)
{
callback.SendFTTArgs(e);
}
void fftCalculated(FftEventArgs fttData)
{
analyzer.Update(fttData.Result);
}
private void FftAnalyzerDdc1_FftCalculated(object sender, FftEventArgs e)
{
/*
* var bin = new FrequencyBins(e,
* new BinParameters
* {
* Relative = true,
* CarrierFrequency = Ddc1Frequency,
* MinimumIntensityDb = -120,
* SamplingRate = Ddc1Info.SampleRate,
* BinsPerPoint = Ddc1SpectrumView.SelectedResolution.Resolution
* }, false);
*/
Wait = true;
var bins = new FastFrequencyBins(e,
new BinParameters
{
Relative = true,
CarrierFrequency = Ddc1Frequency,
MinimumIntensityDb = _model.Settings.Ddc1Parameter.MinimumIntensityDb,
SamplingRate = Ddc1Info.SampleRate,
BinsPerPoint = 1,
CalibrationAmplitude = _model.Settings.Ddc1Parameter.CalibrationAmplitude,
CalibrationOffset = _model.Settings.Ddc1Parameter.CalibrationOffset
}, false);
// Morse decoder
if (SearchEventHandler != null)
{
SearchEventHandler(this, new SearchEventArgs(bins));
}
Wait = false;
var intensities = bins.Intensities().ToList <double>().Where((x, i) => i % Ddc1SpectrumView.SelectedResolution.Resolution == 0);
if (SpectrumAnalyzerDdc1 != null)
{
SpectrumAnalyzerDdc1.Update(intensities.ToArray());
}
MeterViewDdc1.Update(bins);
/*
* FrequencyBins bin = new FrequencyBins(e, new BinParameters
* {
* Relative = true,
* CarrierFrequency = _model.Ddc1Frequency,
* MinimumIntensityDb = -150,
* SamplingRate = _model.Radio.Ddc1().DdcArgs().Info.SampleRate,
* BinsPerPoint = 4,
* CalibrationAmplitude = 1.1, //1.5,//1.0 in sweeper is better
* CalibrationOffset = 20,//8,
* });
* SpectrumAnalyzerDdc1.Update(bin);
*
* RecordingView.Tick();
*/
}
