Triton_160/Common/DataAnalysisControl/Charting/View/MyLineSeries.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Abt.Controls.SciChart.Visuals.RenderableSeries;
using System.ComponentModel;
using System.Windows.Media;
using Abt.Controls.SciChart.Model.DataSeries;
using Aitex.UI.Charting.Model;
using Aitex.UI.Charting.ViewModel;



namespace Aitex.UI.Charting.View
{
    /// <summary>
    /// Customized line series type
    /// </summary>
    public class MyLineSeries : FastLineRenderableSeries, INotifyPropertyChanged
    {
        /// <summary>
        /// 静态构造函数，用于初始化随机的默认颜色的初始值
        /// </summary>
        static MyLineSeries()
        {
            _presetColors = new List<Color>();
            _presetColors.Add(Colors.Indigo);
            _presetColors.Add(Colors.Blue);
            _presetColors.Add(Colors.DarkOrange);
            _presetColors.Add(Colors.Olive);
            _presetColors.Add(Colors.SaddleBrown);
            _presetColors.Add(Colors.DeepPink);
            _presetColors.Add(Colors.DarkGreen);
            _presetColors.Add(Colors.DarkSlateGray);
            _presetColors.Add(Colors.DarkCyan);
            _presetColors.Add(Colors.SteelBlue);
            _presetColors.Add(Colors.Maroon);
            _presetColors.Add(Colors.DarkOrchid);
            _presetColors.Add(Colors.Crimson);
            _presetColors.Add(Colors.Gray);
        }

        /// <summary>
        /// 自定义曲线的构造函数
        /// </summary>
        /// <param name="seriesName"></param>
        /// <param name="dataSource"></param>
        public MyLineSeries(string seriesName, IDataSource dataSource)
        {
            //产生一随机的GUID作为每个曲线的标志号，方便后续对曲线的查找和操作
            UniqueId = Guid.NewGuid().ToString();
            if (dataSource != null)
            {
                Points = dataSource.Datas[seriesName];
                DataSource = dataSource;            
                LastUpdateTime = dataSource.BeginTime;
            }
            XAxisId = "DefaultAxisId";      //指名x、y坐标轴，此处和xaml文件中定义需一致
            YAxisId = "DefaultAxisId";
            DataSeries = new XyDataSeries<DateTime, float>();

            SeriesName = seriesName;
            if (seriesName.Equals("firstLoad")) return;
            //默认用户显示名称为“RecipeName” +“变量名的最后段”
            string displayName = seriesName;
            var strArr = displayName.Split(new char[] { '.' }, StringSplitOptions.RemoveEmptyEntries);
            if (strArr.Length >= 2)
                displayName = string.Format("{0}_{1}", strArr[strArr.Length - 2], strArr[strArr.Length - 1]);

            string recipeName = dataSource == null ? "" : dataSource.Title;
            displayName = recipeName + "#" + displayName;
            
            DisplayName = displayName;
            SeriesDisplayName = seriesName;
            
            //产生预设10组+随机的颜色
            SeriesColor = GetRandomColor();

            NextQueryTime = DateTime.MinValue;
        }
        private string ConvertWaferDisplayName(string source)
        {
            string str = source;
            if ((source.ToLower().Contains("smart") && source.ToLower().Contains("reflect")) ||
                (source.ToLower().Contains("curvaturea") || source.ToLower().Contains("curvatureb") || source.ToLower().Contains("curvaturec") || source.ToLower().Contains("curvatured")) ||
                (source.ToLower().Contains("reflecta") || source.ToLower().Contains("reflectb") || source.ToLower().Contains("reflectc") || source.ToLower().Contains("reflectd")) ||
                (source.ToLower().Contains("tempa") || source.ToLower().Contains("tempb") || source.ToLower().Contains("tempc") || source.ToLower().Contains("tempd")))
            {
                if (!(string.IsNullOrEmpty(CommonViewModel.Instance.WaferDisplayIndex)))
                {
                    string[] mSplit = source.Split('_');
                    if (mSplit.Length >= 2)
                    {
                        int index;
                        bool result = int.TryParse(mSplit[mSplit.Length - 1], out index);
                        --index;
                        if (result)
                        {
                            List<string> _mWaferDisplayIndex = CommonViewModel.Instance.WaferDisplayIndex.Split(',').ToList();
                            for (int i = 0; i < _mWaferDisplayIndex.Count; i++)
                            {
                                if (i == index)
                                {
                                    str = mSplit[0] + "_";
                                    for (int ii = 1; ii < mSplit.Length - 1; ii++)
                                    {
                                        str += mSplit[ii] + "_";
                                    }
                                    str += _mWaferDisplayIndex[i].PadLeft(2, '0');
                                    break;
                                }
                            }
                        }
                    }
                }
            }
            return str;
        }

        /// <summary>
        /// 下一次获取数据的时间点
        /// </summary>
        public DateTime NextQueryTime { get; set; }

