public async override Task ReloadAsync()
        {
            var calibratorApp = new CalibratorApplication(_calibrator.Results, _calibrator.Constants);
            var points        = await calibratorApp.CalculateErrorsAsync();

            Error = await AngularCalibrationErrorVM.CreateAsync(points.Flatten().ToArray());
        }
 public override void Clear()
 {
     Error = null;
 }
Esempio n. 3
0
        public static async Task <AngularCalibrationErrorVM> CreateAsync(CalibratedPoint[] points)
        {
            var vm     = new AngularCalibrationErrorVM();
            var errors = await getAverageErrors(points).ToArrayAsync();

            vm.Plots    = new PlotVM[3];
            vm.Plots[0] = new PlotVM("Средние ошибки по Inc", "Порядковый номер позиции", "Средняя ошибка",
                                     new CurveVM[2]
            {
                new CurveVM("До калибровок", Colors.Red, errors.Select((e, i) => new DataPoint(i, e.BeforeCal.X)).ToArray()),
                new CurveVM("После калибровок", Colors.Green, errors.Select((e, i) => new DataPoint(i, e.AfterCal.X)).ToArray()),
            });
            vm.Plots[1] = new PlotVM("Средние ошибки по Azi", "Порядковый номер позиции", "Средняя ошибка",
                                     new CurveVM[2]
            {
                new CurveVM("До калибровок", Colors.Red, errors.Select((e, i) => new DataPoint(i, e.BeforeCal.Y)).ToArray()),
                new CurveVM("После калибровок", Colors.Green, errors.Select((e, i) => new DataPoint(i, e.AfterCal.Y)).ToArray()),
            });
            vm.Plots[2] = new PlotVM("Средние ошибки по GTF", "Порядковый номер позиции", "Средняя ошибка",
                                     new CurveVM[2]
            {
                new CurveVM("До калибровок", Colors.Red, errors.Select((e, i) => new DataPoint(i, e.BeforeCal.Z)).ToArray()),
                new CurveVM("После калибровок", Colors.Green, errors.Select((e, i) => new DataPoint(i, e.AfterCal.Z)).ToArray()),
            });
            var incAvgErrBefore = vm.Plots[0].Curves[0].Points.Select(p => p.Y).Average();
            var aziAvgErrBefore = vm.Plots[1].Curves[0].Points.Select(p => p.Y).Average();
            var gtfAvgErrBefore = vm.Plots[2].Curves[0].Points.Select(p => p.Y).Average();
            var incAvgErrAfter  = vm.Plots[0].Curves[1].Points.Select(p => p.Y).Average();
            var aziAvgErrAfter  = vm.Plots[1].Curves[1].Points.Select(p => p.Y).Average();
            var gtfAvgErrAfter  = vm.Plots[2].Curves[1].Points.Select(p => p.Y).Average();

            var hasProblem = false;
            var msg        = "Обнаружено ухудшение характеристик по углу {0}";

            if (incAvgErrAfter.Abs() > incAvgErrBefore.Abs())
            {
                Logger.LogWarningEverywhere(msg.Format("Inc"));
                hasProblem = true;
            }
            if (aziAvgErrAfter.Abs() > aziAvgErrBefore.Abs())
            {
                Logger.LogWarningEverywhere(msg.Format("Azi"));
                hasProblem = true;
            }
            if (gtfAvgErrAfter.Abs() > gtfAvgErrBefore.Abs())
            {
                Logger.LogWarningEverywhere(msg.Format("GTF"));
                hasProblem = true;
            }
            if (hasProblem)
            {
                Logger.LogWarningEverywhere($"Угловая калибровка проведена некачественно");
            }

            vm.ParametersGroups = new Dictionary <string, NameValuePair <double>[]>
            {
                {
                    "До калибровки",
                    new NameValuePair <double>[]
                    {
                        new NameValuePair <double>("Средняя ошибка по Inc", "°", new DoubleValueVM(_ => true, v => v.Round(3))
                        {
                            ModelValue = incAvgErrBefore
                        }),
                        new NameValuePair <double>("Средняя ошибка по Azi", "°", new DoubleValueVM(_ => true, v => v.Round(3))
                        {
                            ModelValue = aziAvgErrBefore
                        }),
                        new NameValuePair <double>("Средняя ошибка по GTF", "°", new DoubleValueVM(_ => true, v => v.Round(3))
                        {
                            ModelValue = gtfAvgErrBefore
                        })
                    }
                },
                {
                    "После калибровки",
                    new NameValuePair <double>[]
                    {
                        new NameValuePair <double>("Средняя ошибка по Inc", "°", new DoubleValueVM(_ => true, v => v.Round(3))
                        {
                            ModelValue = incAvgErrAfter
                        }),
                        new NameValuePair <double>("Средняя ошибка по Azi", "°", new DoubleValueVM(_ => true, v => v.Round(3))
                        {
                            ModelValue = aziAvgErrAfter
                        }),
                        new NameValuePair <double>("Средняя ошибка по GTF", "°", new DoubleValueVM(_ => true, v => v.Round(3))
                        {
                            ModelValue = gtfAvgErrAfter
                        })
                    }
                }
            };

            return(vm);
        }