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

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

namespace ShakerApp.ViewModels
{
    internal class RandomMainPageViewModel:BaseMainPageViewModel<RandomDataModel>
    {
        [PropertyAssociation(nameof(RandomDataModel.CurrentIdentifyDisplacement))]
        public double CurrentIdentifyDisplacement => Model.CurrentIdentifyDisplacement;
        [PropertyAssociation(nameof(RandomDataModel.CurrentIdentifyRms))]
        public double CurrentIdentifyRms => Model.CurrentIdentifyRms;
        [PropertyAssociation(nameof(RandomDataModel.IdentifyIndex))]
        public double IdentifyIndex => Model.IdentifyIndex;
        [PropertyAssociation(nameof(RandomDataModel.RandomStatus))]
        public RandomStatus RandomStatus => Model.RandomStatus;
        [PropertyAssociation(nameof(RandomDataModel.TimeDomainRMS))]
        public double TimeDomainRMS => Model.TimeDomainRMS;
        [PropertyAssociation(nameof(RandomDataModel.RandomTestStep))]
        public RandomTestStep RandomTestStep => Model.RandomTestStep;
        [PropertyAssociation(nameof(RandomDataModel.RandomTestStep))]
        public string RandomTestStepKey => RandomTestStep.Description();
        [PropertyAssociation(nameof(RandomDataModel.CurrentTestLevel))]
        public double CurrentTestLevel => Model.CurrentTestLevel;
        [PropertyAssociation(nameof(RandomDataModel.CurrentTestTime))]
        public uint CurrentTestTime => Model.CurrentTestTime;
        [PropertyAssociation(nameof(RandomDataModel.CurrentLevelTestMaxTime))]
        public uint CurrentLevelTestMaxTime => Model.CurrentLevelTestMaxTime;
        public AvaloniaList<LineSeries> LineSeries { get; } = new AvaloniaList<LineSeries>();
        List<OxyColor> oxyColors = new List<OxyColor>() {OxyColors.Blue, 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.Solid, LineStyle.LongDashDotDot, LineStyle.LongDashDotDot };
        List<string> properties = new List<string>() {nameof(RandomData.Driver), nameof(RandomData.Acceleration), nameof(RandomData.TargetAcceleration), nameof(RandomData.UpStopAcceleration), nameof(RandomData.DownStopAcceleration), nameof(RandomData.UpWarnAcceleration), nameof(RandomData.DownWarnAcceleration) };
        List<RandomData> datas = new List<RandomData>();
        private RandomMainPageViewModel()
        {
            Content = typeof(Views.RandomMainPage);
            #region 加速度谱曲线
            PlotModel.Axes.Add(new OxyPlot.Axes.LogarithmicAxis()
            {
                MaximumPadding = 0,
                MinimumPadding = 0,
                Title = App.Current?.FindResource(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 = App.Current?.FindResource("RandomValueUnit")?.ToString() ?? string.Empty,
                MajorGridlineStyle = LineStyle.Solid,
                Position = OxyPlot.Axes.AxisPosition.Left,
            });
            PlotModel.Title = App.Current?.FindResource(MainPageType.RandomPage.Description()) + "";

            for (int i = 0; i < oxyColors.Count; i++)
            {
                LineSeries line = new LineSeries();
                line.Title = App.Current?.FindResource(ShakerConstant.ShowRandomAccelerationSpectrumNames[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.Legends.Add(new OxyPlot.Legends.Legend()
            {
                ShowInvisibleSeries = true,
            });
            PlotModel.Title = App.Current?.FindResource(MainPageType.RandomPage.Description()) + "";
            #endregion

            GetEvent(ShakerSettingViewModel.LANGUAGECHANGEDEVENT).Subscrip((_, _) =>
            {
                PlotModel.InvalidatePlot(false);
                PlotModel.Title = App.Current?.FindResource(MainPageType.RandomPage.Description()) + "";
                PlotModel.Axes[0].Title = App.Current?.FindResource("Frequency") + "";
                PlotModel.Axes[1].Title = Title = App.Current?.FindResource("Ampt") + "";
                PlotModel.InvalidatePlot(true);
            });
            GetEvent<AllConfig>().Subscrip((_, _) =>
            {
                CommunicationViewModel.Instance.LocalCommunication?.GetEvent<RandomDataModel>()?.Subscrip((_, args) =>
                {
                    UpdateData(new List<IResultDataModel>() { args.Data });
                    CommunicationViewModel.Instance.ServiceCommunication?.GetEvent<RandomDataModel>()?.Publish(this, args.Data);
                });
                CommunicationViewModel.Instance.LocalCommunication?.GetEvent(nameof(RandomDataModel.TransferFunction))?.Subscrip((sender, args) =>
                {
                    if (args.Data.Length > 0 && args.Data[0] is double[] func)
                    {
                        Tools.DispatherInovke.Inovke(()=> ShowTransferFunction(func));
                        CommunicationViewModel.Instance.ServiceCommunication?.GetEvent(nameof(RandomDataModel.TransferFunction))?.Publish(this, null, func);
                    }
                });
            });
        }
        private async void ShowTransferFunction(double[] data)
        {
            if (Application.Current?.ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
            {
                RandomTransferFunctionViewModel.Instance.InitData();
                RandomTransferFunctionViewModel.Instance.InitTransferFunctionData(data);
                RandomTransferFunctionViewModel.Instance.Title = "TransferFunction";
                BaseDialogWindow window = new BaseDialogWindow();
                window.DataContext = RandomTransferFunctionViewModel.Instance;
                bool isclose = false;
                RandomTransferFunctionViewModel.Instance.CloseWindowAction = () =>
                {
                    if (isclose) return;
                    isclose = true;
                    window?.Close();
                };
                await window.ShowDialog(desktop.MainWindow!);
            }
        }
        static RandomMainPageViewModel()
        {

        }
        public override void SaveTdmsConfig(Dictionary<string, string> config)
        {
            base.SaveTdmsConfig(config); 
            typeof(RandomConfigViewModel).GetFields(System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance)
                .Select(x => (x, x.GetValue(RandomConfigViewModel.Instance.Model)))
                .ToList()
                .ForEach(x =>
                {
                    if (x.Item2 == null)
                    {
                        return;
                    }
                    if (x.x.FieldType.IsAssignableTo(typeof(IList)) || x.x.FieldType.IsArray)
                    {
                        config[$"{nameof(RandomConfigViewModel)}_{x.x.Name}"] = string.Join("", x.Item2.GetBytes().Select(x => $"{x:X2}"));
                    }
                    else
                    {
                        config[$"{nameof(RandomConfigViewModel)}_{x.x.Name}"] = x.Item2?.ToString() ?? string.Empty;
                    }
                });
        }
        public override void UpdataColnumInfo()
        {
            /*
             * 保存时域信号和各加速度通道psd数据、加速度合成PSD数据和驱动PSD数据
             */
            columns = new Column[ShakerConfigViewModel.Instance.ChannelCount + ShakerConfigViewModel.Instance.AccelerationSensorCount + 2];
            for(int i=0;i<columns.Length;i++)
            {
                if(i<ShakerConfigViewModel.Instance.ChannelCount)
                {
                    columns[i] = new Column<double>($"{ShakerConfigViewModel.Instance.Model.AnalogSignalConfigs[i].Name}_{ShakerConfigViewModel.Instance.Model.AnalogSignalConfigs[i].Unit}_{ShakerConfigViewModel.Instance.Model.AnalogSignalConfigs[i].AnalogType}_{Models.DataAxisType.Linear}");
                }
                else
                {
                    columns[i] = new Column<double>($"{ShakerConfigViewModel.Instance.Model.AnalogSignalConfigs[i].Name}_{App.Current?.FindResource("RandomValueUnit")}_{""}_{Models.DataAxisType.Logarithm}");
                }
            }
        }
        public override void SaveTestData(ParquetFileWriter file)
        {
            base.SaveTestData(file);
            if (lastdata == null) return;
            var writer = file.AppendBufferedRowGroup();
            for(int i=0;i<ShakerConfigViewModel.Instance.AccelerationSensorCount;i++)
            {
                writer.Column(ShakerConfigViewModel.Instance.AnalogSignals.Count + i).LogicalWriter<double>().WriteBatch(lastdata.CurrentAccelerationPSD[i]);
            }
            writer.Column(ShakerConfigViewModel.Instance.AccelerationSensorCount + ShakerConfigViewModel.Instance.AnalogSignals.Count).LogicalWriter<double>().WriteBatch(lastdata.CurrentAccelerationSynthesisPSD);
            writer.Column(ShakerConfigViewModel.Instance.AccelerationSensorCount + ShakerConfigViewModel.Instance.Accelerations.Count + 1).LogicalWriter<double>().WriteBatch(lastdata.DriverPSD);
        }
        public override void Start()
        {
            SetRefSpectrum(RandomConfigViewModel.Instance.RefSpectrum);
        }

        public override void Stop()
        {
        }
        private RandomDataModel lastdata;
        public override void UpDateModel(RandomDataModel model)
        {
            lastdata = model;
            base.UpDateModel(model);
            int startindex = (int)(RandomConfigViewModel.Instance.MinFrequency / RandomConfigViewModel.Instance.FrequencyResolution);
            for(int i=0;i<datas.Count;i++)
            {
                datas[i].SetAcceleration(model.CurrentAccelerationSynthesisPSD[i + startindex]);
                datas[i].SetDriver(model.DriverPSD[i + startindex]);
            }
            PlotModel.InvalidatePlot(false);
            for(int i=0;i<LineSeries.Count;i++)
            {
                LineSeries[i].ItemsSource = datas;
            }
            PlotModel.InvalidatePlot(true);
        }

        public override void UpdateData(List<IResultDataModel> model)
        {
            if(model !=null &&model.Count >0 && model.First() is RandomDataModel randomdata)
            {
                UpDateModel(randomdata);
            }
        }
        public void SetRefSpectrum(List<RandomData> data)
        {
            datas.Clear();
            datas.AddRange(data);
            PlotModel.InvalidatePlot(false);
            for (int i = 0; i < LineSeries.Count; i++)
            {
                LineSeries[i].ItemsSource = datas;
            }
            PlotModel.InvalidatePlot(true);
        }
        public override MainPageType PageType => MainPageType.RandomPage;

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