        /// <summary>
        /// related data source
        /// </summary>
        public IDataSource DataSource { get; private set; }

        /// <summary>
        /// intenal data of property changed
        /// </summary>
        private double _factor = 1.0;

        /// <summary>
        /// internal data of property changed
        /// </summary>
        private double _offset = 0.0;

        /// <summary>
        /// data value's factor
        /// </summary>
        public double Factor
        {
            get
            {
                return _factor;
            }
            set
            {
                if (_factor != value)
                {
                    _factor = value;
                    //genetate factor change command
                    CommonViewModel.Instance.ChangeDataDisplayFactor(UniqueId, value, _offset);
                    InvokePropertyChanged("Factor");
                }
            }
        }

        /// <summary>
        /// data value's offset
        /// </summary>
        public double Offset
        {
            get
            {
                return _offset;
            }
            set
            {
                if (_offset != value)
                {
                    _offset = value;
                    //genetate factor change command
                    CommonViewModel.Instance.ChangeDataDisplayFactor(UniqueId, _factor, value);
                    InvokePropertyChanged("Offset");
                }
            }
        }

        /// <summary>
        /// Series Name
        /// </summary>
        public string SeriesName { get; private set; }


        /// <summary>
        /// data source name of this series object
        /// </summary>
        public string DataSourceName
        {
            get
            {
                if (DataSource == null)
                    return string.Empty;
                return DataSource.Title;
            }
        }

        /// <summary>
        /// indicate the last update timestamp
        /// </summary>
        public DateTime LastUpdateTime { get; set; }

        /// <summary>
        /// internal string for display name
        /// </summary>
        private string _displayName;
        private string _serialDisplayName;

        /// <summary>
        /// series line's display name
        /// </summary>
        public string DisplayName
        {
            get
            {
                return _displayName;
            }
            set
            {
                _displayName = ConvertWaferDisplayName(value);//wafer排序映射
                if (DataSeries != null)
                {
                    if (_offset == 0)
                        DataSeries.SeriesName = string.Format("{0}   x{1}", _displayName, _factor);
                    else
                        DataSeries.SeriesName = string.Format("{0}   x{1}+{2}", _displayName, _factor, _offset);
                }
                InvokePropertyChanged("DisplayName");
            }
        }
        public string SeriesDisplayName {
            get
            {
                return _serialDisplayName;
            }
            set
            {
                _serialDisplayName = ConvertWaferDisplayName(value);//wafer排序映射
                InvokePropertyChanged("SeriesDisplayName");
            }
        }

        /// <summary>
        /// series line's thickness
        /// </summary>
        public double LineThickness
        {
            get
            {
                return StrokeThickness;
            }
            set
            {
                var i = Convert.ToInt32(value);
                if (i < 1) i = 1;
                if (i > 100) i = 100;
                StrokeThickness = i;
                InvokePropertyChanged("LineThickness");
            }
        }

        /// <summary>
        /// series object's unique id
        /// </summary>
        public string UniqueId { get; private set; }

        /// <summary>
        /// raw data points
        /// </summary>
        public DataItem Points { get; set; }

        #region Generate random color
        /// <summary>
        /// generate a random color
        /// </summary>
        private Random _colorRamdom = new Random();
        private Color GetRandomColor()
        {
            foreach (var preCo in _presetColors)
            {
                bool has = false;
                foreach (var co in CommonViewModel.Instance.RenderableSeries)
                {
                    if (co.SeriesColor == preCo)
                    {
                        has = true;
                        break;
                    }
                }
                if (!has)
                    return preCo;
            }
            byte r, g, b;
            do
            {
                _colorRamdom = new Random(Guid.NewGuid().GetHashCode());
                r = (byte)_colorRamdom.Next(255);
                _colorRamdom = new Random(Guid.NewGuid().GetHashCode());
                g = (byte)_colorRamdom.Next(255);
                _colorRamdom = new Random(Guid.NewGuid().GetHashCode());
                b = (byte)_colorRamdom.Next(255);
            } while (r + g + b < 255);
            return Color.FromArgb(0xFF, r, g, b);
        }
        /// <summary>
        /// 预先设定的颜色
        /// </summary>
        private static List<Color> _presetColors;
        #endregion

        #region PropertyChanged
        public event PropertyChangedEventHandler PropertyChanged;
        public void InvokePropertyChanged(string propertyName)
        {
            PropertyChangedEventArgs eventArgs = new PropertyChangedEventArgs(propertyName);
            PropertyChangedEventHandler changed = PropertyChanged;
            if (changed != null)
            {
                changed(this, eventArgs);
            }
        }
        public void InvokePropertyChanged()
        {
            Type t = this.GetType();
            var ps = t.GetProperties();
            foreach (var p in ps)
            {
                InvokePropertyChanged(p.Name);
            }
        }
        #endregion
    }
}