public SampledSignal LoadFromFile(string filePath)
        {
            using (BinaryReader reader = new BinaryReader(File.OpenRead(filePath)))
            {
                SampledSignal signal = new SampledSignal();
                signal.PointsY   = new List <double>();
                signal.StartTime = reader.ReadDouble();
                signal.Frequency = reader.ReadDouble();
                signal.Type      = reader.ReadByte();

                int length = reader.ReadInt32();
                for (int i = 0; i < length; i++)
                {
                    signal.PointsY.Add(reader.ReadDouble());
                }

                signal.CalculateSamplesX();
                return(signal);
            }
        }
Example #2
0
        public void AddSignal()
        {
            SignalGenerator generator = new SignalGenerator()
            {
                Amplitude   = A,
                FillFactor  = Kw,
                Period      = T,
                StartTime   = T1,
                JumpTime    = Ts,
                JumpN       = Ns,
                Probability = P
            };
            List <double> pointsX = new List <double>();
            List <double> pointsY = new List <double>();
            List <double> samples = new List <double>();

            Func <double, double> func = null;

            switch (SelectedSignalType.Substring(1, 3))
            {
            case "S00":
                func = generator.GenerateSignalForTransform;
                break;

            case "S01":
                func = generator.GenerateUniformDistributionNoise;
                break;

            case "S02":
                func = generator.GenerateGaussianNoise;
                break;

            case "S03":
                func = generator.GenerateSinusoidalSignal;
                break;

            case "S04":
                func = generator.GenerateSinusoidal1PSignal;
                break;

            case "S05":
                func = generator.GenerateSinusoidal2PSignal;
                break;

            case "S06":
                func = generator.GenerateRectangularSignal;
                break;

            case "S07":
                func = generator.GenerateRectangularSymmetricalSignal;
                break;

            case "S08":
                func = generator.GenerateTriangularSignal;
                break;

            case "S09":
                func = generator.GenerateUnitJump;
                break;

            case "S10":
                func = generator.GenerateUnitPulse;
                break;

            case "S11":
                func = generator.GenerateImpulseNoise;
                break;
            }


            if (func != null)
            {
                generator.Func = func;
                if (func.Method.Name.Contains("GenerateUnitPulse"))
                {
                    for (double i = N1 * F; i <= (D + N1) * F; i++)
                    {
                        pointsX.Add(i / F);
                        pointsY.Add(func(i / F));
                    }

                    SampledSignal signal = new SampledSignal();
                    signal.Frequency = F;
                    signal.StartTime = N1;
                    signal.PointsY   = pointsY;
                    signal.PointsX   = pointsX;
                    signal.Name      = SignalName + " - S";
                    AddSignal(signal);
                }
                else if (func.Method.Name.Contains("GenerateImpulseNoise"))
                {
                    for (double i = N1; i <= D + N1; i += 1 / F)
                    {
                        pointsX.Add(i);
                        pointsY.Add(func(0));
                    }

                    SampledSignal signal = new SampledSignal();
                    signal.Frequency = F;
                    signal.StartTime = N1;
                    signal.PointsY   = pointsY;
                    signal.PointsX   = pointsX;
                    signal.Name      = SignalName + " - S";
                    AddSignal(signal);
                }
                else
                {
                    if (IsContinuous)
                    {
                        for (double i = T1; i < T1 + D; i += D / 5000)
                        {
                            pointsX.Add(i);
                            pointsY.Add(func(i));
                        }
                        ContinuousSignal signal = new ContinuousSignal();
                        signal.PointsY = pointsY;
                        signal.PointsX = pointsX;
                        signal.Name    = SignalName + " - C";
                        AddSignal(signal);
                    }
                    if (IsSampled)
                    {
                        for (double i = T1; i < T1 + D; i += 1 / Fp)
                        {
                            samples.Add(func(i));
                        }
                        SampledSignal signal = new SampledSignal();
                        signal.Frequency = Fp;
                        signal.StartTime = T1;
                        signal.PointsY   = samples;
                        signal.Name      = SignalName + " - S";
                        signal.CalculateSamplesX();
                        AddSignal(signal);
                    }
                }
            }
        }
        public void ComputeSignals()
        {
            if (SelectedSignal1 != null && SelectedSignal2 != null)
            {
                if (IsComplex)
                {
                    SampledSignal  signal = new SampledSignal();
                    List <Complex> points = new List <Complex>();

                    switch (SelectedOperation.Substring(1, 2))
                    {
                    case "D1":
                        points = SignalOperations.AddComplexSignals(SelectedSignal1.ComplexPoints,
                                                                    SelectedSignal2.ComplexPoints);
                        break;

                    case "D2":
                        points = SignalOperations.SubtractComplexSignals(SelectedSignal1.ComplexPoints,
                                                                         SelectedSignal2.ComplexPoints);
                        break;

                    case "D3":
                        points = SignalOperations.MultiplyComplexSignals(SelectedSignal1.ComplexPoints,
                                                                         SelectedSignal2.ComplexPoints);
                        break;

                    case "D4":
                        points = SignalOperations.DivideComplexSignals(SelectedSignal1.ComplexPoints,
                                                                       SelectedSignal2.ComplexPoints);
                        break;
                    }
                    signal.ComplexPoints = points;
                    signal.Name          = ResultSignalName + " - S [Complex]";
                    SignalCreator.Signals.Add(signal);
                    SignalCreator.SampledSignals.Add(signal);
                }
                else
                {
                    if (!SelectedSignal2.IsValid(SelectedSignal2))
                    {
                        MessageBox.Show("Given signals are not valid", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
                        return;
                    }
                    SampledSignal signal  = new SampledSignal();
                    List <double> pointsY = new List <double>();

                    switch (SelectedOperation.Substring(1, 2))
                    {
                    case "D1":
                        pointsY = SignalOperations.AddSignals(SelectedSignal1.PointsY,
                                                              SelectedSignal2.PointsY);
                        break;

                    case "D2":
                        pointsY = SignalOperations.SubtractSignals(SelectedSignal1.PointsY,
                                                                   SelectedSignal2.PointsY);
                        break;

                    case "D3":
                        pointsY = SignalOperations.MultiplySignals(SelectedSignal1.PointsY,
                                                                   SelectedSignal2.PointsY);
                        break;

                    case "D4":
                        pointsY = SignalOperations.DivideSignals(SelectedSignal1.PointsY,
                                                                 SelectedSignal2.PointsY);
                        break;
                    }
                    signal.PointsY   = pointsY;
                    signal.StartTime = SelectedSignal1.StartTime;
                    signal.Frequency = SelectedSignal1.Frequency;
                    signal.CalculateSamplesX();
                    signal.Name = ResultSignalName + " - S";
                    SignalCreator.Signals.Add(signal);
                    SignalCreator.SampledSignals.Add(signal);
                }
            }
        }