PgBlowingExtVm.cs

using FLY.Thick.Blowing.IService;
using GalaSoft.MvvmLight.Command;
using LiveCharts;
using LiveCharts.Configurations;
using LiveCharts.Wpf;
using Microsoft.Win32;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Media;

namespace FLY.Thick.Blowing360.UI
{
    public class PgBlowingExtVm : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;

        #region 曲线


        /// <summary>
        /// 画在图上的 速度曲线，限制最多100个数据
        /// </summary>
        public ChartValues<TimeValue> VelocityValues { get; } = new ChartValues<TimeValue>();
        /// <summary>
        /// 画在图上的 厚度曲线，限制最多100个数据
        /// </summary>
        public ChartValues<TimeValue> ThicknessValues { get; } = new ChartValues<TimeValue>();

        /// <summary>
        /// 画在图上的 角度增量曲线，限制最多100个数据
        /// </summary>
        public ChartValues<TimeValue> AngleValues { get; } = new ChartValues<TimeValue>();


        /// <summary>
        /// 转换为分区号单位的 每幅图
        /// </summary>
        public SeriesCollection FrameSeries { get; } = new SeriesCollection();
        public List<AxisSection> LimitSections { get; } = new List<AxisSection>();

        #endregion

        #region 参数

        /// <summary>
        /// 需要 旋转角度增量曲线
        /// </summary>
        public bool IsRPosMode { get; set; }
        /// <summary>
        /// 膜距离
        /// </summary>
        public double FilmLength { get; set; }

        /// <summary>
        /// 膜距离查找范围 m
        /// </summary>
        public int FLRange { get; set; } = 5;

        /// <summary>
        /// 速度滤波 s
        /// </summary>
        public int VelocityFilter { get; set; }

        /// <summary>
        /// 牵引1速度
        /// </summary>
        public double Velocity1 { get; set; }
        #endregion

        #region 状态
        public double VAvg { get; private set; }
        public double VMax { get; private set; }
        public double VMin { get; private set; }

        public double FAvg { get; private set; }
        public double FMax { get; private set; }
        public double FMin { get; private set; }

        #endregion
        #region 界面
        /// <summary>
        /// y轴格式
        /// </summary>
        public Func<double, string> YFormatter { get; set; }

        /// <summary>
        /// X轴格式
        /// </summary>
        public Func<double, string> DateTimeFormatter { get; set; }

        /// <summary>
        /// 分区号X轴格式
        /// </summary>
        public Func<double, string> BoltNoFormatter { get; set; }

        public CartesianMapper<TimeValue> MapperTv { get; set; }

        #endregion
        #region Command
        public RelayCommand DownloadCmd { get; private set; }
        public RelayCommand UpdateVCmd { get; private set; }


        public RelayCommand UpdateFramesCmd { get; private set; }

        public RelayCommand CalCmd { get; private set; }

        public RelayCommand ApplyFilmLengthCmd { get; private set; }

        public RelayCommand SaveCmd { get; private set; }

        public RelayCommand LoadCmd { get; private set; }
        #endregion

        public CalFilmLen360 Cfl { get; set; }
        IBlowingFixService blowing;
        IBlowingDetectService rdetect;

        public PgBlowingExtVm()
        {
            #region 界面配置
            MapperTv = Mappers.Xy<TimeValue>()
                .X(value => value.Time.Ticks)
                .Y(value => value.Value);

            DateTimeFormatter = value => new DateTime((long)value).ToString("HH:mm:ss");
            BoltNoFormatter = value => (value + 1).ToString();
            YFormatter = value => value.ToString("F1");

            #endregion

            DownloadCmd = new RelayCommand(Download);
            UpdateVCmd = new RelayCommand(UpdateVelocity);
            UpdateFramesCmd = new RelayCommand(UpdateFrames);
            CalCmd = new RelayCommand(Cal);
            ApplyFilmLengthCmd = new RelayCommand(ApplyFilmLength);
            SaveCmd = new RelayCommand(Save);
            LoadCmd = new RelayCommand(Load);
        }

        public void Init(IBlowingFixService blowing, IBlowingDetectService rdetect)
        {
            this.rdetect = rdetect;
            this.blowing = blowing;

            Cfl = new CalFilmLen360();
            Cfl.Init(blowing, rdetect);


            Misc.BindingOperations.SetBinding(Cfl, nameof(Cfl.IsRPosMode), this, nameof(IsRPosMode));

            Misc.BindingOperations.SetBinding(Cfl, nameof(Cfl.FilmLength), this, nameof(FilmLength));
            Misc.BindingOperations.SetBinding(Cfl, nameof(Cfl.VelocityFilter), this, nameof(VelocityFilter));
            Misc.BindingOperations.SetBinding(Cfl, nameof(Cfl.Velocity1), this, nameof(Velocity1));
            

            Cfl.PropertyChanged += CalFilmLen_PropertyChanged;
        }



