Shaker/Avalonia/ShakerApp/ViewModels/MainPage/SineMainPageViewModel.cs

using Avalonia.Collections;
using Avalonia.Controls;
using OxyPlot;
using OxyPlot.Series;
using Shaker.Model;
using Shaker.Model.Tools;
using Shaker.Models;
using ShakerApp.Tools;
using ShakerApp.Views;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ShakerApp.ViewModels
{
    internal class SineMainPageViewModel : ViewModelBase<SineDataModel>, IMainPageViewModel
    {
        List<OxyColor> oxyColors = new List<OxyColor>() {OxyColors.Black, OxyColors.Green, OxyColors.Red, OxyColors.Red, OxyColors.Yellow, OxyColors.Yellow };
        List<LineStyle> lineStyles = new List<LineStyle>() {LineStyle.Solid, LineStyle.Solid, LineStyle.Solid, LineStyle.Solid, LineStyle.LongDashDotDot, LineStyle.LongDashDotDot };
        List<string> properties = new List<string>() {nameof(SweepData.Acceleration), nameof(SweepData.TargetAcceleration), nameof(SweepData.UpStopAcceleration), nameof(SweepData.DownStopAcceleration), nameof(SweepData.UpWarnAcceleration), nameof(SweepData.DownWarnAcceleration) };
        List<SweepData> datas = new List<SweepData>();

        OxyPlot.Annotations.ArrowAnnotation arrowAnnotation = new OxyPlot.Annotations.ArrowAnnotation();
        public AvaloniaList<LineSeries> LineSeries { get; } = new AvaloniaList<LineSeries>();
        private SineMainPageViewModel()
        {
            #region 加速度谱曲线
            PlotModel.Axes.Add(new OxyPlot.Axes.LogarithmicAxis()
            {
                MaximumPadding = 0,
                MinimumPadding = 0,
                Title = App.Current?.FindResource(Shaker.Model.ShakerConstant.FrequencyKey) + "",
                Unit = "Hz",
                MajorGridlineStyle = LineStyle.Solid,
                Position = OxyPlot.Axes.AxisPosition.Bottom,
                Key = "Freq"
            });
            PlotModel.Axes.Add(new OxyPlot.Axes.LogarithmicAxis()
            {
                Key = "Ampt",
                Title = App.Current?.FindResource(ShakerConstant.AmptAxisTitleKey) + "",
                Unit = "g",
                MajorGridlineStyle = LineStyle.Solid,
                Position = OxyPlot.Axes.AxisPosition.Left,
            });
            PlotModel.Title = App.Current?.FindResource(ShakerConstant.AccelerationSpectrumKey) + "";

            for (int i = 0; i < oxyColors.Count; i++)
            {
                LineSeries line = new LineSeries();
                line.Title = App.Current?.FindResource(ShakerConstant.ShowSweepAccelerationSpectrumNames[i]) + "";
                line.Color = oxyColors[i];
                line.StrokeThickness = 1;
                line.DataFieldX = nameof(SweepData.Frequency);
                line.DataFieldY = properties[i];
                line.LineStyle = lineStyles[i];
                line.XAxisKey = "Freq";
                line.YAxisKey = "Ampt";
                LineSeries.Add(line);
                PlotModel.Series.Add(line);
            }
            PlotModel.Annotations.Add(arrowAnnotation);
            arrowAnnotation.Selectable = false;
            arrowAnnotation.SelectionMode = OxyPlot.SelectionMode.Single;
            arrowAnnotation.Text = "Test";
            arrowAnnotation.TextColor = OxyColors.Transparent;
            arrowAnnotation.StartPoint = new DataPoint(8, 4);
            arrowAnnotation.EndPoint = new DataPoint();
            arrowAnnotation.Color = OxyColors.Transparent;
            PlotModel.Legends.Add(new OxyPlot.Legends.Legend()
            {
                ShowInvisibleSeries = true,
            });
            PlotModel.Title = App.Current?.FindResource(MainPageType.SinePage.Description()) + "";
            #endregion
            GetEvent(ShakerSettingViewModel.LANGUAGECHANGEDEVENT).Subscrip((_, _) =>
            {
                PlotModel.InvalidatePlot(false);
                PlotModel.Title = App.Current?.FindResource(MainPageType.SinePage.Description()) + "";
                PlotModel.Axes[0].Title = App.Current?.FindResource("Frequency") + "";
                PlotModel.Axes[1].Title = Title = App.Current?.FindResource("Ampt") + "";
                for(int i=0;i<LineSeries.Count;i++)
                {
                    LineSeries[i].Title = App.Current?.FindResource(ShakerConstant.ShowSweepAccelerationSpectrumNames[i]) + "";
                }
                PlotModel.InvalidatePlot(true);
            });
        }
        static SineMainPageViewModel()
        {

        }
        public void SetRefSpectrum(List<SweepData> data)
        {
            datas.Clear();
            datas.AddRange(data);
            PlotModel.InvalidatePlot(false);
            //LineSeries[0].IsVisible = false;
            for(int i=0;i<LineSeries.Count;i++)
            {
                LineSeries[i].ItemsSource = datas;
            }
            PlotModel.InvalidatePlot(true);
        }

        public void Start()
        {
            SetRefSpectrum(SweepConfigViewModel.Instance.RefSpectrum);
        }

        public void Stop()
        {
        }

        public void UpdateData(IResultDataModel model)
        {
            if (model is SineDataModel sine)
            {
                if(sine.SweepDirection != Model.SweepDirection)
                {
                    SetRefSpectrum(SweepConfigViewModel.Instance.RefSpectrum);
                }
                UpDateModel(sine);
                uint targetacc = (uint)sine.CurrentAcceleration * 1000_1000;

                int index = -1;
                for (int i = 0; i < datas.Count; i++)
                {
                    uint tempacc = (uint)(datas[i].Acceleration * 1000_000);
                    if (tempacc == targetacc)
                    {
                        index = i;
                        datas[i].Acceleration = sine.CurrentAcceleration;
                        UpPlot();
                        return;
                    }
                    else if (tempacc > targetacc)
                    {
                        if (i > 0)
                        {
                            index = i - 1;
                        }
                        else index = 0;
                        break;
                    }
                }
                if (index == -1) index = datas.Count - 1;
                float value = 0; float upstop = 0; float upwarn = 0; float downstop = 0; float downwarn = 0;
                SweepConfigViewModel.Instance.Model.CalcAmpt(sine.CurrentFrequency, ref value, ref upstop, ref upwarn, ref downstop, ref downwarn);
                datas.Insert(index + 1, new SweepData()
                {
                    Acceleration = sine.CurrentAcceleration,
                    Frequency = sine.CurrentFrequency,
                    TargetAcceleration = value,
                    UpStopAcceleration = upstop,
                    UpWarnAcceleration = upwarn,
                    DownStopAcceleration = downstop,
                    DownWarnAcceleration = downwarn,
                });
                UpPlot();
            }
        }
        private void UpPlot()
        {
            PlotModel.InvalidatePlot(false);
            arrowAnnotation.TextColor = OxyColors.Black;
            arrowAnnotation.Color = OxyColors.Green;
            arrowAnnotation.EndPoint = new DataPoint(CurrentFrequency, CurrentAcceleration);
            arrowAnnotation.StartPoint = new DataPoint(CurrentFrequency, 1E-30);
            arrowAnnotation.Text = $"{App.Current?.FindResource("Frequency")}:{CurrentFrequency:F2}Hz\r\n{App.Current?.FindResource("Acceleration")}:{CurrentAcceleration:F3}g";
            arrowAnnotation.TextPosition = arrowAnnotation.EndPoint;
            arrowAnnotation.TextHorizontalAlignment = HorizontalAlignment.Left;
            arrowAnnotation.TextVerticalAlignment = VerticalAlignment.Top;
            for(int i=0;i<LineSeries.Count;i++)
            {
                LineSeries[i].ItemsSource = datas;
            }
            PlotModel.InvalidatePlot(true);
        }

        public float TotalTime { get => Model.TotalTime; set => SetProperty(ref Model.TotalTime, value); }
        public float RunTime { get => Model.RunTime; set => SetProperty(ref Model.RunTime, value); }
        public float CurrentFrequency { get => Model.CurrentFrequency; set => SetProperty(ref Model.CurrentFrequency, value); }
        public float CurrentAcceleration { get => Model.CurrentAcceleration; set => SetProperty(ref Model.CurrentAcceleration, value); }
        public SweepDirection SweepDirection { get => Model.SweepDirection; set => SetProperty(ref Model.SweepDirection, value); }
        public uint SweepIndex { get => Model.SweepIndex; set => SetProperty(ref Model.SweepIndex, value); }
        public MainPageType PageType => Model.MainPageType;

        public OxyPlot.PlotModel PlotModel { get; private set; } = new OxyPlot.PlotModel();
        public static SineMainPageViewModel Instance { get; } = new SineMainPageViewModel();

        public OxyPlot.PlotModel DriverModel { get; private set; } = new PlotModel();
    }
}