public override SignalImplementation TransformSignal(ISignal signal)
{
SignalImplementation result = new SignalImplementation
{
Points = new List <Tuple <double, Complex> >()
};
double samplingFrequency = 1d / (signal.Points[1].Item1 - signal.Points[0].Item1);
double f0 = samplingFrequency / signal.Points.Count;
for (int i = 0; i < signal.Points.Count; i++)
{
double x = i * f0 / 2;
Complex transformValue = Complex.GetZero();
for (int j = 0; j < signal.Points.Count; j++)
{
Complex cosCoefficient = new Complex
{
Real = Math.Cos((Math.PI * (2d * j + 1d) * i) / (2d * signal.Points.Count)),
Imaginary = 0d
};
Complex product = Complex.Multiply(signal.Points[j].Item2, cosCoefficient);
transformValue = Complex.Add(transformValue, product);
}
transformValue.Real = transformValue.Real * CValue(i, signal.Points.Count);
result.Points.Add(new Tuple <double, Complex>(x, transformValue));
}
return(result);
}
private static SignalImplementation CombineSignals(Func <Complex, Complex, Complex> func, ISignal firstSignal, ISignal secondSignal)
{
List <Tuple <double, Complex> > signal1 = firstSignal.Points;
List <Tuple <double, Complex> > signal2 = secondSignal.Points;
List <Tuple <double, Complex> > outputSignal = new List <Tuple <double, Complex> >();
int i = 0;
int j = 0;
Complex result;
while (i < signal1.Count && j < signal2.Count)
{
if (Math.Abs(signal1[i].Item1 - signal2[j].Item1) <= 0.001)
{
result = func(signal1[i].Item2, signal2[j].Item2);
outputSignal.Add(new Tuple <double, Complex>(signal1[i].Item1, result));
i++;
j++;
}
else if (signal1[i].Item1 - signal2[j].Item1 > 0.001)
{
j++;
}
else if (signal2[j].Item1 - signal1[i].Item1 > 0.001)
{
i++;
}
}
SignalImplementation signalImplementation = new SignalImplementation();
signalImplementation.Points = new List <Tuple <double, Complex> >();
signalImplementation.Points.AddRange(outputSignal);
return(signalImplementation);
}
public override SignalImplementation TransformSignal(ISignal signal)
{
SignalImplementation result = new SignalImplementation
{
Points = new List <Tuple <double, Complex> >()
};
double samplingFrequency = 1d / (signal.Points[1].Item1 - signal.Points[0].Item1);
double f0 = samplingFrequency / signal.Points.Count;
for (int i = 0; i < signal.Points.Count; i++)
{
double x = i * f0;
Complex transformValue = Complex.GetZero();
for (int j = 0; j < signal.Points.Count; j++)
{
Complex wCoefficient = GetWCoefficient(-i * j, signal.Points.Count);
Complex product = Complex.Multiply(signal.Points[j].Item2, wCoefficient);
transformValue = Complex.Add(transformValue, product);
}
transformValue.Real = transformValue.Real / signal.Points.Count;
transformValue.Imaginary = transformValue.Imaginary / signal.Points.Count;
result.Points.Add(new Tuple <double, Complex>(x, transformValue));
}
return(result);
}
//function assumes signals have the same sample frequency
public static SignalImplementation ConvoluteSignals(ISignal firstSignal, ISignal secondSignal)
{
ISignal extendedFirstSignal = new SignalImplementation();
ISignal extendedSecondSignal = new SignalImplementation();
extendedFirstSignal.Points = new List <Tuple <double, Complex> >(firstSignal.Points);
extendedSecondSignal.Points = new List <Tuple <double, Complex> >(secondSignal.Points);
ExtendSignals(extendedFirstSignal, extendedSecondSignal);
SignalImplementation outputSignal = new SignalImplementation();
outputSignal.Points = new List <Tuple <double, Complex> >();
double currentX = extendedFirstSignal.Points[0].Item1;
double samplePeriod = firstSignal.Points[1].Item1 - firstSignal.Points[0].Item1;
for (int i = 0; i < (extendedFirstSignal.Points.Count + extendedSecondSignal.Points.Count); i++)
{
Complex sum = Complex.GetZero();
for (int j = 0; j < extendedFirstSignal.Points.Count; j++)
{
if ((i - j) < 0 || (i - j) >= extendedSecondSignal.Points.Count)
{
continue;
}
sum = Complex.Add(sum, Complex.Multiply(extendedFirstSignal.Points[j].Item2, extendedSecondSignal.Points[i - j].Item2));
}
outputSignal.Points.Add(new Tuple <double, Complex>(currentX, sum));
currentX += samplePeriod;
}
return(outputSignal);
}
public override SignalImplementation FilterSignal(ISignal signal)
{
double samplingFrequency = 1d / (signal.Points[1].Item1 - signal.Points[0].Item1);
double kCoefficient = samplingFrequency / _cutoffFrequency;
SignalImplementation filterCoefficients = getFilterCoefficients(signal, kCoefficient);
SignalImplementation result = SignalOperations.ConvoluteSignals(signal, filterCoefficients);
return(result);
}
public static SignalImplementation GetAbsoluteSignal(ISignal signal)
{
SignalImplementation outputSignal = new SignalImplementation();
foreach (Tuple <double, Complex> point in signal.Points)
{
outputSignal.Points.Add(new Tuple <double, Complex>(point.Item1, point.Item2.GetAbsouluteValue()));
}
return(outputSignal);
}
private void LoadPlot(object param)
{
SignalRepresentation signalRepresentation;
switch (param.ToString())
{
case "1":
signalRepresentation = FirstChart.SignalRepresentation;
FirstChart.SelectedIndex = -1;
break;
case "2":
signalRepresentation = SecondChart.SignalRepresentation;
SecondChart.SelectedIndex = -1;
break;
default:
throw new ArgumentException();
}
Microsoft.Win32.OpenFileDialog dlg = new Microsoft.Win32.OpenFileDialog
{
Filter = "*All Files | *.xD"
};
if (dlg.ShowDialog() == false)
{
return;
}
using (BinaryReader reader = new BinaryReader(File.Open(dlg.FileName, FileMode.Open)))
{
SignalImplementation signalImplementation = new SignalImplementation
{
Points = new List <Tuple <double, Complex> >()
};
while (reader.BaseStream.Position != reader.BaseStream.Length)
{
double xCoordinate = reader.ReadDouble();
Complex value = new Complex
{
Real = reader.ReadDouble(),
Imaginary = reader.ReadDouble()
};
signalImplementation.Points.Add(new Tuple <double, Complex>(xCoordinate, value));
}
signalImplementation.StartingMoment = signalImplementation.Points[0].Item1;
signalImplementation.EndingMoment = signalImplementation.Points[signalImplementation.Points.Count - 1].Item1;
signalImplementation.CalculateTraits();
signalRepresentation.Signal = signalImplementation;
}
}
public override SignalImplementation TransformSignal(ISignal signal)
{
SignalImplementation cutSignal = CutSignalSamplesToPowerOfTwo(signal);
CalculateWCoefficients(cutSignal.Points.Count);
SignalImplementation result = CalculateFastTransform(cutSignal, 0);
foreach (Tuple <double, Complex> point in result.Points)
{
point.Item2.Real = point.Item2.Real / signal.Points.Count;
point.Item2.Imaginary = point.Item2.Imaginary / signal.Points.Count;
}
return(result);
}
public override SignalImplementation FilterSignal(ISignal signal)
{
double samplingFrequency = 1d / (signal.Points[1].Item1 - signal.Points[0].Item1);
double kCoefficient = samplingFrequency / (samplingFrequency / 2 - _cutoffFrequency);
SignalImplementation filterCoefficients = getFilterCoefficients(signal, kCoefficient);
for (int i = 0; i < filterCoefficients.Points.Count; i++)
{
filterCoefficients.Points[i].Item2.Real = filterCoefficients.Points[i].Item2.Real * Math.Pow(-1.0, i);
}
SignalImplementation result = SignalOperations.ConvoluteSignals(signal, filterCoefficients);
return(result);
}
private SignalImplementation CutSignalSamplesToPowerOfTwo(ISignal signal)
{
int powerOfTwo = 1;
while (powerOfTwo <= signal.Points.Count)
{
powerOfTwo *= 2;
}
powerOfTwo /= 2;
SignalImplementation result = new SignalImplementation();
result.Points.AddRange(signal.Points.GetRange(0, powerOfTwo));
return(result);
}
protected SignalImplementation getFilterCoefficients(ISignal signal, double kCoefficient)
{
SignalImplementation filterCoefficients = new SignalImplementation();
filterCoefficients.Points = new List <Tuple <double, Complex> >();
int i = 0;
foreach (Tuple <double, Complex> point in signal.Points)
{
Complex filterCoefficient = Complex.GetZero();
filterCoefficient.Real = GetFilterCoeficcient(i, kCoefficient);
filterCoefficients.Points.Add(new Tuple <double, Complex>(point.Item1, filterCoefficient));
i++;
}
return(filterCoefficients);
}
private SignalImplementation CalculateFastTransform(ISignal signal, int recursionDepth)
{
SignalImplementation evenElements = new SignalImplementation();
SignalImplementation oddElements = new SignalImplementation();
bool isEven = true;
foreach (Tuple <double, Complex> point in signal.Points)
{
if (isEven)
{
evenElements.Points.Add(point);
}
else
{
oddElements.Points.Add(point);
}
isEven = !isEven;
}
SignalImplementation evenElementsTransformed = evenElements;
SignalImplementation oddElementsTransformed = oddElements;
if (evenElements.Points.Count > 1)
{
evenElementsTransformed = CalculateFastTransform(evenElements, recursionDepth + 1);
}
if (oddElements.Points.Count > 1)
{
oddElementsTransformed = CalculateFastTransform(oddElements, recursionDepth + 1);
}
SignalImplementation result = new SignalImplementation();
result.Points.AddRange(Enumerable.Repeat(new Tuple <double, Complex>(0, Complex.GetZero()), signal.Points.Count));
int halfOfSampleCount = signal.Points.Count / 2;
double samplingFrequency = 1d / (signal.Points[1].Item1 - signal.Points[0].Item1);
double f0 = samplingFrequency / signal.Points.Count;
for (int i = 0; i < evenElements.Points.Count; i++)
{
Complex product = Complex.Multiply(_wCoefficients[(int)(i * Math.Pow(2, recursionDepth))], oddElementsTransformed.Points[i].Item2);
result.Points[i] = new Tuple <double, Complex>(i * f0, Complex.Add(evenElementsTransformed.Points[i].Item2, product));
result.Points[i + halfOfSampleCount] = new Tuple <double, Complex>((i + halfOfSampleCount) * f0, Complex.Subtract(evenElementsTransformed.Points[i].Item2, product));
}
return(result);
}
public override SignalImplementation TransformSignal(ISignal signal)
{
SignalImplementation evenElements = new SignalImplementation();
SignalImplementation oddElements = new SignalImplementation();
bool isEven = true;
foreach (Tuple <double, Complex> point in signal.Points)
{
if (isEven)
{
evenElements.Points.Add(point);
}
else
{
oddElements.Points.Add(point);
}
isEven = !isEven;
}
oddElements.Points.Reverse();
SignalImplementation combinedSignal = new SignalImplementation();
combinedSignal.Points.AddRange(evenElements.Points);
combinedSignal.Points.AddRange(oddElements.Points);
DecimationInTimeFFT fft = new DecimationInTimeFFT();
SignalImplementation signalAfterFFT = fft.TransformSignal(combinedSignal);
SignalImplementation result = new SignalImplementation();
double samplingFrequency = 1d / (signal.Points[1].Item1 - signal.Points[0].Item1);
double f0 = samplingFrequency / signal.Points.Count;
for (int i = 0; i < signalAfterFFT.Points.Count; i++)
{
double exponent = ((-1d) * i * Math.PI) / (2d * signalAfterFFT.Points.Count);
Complex complexExponent = new Complex
{
Real = Math.Cos(exponent) * CValue(i, signalAfterFFT.Points.Count),
Imaginary = 0
};
result.Points.Add(new Tuple <double, Complex>(i * f0 / 2, Complex.Multiply(signalAfterFFT.Points.ElementAt(i).Item2, complexExponent)));
result.Points[i].Item2.Imaginary = 0;
}
return(result);
}
public static SignalImplementation ExtrapolationZeroOrderHold(ISignal signalToReconstruct, double targetFrequency)
{
SignalImplementation reconstructedSignal = new SignalImplementation();
double step = 1 / targetFrequency;
if (signalToReconstruct.Points.Count < 2)
{
throw new ArgumentException();
}
double baseSignalStep = signalToReconstruct.Points.ElementAtOrDefault(1).Item1 - signalToReconstruct.Points.ElementAtOrDefault(0).Item1;
Tuple <double, Complex> referencePoint = signalToReconstruct.Points.First();
foreach (Tuple <double, Complex> point in signalToReconstruct.Points)
{
for (double d = point.Item1; d < point.Item1 + baseSignalStep; d += step)
{
reconstructedSignal.Points.Add(new Tuple <double, Complex>(d, point.Item2));
}
}
return(reconstructedSignal);
}
public static SignalImplementation SampleSignal(ISignal signalToSample, double samplingFrequency)
{
SignalImplementation result = new SignalImplementation();
double step = 1 / samplingFrequency;
for (double d = signalToSample.Points.First().Item1; d <= signalToSample.Points.Last().Item1; d += step)
{
Tuple <double, Complex> point = signalToSample.Points.Find(x => x.Item1 == d);
if (point != null)
{
result.Points.Add(point);
}
else
{
IEnumerable <Tuple <double, Complex> > lowerPoints = signalToSample.Points.Where(x => x.Item1 < d);
IEnumerable <Tuple <double, Complex> > greaterPoints = signalToSample.Points.Where(x => x.Item1 > d);
if (lowerPoints.Count() == 0)
{
result.Points.Add(greaterPoints.Min());
}
else if (greaterPoints.Count() == 0)
{
result.Points.Add(lowerPoints.Max());
}
else
{
Tuple <double, Complex> lowerPoint = lowerPoints.Max();
Tuple <double, Complex> greaterPoint = greaterPoints.Min();
Complex averagedPoint = new Complex
{
Real = (greaterPoint.Item2.Real + lowerPoint.Item2.Real) / 2,
Imaginary = (greaterPoint.Item2.Imaginary + lowerPoint.Item2.Imaginary) / 2
};
result.Points.Add(new Tuple <double, Complex>(d, averagedPoint));
}
}
}
return(result);
}
private void Quantize(object param)
{
string samplingText = "";
string levelsText = "";
QuantizeWindow dialog = new QuantizeWindow();
if (dialog.ShowDialog() == true)
{
samplingText = dialog.SamplingFrequency;
levelsText = dialog.LevelsOfQuantization;
}
if (!double.TryParse(samplingText, out double samplingFrequency))
{
return;
}
if (!int.TryParse(levelsText, out int levelsOfQuantization))
{
return;
}
ISignal signal;
switch (param.ToString())
{
case "1":
signal = FirstChart.SignalRepresentation.Signal;
break;
default:
throw new ArgumentException();
}
SignalImplementation quantizedSignal = Quantizator.Quantize(Quantizator.SampleSignal(signal, samplingFrequency), levelsOfQuantization);
quantizedSignal.StartingMoment = quantizedSignal.Points[0].Item1;
quantizedSignal.EndingMoment = quantizedSignal.Points[quantizedSignal.Points.Count - 1].Item1;
quantizedSignal.CalculateTraits();
combinedSignal.Signal = quantizedSignal;
combinedTextProperties.AverageValueText = combinedSignal.Signal.AverageValue.ToString("N3");
combinedTextProperties.AbsouluteAverageValueText = combinedSignal.Signal.AbsouluteAverageValue.ToString("N3");
combinedTextProperties.AveragePowerText = combinedSignal.Signal.AveragePower.ToString("N3");
combinedTextProperties.VarianceText = combinedSignal.Signal.Variance.ToString("N3");
combinedTextProperties.EffectiveValueText = combinedSignal.Signal.EffectiveValue.ToString("N3");
OnPropertyChanged("CombinedTextProperties");
realCombinedSeries = new ScatterSeries();
imaginaryCombinedSeries = new ScatterSeries();
foreach (Tuple <double, Complex> tuple in quantizedSignal.Points)
{
realCombinedSeries.Points.Add(new ScatterPoint(tuple.Item1, tuple.Item2.Real));
imaginaryCombinedSeries.Points.Add(new ScatterPoint(tuple.Item1, tuple.Item2.Imaginary));
}
realCombinedSeries.MarkerType = MarkerType.Circle;
imaginaryCombinedSeries.MarkerType = MarkerType.Circle;
realCombinedSeries.MarkerSize = 2;
imaginaryCombinedSeries.MarkerSize = 2;
realCombinedSeries.MarkerFill = OxyColors.Green;
imaginaryCombinedSeries.MarkerFill = OxyColors.Green;
realPlotModel.Series.Add(realCombinedSeries);
imaginaryPlotModel.Series.Add(imaginaryCombinedSeries);
realPlotModel.InvalidatePlot(true);
imaginaryPlotModel.InvalidatePlot(true);
}
private void Filter(object param)
{
string filterDegreeText = "";
string cutoffFrequencyText = "";
IWindow windowFunction = null;
Filter filter = null;
FilterWindow dialog = new FilterWindow();
if (dialog.ShowDialog() == true)
{
filterDegreeText = dialog.FilterDegree;
cutoffFrequencyText = dialog.CutoffFrequency;
windowFunction = dialog.SelectedWindowFunction;
filter = dialog.SelectedFilter;
}
if (!int.TryParse(filterDegreeText, out int filterDegree))
{
return;
}
if (!double.TryParse(cutoffFrequencyText, out double cutoffFrequency))
{
return;
}
if (windowFunction == null)
{
return;
}
if (filter == null)
{
return;
}
ISignal signal;
switch (param.ToString())
{
case "1":
signal = FirstChart.SignalRepresentation.Signal;
break;
case "2":
signal = SecondChart.SignalRepresentation.Signal;
break;
case "3":
signal = combinedSignal.Signal;
break;
default:
throw new ArgumentException();
}
filter.InitFilter(cutoffFrequency, filterDegree, windowFunction);
SignalImplementation filteredSignal = filter.FilterSignal(signal);
filteredSignal.StartingMoment = filteredSignal.Points[0].Item1;
filteredSignal.EndingMoment = filteredSignal.Points[filteredSignal.Points.Count - 1].Item1;
filteredSignal.CalculateTraits();
combinedSignal.Signal = filteredSignal;
combinedTextProperties.AverageValueText = combinedSignal.Signal.AverageValue.ToString("N3");
combinedTextProperties.AbsouluteAverageValueText = combinedSignal.Signal.AbsouluteAverageValue.ToString("N3");
combinedTextProperties.AveragePowerText = combinedSignal.Signal.AveragePower.ToString("N3");
combinedTextProperties.VarianceText = combinedSignal.Signal.Variance.ToString("N3");
combinedTextProperties.EffectiveValueText = combinedSignal.Signal.EffectiveValue.ToString("N3");
OnPropertyChanged("CombinedTextProperties");
realCombinedSeries = new ScatterSeries();
imaginaryCombinedSeries = new ScatterSeries();
foreach (Tuple <double, Complex> tuple in filteredSignal.Points)
{
realCombinedSeries.Points.Add(new ScatterPoint(tuple.Item1, tuple.Item2.Real));
imaginaryCombinedSeries.Points.Add(new ScatterPoint(tuple.Item1, tuple.Item2.Imaginary));
}
ClearPlot();
realCombinedSeries.MarkerType = MarkerType.Circle;
imaginaryCombinedSeries.MarkerType = MarkerType.Circle;
realCombinedSeries.MarkerSize = 1;
imaginaryCombinedSeries.MarkerSize = 1;
realCombinedSeries.MarkerFill = OxyColors.Green;
imaginaryCombinedSeries.MarkerFill = OxyColors.Green;
realPlotModel.Series.Add(realCombinedSeries);
imaginaryPlotModel.Series.Add(imaginaryCombinedSeries);
realPlotModel.InvalidatePlot(true);
imaginaryPlotModel.InvalidatePlot(true);
}
private void Transform(object param)
{
SignalTransform transform = null;
bool absoluteValue = false;
TransformWindow dialog = new TransformWindow();
if (dialog.ShowDialog() == true)
{
transform = dialog.SelectedTransform;
absoluteValue = dialog.AbsoluteValue;
}
if (transform == null)
{
return;
}
ISignal signal;
switch (param.ToString())
{
case "1":
signal = FirstChart.SignalRepresentation.Signal;
break;
case "2":
signal = SecondChart.SignalRepresentation.Signal;
break;
case "3":
signal = combinedSignal.Signal;
break;
default:
throw new ArgumentException();
}
DateTime start = DateTime.Now;
SignalImplementation transformedSignal = transform.TransformSignal(signal);
if (absoluteValue)
{
transformedSignal = SignalOperations.GetAbsoluteSignal(transformedSignal);
}
TimeSpan elapsedTime = DateTime.Now - start;
MessageBox.Show("Czas wykonania algorytmu: " + elapsedTime.Minutes + "m " + elapsedTime.Seconds + "s " + elapsedTime.Milliseconds + "ms");
transformedSignal.StartingMoment = transformedSignal.Points[0].Item1;
transformedSignal.EndingMoment = transformedSignal.Points[transformedSignal.Points.Count - 1].Item1;
transformedSignal.CalculateTraits();
combinedSignal.Signal = transformedSignal;
combinedTextProperties.AverageValueText = combinedSignal.Signal.AverageValue.ToString("N3");
combinedTextProperties.AbsouluteAverageValueText = combinedSignal.Signal.AbsouluteAverageValue.ToString("N3");
combinedTextProperties.AveragePowerText = combinedSignal.Signal.AveragePower.ToString("N3");
combinedTextProperties.VarianceText = combinedSignal.Signal.Variance.ToString("N3");
combinedTextProperties.EffectiveValueText = combinedSignal.Signal.EffectiveValue.ToString("N3");
OnPropertyChanged("CombinedTextProperties");
realCombinedSeries = new ScatterSeries();
imaginaryCombinedSeries = new ScatterSeries();
foreach (Tuple <double, Complex> tuple in transformedSignal.Points)
{
realCombinedSeries.Points.Add(new ScatterPoint(tuple.Item1, tuple.Item2.Real));
imaginaryCombinedSeries.Points.Add(new ScatterPoint(tuple.Item1, tuple.Item2.Imaginary));
}
ClearPlot();
realCombinedSeries.MarkerType = MarkerType.Circle;
imaginaryCombinedSeries.MarkerType = MarkerType.Circle;
realCombinedSeries.MarkerSize = 2;
imaginaryCombinedSeries.MarkerSize = 2;
realCombinedSeries.MarkerFill = OxyColors.Green;
imaginaryCombinedSeries.MarkerFill = OxyColors.Green;
realPlotModel.Series.Add(realCombinedSeries);
imaginaryPlotModel.Series.Add(imaginaryCombinedSeries);
realPlotModel.InvalidatePlot(true);
imaginaryPlotModel.InvalidatePlot(true);
}
private void Reconstruct(object param)
{
string frequencyToReconstructText = "";
ReconstructWindow dialog = new ReconstructWindow();
if (dialog.ShowDialog() == true)
{
frequencyToReconstructText = dialog.FrequencyToReconstruct;
}
if (!double.TryParse(frequencyToReconstructText, out double frequencyToReconstruct))
{
return;
}
ISignal signal;
switch (param.ToString())
{
case "1":
if (combinedSignal.Signal.Points.Count != 0)
{
signal = combinedSignal.Signal;
}
else
{
signal = FirstChart.SignalRepresentation.Signal;
}
break;
default:
throw new ArgumentException();
}
SignalImplementation reconstructedSignal = Quantizator.ExtrapolationZeroOrderHold(signal, frequencyToReconstruct);
reconstructedSignal.StartingMoment = reconstructedSignal.Points[0].Item1;
reconstructedSignal.EndingMoment = reconstructedSignal.Points[reconstructedSignal.Points.Count - 1].Item1;
reconstructedSignal.CalculateTraits();
combinedSignal.Signal = reconstructedSignal;
combinedTextProperties.AverageValueText = combinedSignal.Signal.AverageValue.ToString("N3");
combinedTextProperties.AbsouluteAverageValueText = combinedSignal.Signal.AbsouluteAverageValue.ToString("N3");
combinedTextProperties.AveragePowerText = combinedSignal.Signal.AveragePower.ToString("N3");
combinedTextProperties.VarianceText = combinedSignal.Signal.Variance.ToString("N3");
combinedTextProperties.EffectiveValueText = combinedSignal.Signal.EffectiveValue.ToString("N3");
OnPropertyChanged("CombinedTextProperties");
realCombinedSeries = new ScatterSeries();
imaginaryCombinedSeries = new ScatterSeries();
foreach (Tuple <double, Complex> tuple in reconstructedSignal.Points)
{
realCombinedSeries.Points.Add(new ScatterPoint(tuple.Item1, tuple.Item2.Real));
imaginaryCombinedSeries.Points.Add(new ScatterPoint(tuple.Item1, tuple.Item2.Imaginary));
}
realCombinedSeries.MarkerType = MarkerType.Circle;
imaginaryCombinedSeries.MarkerType = MarkerType.Circle;
realCombinedSeries.MarkerSize = 1;
imaginaryCombinedSeries.MarkerSize = 1;
realCombinedSeries.MarkerFill = OxyColors.Black;
imaginaryCombinedSeries.MarkerFill = OxyColors.Black;
realPlotModel.Series.Add(realCombinedSeries);
imaginaryPlotModel.Series.Add(imaginaryCombinedSeries);
realPlotModel.InvalidatePlot(true);
imaginaryPlotModel.InvalidatePlot(true);
}
private void CombineSignals(Func <ISignal, ISignal, SignalImplementation> func, SignalTextProperties textTraits)
{
SignalImplementation outputSignal = func(firstChart.SignalRepresentation.Signal, secondChart.SignalRepresentation.Signal);
realPlotModel.Axes.Clear();
imaginaryPlotModel.Axes.Clear();
realCombinedSeries = new ScatterSeries();
imaginaryCombinedSeries = new ScatterSeries();
realCombinedSeries.MarkerType = MarkerType.Circle;
imaginaryCombinedSeries.MarkerType = MarkerType.Circle;
realCombinedSeries.MarkerFill = OxyColors.Purple;
imaginaryCombinedSeries.MarkerFill = OxyColors.Purple;
realCombinedSeries.MarkerSize = 1;
imaginaryCombinedSeries.MarkerSize = 1;
foreach (Tuple <double, Complex> tuple in outputSignal.Points)
{
realCombinedSeries.Points.Add(new ScatterPoint(tuple.Item1, tuple.Item2.Real));
imaginaryCombinedSeries.Points.Add(new ScatterPoint(tuple.Item1, tuple.Item2.Imaginary));
}
ClearPlot();
outputSignal.StartingMoment = outputSignal.Points[0].Item1;
outputSignal.EndingMoment = outputSignal.Points[outputSignal.Points.Count - 1].Item1;
outputSignal.CalculateTraits();
combinedSignal.Signal = outputSignal;
textTraits.AverageValueText = combinedSignal.Signal.AverageValue.ToString("N3");
textTraits.AbsouluteAverageValueText = combinedSignal.Signal.AbsouluteAverageValue.ToString("N3");
textTraits.AveragePowerText = combinedSignal.Signal.AveragePower.ToString("N3");
textTraits.VarianceText = combinedSignal.Signal.Variance.ToString("N3");
textTraits.EffectiveValueText = combinedSignal.Signal.EffectiveValue.ToString("N3");
OnPropertyChanged("TextProperties3");
realPlotModel.Series.Add(realCombinedSeries);
imaginaryPlotModel.Series.Add(imaginaryCombinedSeries);
realPlotModel.InvalidatePlot(true);
imaginaryPlotModel.InvalidatePlot(true);
double min = outputSignal.Points.Min(d => d.Item2.Real);
double max = outputSignal.Points.Max(d => d.Item2.Real);
double universumWidth = max - min;
double intervalWidth = universumWidth / NumberOfIntervals;
int[] histogramUniversum = new int[NumberOfIntervals];
for (int k = 0; k < outputSignal.Points.Count; k++)
{
int interval = (int)Math.Floor((outputSignal.Points[k].Item2.Real - min) / (intervalWidth + 0.0001));
histogramUniversum[interval]++;
}
List <int> realHisogramUniversum = histogramUniversum.ToList();
realCombinedHistogramSeries = new ColumnSeries();
foreach (int elem in realHisogramUniversum)
{
realCombinedHistogramSeries.Items.Add(new ColumnItem(elem));
}
realHistogramPlotModel.Axes.Clear();
realHistogramPlotModel.Series.Clear();
realCombinedHistogramSeries.FillColor = OxyColors.Purple;
realHistogramPlotModel.Series.Add(realCombinedHistogramSeries);
realHistogramPlotModel.InvalidatePlot(true);
firstChart.SignalRepresentation.Signal = null;
secondChart.SignalRepresentation.Signal = null;
}