        private void CalFilmLen_PropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            if (e.PropertyName == nameof(Cfl.LimitValues))
            {
                var vList = Cfl.LimitValues;

                LimitSections.Clear();
                for (int i = 0; i < vList.Count(); i++) {

                    var value = vList[i]; 
                    var axisSection = new AxisSection()
                    {
                        StrokeThickness = 1,
                        DataLabel = true,
                        DisableAnimations = true,
                        DataLabelForeground = new SolidColorBrush(Colors.White),
                        Opacity = 1,
                        Stroke = new SolidColorBrush(Colors.Orange),
                    };
                    if (value.Value == 1)
                        axisSection.Stroke = new SolidColorBrush(Colors.DarkBlue);
                    axisSection.Value = value.Time.Ticks;
                    LimitSections.Add(axisSection);
                }
                
            }
            else if (e.PropertyName == nameof(Cfl.VelocityValues))
            {
                var vList = Cfl.VelocityValues;

                VAvg = vList.Average(tv => tv.Value);
                VMax = vList.Max(tv => tv.Value);
                VMin = vList.Min(tv => tv.Value);

                var newList = GetLimitedList(vList,200);

                VelocityValues.Clear();
                VelocityValues.AddRange(newList);
            }
            else if (e.PropertyName == nameof(Cfl.ThicknessValues))
            {
                var vList = Cfl.ThicknessValues;
                var newList = GetLimitedList(vList, 200);

                ThicknessValues.Clear();
                ThicknessValues.AddRange(newList);
            }
            else if (e.PropertyName == nameof(Cfl.AngleValues))
            {
                var vList = Cfl.AngleValues;
                var newList = GetLimitedList(vList, 200);

                AngleValues.Clear();
                AngleValues.AddRange(newList);
            }
            else if (e.PropertyName == nameof(Cfl.Frames))
            {
                FrameSeries.Clear();
                for (int i = 0; i < Cfl.Frames.Count(); i++)
                {

                    var frame = Cfl.Frames[i];
                    string title = $"{((frame.Direction == Misc.DIRECTION.FORWARD) ? "正" : "反")}" +
                        $" [{frame.RotationCnt}]";
                    if (frame.IsVaild)
                        title += $" R={frame.R:F3}";
                    FrameSeries.Add(
                        new LineSeries()
                        {
                            Title = title,
                            Values = new ChartValues<double>(frame.Thicks),
                            LineSmoothness = 1,
                            StrokeThickness = 3,
                            PointGeometrySize = 0
                        });
                }
            }
        }

        /// <summary>
        /// 从原始数据队列平均获取100个数据
        /// </summary>
        /// <param name="orgList"></param>
        /// <returns></returns>
        protected List<T> GetLimitedList<T>(List<T> orgList, int limitCnt) {
            var tList = orgList;
            var newList = new List<T>();
            if (tList.Count < limitCnt) 
            {
                limitCnt = tList.Count;
            }

            for (int i = 0; i < limitCnt; i++)
            {
                int idx = tList.Count() * i / limitCnt;
                if (idx >= tList.Count()) idx = tList.Count() - 1;
                newList.Add(tList[idx]);

            }
            return newList;
        }

        public void Download()
        {
            Cfl.DownloadData();
        }
        public void UpdateVelocity()
        {
            Cfl.UpdateVelocityValues(VelocityFilter);
        }

        public void UpdateFrames()
        {
            Cfl.SetFilmLength(FilmLength);
        }

        public void Cal()
        {
            Cfl.Cal(FilmLength - FLRange, FilmLength + FLRange);
        }

        public void ApplyFilmLength()
        {
            rdetect.FilmLength = FilmLength;
            rdetect.Apply();
            FLY.ControlLibrary.Window_Tip.Show(
                "应用成功",
                $"膜距离 设置为{FilmLength:F1}m",
                TimeSpan.FromSeconds(2));
        }

        public void Save()
        {
            SaveFileDialog sfd = new SaveFileDialog();
            sfd.FileName = $"{DateTime.Now:yyyyMMdd_HHmmss}.json";
            if (sfd.ShowDialog() == true)
            {
                Cfl.Save(sfd.FileName);
                FLY.ControlLibrary.Window_Tip.Show(
                    "保存成功",
                    $"保存到{sfd.FileName}",
                    TimeSpan.FromSeconds(2));
            }
        }
        public void Load()
        {
            OpenFileDialog ofd = new OpenFileDialog();
            ofd.DefaultExt = ".json";
            if (ofd.ShowDialog() == true)
            {
                Cfl.Load(ofd.FileName);
                FLY.ControlLibrary.Window_Tip.Show(
                    "加载成功",
                    $"读取 {ofd.FileName}",
                    TimeSpan.FromSeconds(2));
            }
        }
    }


    public class TimeValue : INotifyPropertyChanged
    {
        public DateTime Time { get; set; }

        public double Value { get; set; }

        public event PropertyChangedEventHandler PropertyChanged;
    }
}