Serie.cs

/************************************************/
/*                                              */
/*     Copyright (c) 2018 - 2021 monitor1394    */
/*     https://github.com/monitor1394           */
/*                                              */
/************************************************/
 
using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Serialization;
 
namespace XCharts
{
    public enum SerieType
    {
        Line,
        Bar,
        Pie,
        Radar,
        Scatter,
        EffectScatter,
        Heatmap,
        Gauge,
        Ring,
        Liquid,
        Candlestick,
        Custom,
    }
 
    public enum RoseType
    {
        None,
        Radius,
        Area
    }
 
    public enum LineType
    {
        Normal,
        Smooth,
        SmoothDash,
        StepStart,
        StepMiddle,
        StepEnd,
        Dash,
        Dot,
        DashDot,
        DashDotDot
    }
 
    public enum BarType
    {
        Normal,
        Zebra,
        Capsule
    }
 
    public enum GaugeType
    {
        Pointer,
        ProgressBar
    }
 
    public enum RadarType
    {
        Multiple,
        Single
    }
 
    public enum SampleType
    {
        Peak,
        Average,
        Max,
        Min,
        Sum
    }
 
    public enum SerieDataSortType
    {
        None,
        Ascending,
        Descending,
    }
 
    public enum Align
    {
        Center,
        Left,
        Right
    }
 
    [System.Serializable]
    public class Serie : MainComponent
    {
        [SerializeField] private bool m_Show = true;
        [SerializeField] private SerieType m_Type;
        [SerializeField] private string m_Name;
        [SerializeField] private string m_Stack;
        [SerializeField] private int m_XAxisIndex = 0;
        [SerializeField] private int m_YAxisIndex = 0;
        [SerializeField] private int m_RadarIndex = 0;
        [SerializeField] private int m_VesselIndex = 0;
        [SerializeField] private int m_PolarIndex = 0;
        [SerializeField] protected int m_MinShow;
        [SerializeField] protected int m_MaxShow;
        [SerializeField] protected int m_MaxCache;
        [SerializeField] private AreaStyle m_AreaStyle = AreaStyle.defaultAreaStyle;
        [SerializeField] private SerieSymbol m_Symbol = new SerieSymbol();
 
        [SerializeField] private float m_SampleDist = 0;
        [SerializeField] private SampleType m_SampleType = SampleType.Average;
        [SerializeField] private float m_SampleAverage = 0;
 
        [SerializeField] private LineType m_LineType = LineType.Normal;
        [SerializeField] private LineStyle m_LineStyle = new LineStyle();
 
        [SerializeField] private BarType m_BarType = BarType.Normal;
        [SerializeField] private bool m_BarPercentStack = false;
        [SerializeField] private float m_BarWidth = 0.6f;
        [SerializeField] private float m_BarGap = 0.3f; // 30%
        [SerializeField] private float m_BarCategoryGap = 0.2f; // 20%
        [SerializeField] private float m_BarZebraWidth = 4f;
        [SerializeField] private float m_BarZebraGap = 2f;
 
        [SerializeField] private float m_Min;
        [SerializeField] private float m_Max;
        [SerializeField] private float m_MinSize = 0f;
        [SerializeField] private float m_MaxSize = 1f;
        [SerializeField] private float m_StartAngle;
        [SerializeField] private float m_EndAngle;
        [SerializeField] private float m_MinAngle;
        [SerializeField] private bool m_Clockwise = true;
        [FormerlySerializedAs("m_ArcShaped")]
        [SerializeField] private bool m_RoundCap;
        [SerializeField] private float m_RingGap = 10f;
 
        [SerializeField] private int m_SplitNumber;
        [SerializeField] private GaugeType m_GaugeType = GaugeType.Pointer;
        [SerializeField] private GaugeAxis m_GaugeAxis = new GaugeAxis();
        [SerializeField] private GaugePointer m_GaugePointer = new GaugePointer();
 
        [SerializeField] private bool m_ClickOffset = true;
        [SerializeField] private RoseType m_RoseType = RoseType.None;
        [FormerlySerializedAs("m_Gap")]
        [SerializeField] private float m_Space;
        [SerializeField] private float[] m_Center = new float[2] { 0.5f, 0.45f };
        [SerializeField] private float[] m_Radius = new float[2] { 0, 80 };
        [SerializeField] private SerieLabel m_Label = new SerieLabel();
        [SerializeField] private SerieAnimation m_Animation = new SerieAnimation();
        [SerializeField] private LineArrow m_LineArrow = new LineArrow();
        [SerializeField] private ItemStyle m_ItemStyle = new ItemStyle();
        [SerializeField] private Emphasis m_Emphasis = new Emphasis();
        [SerializeField] private TitleStyle m_TitleStyle = new TitleStyle();
        [SerializeField] private IconStyle m_IconStyle = new IconStyle();
        [SerializeField] private MarkLine m_MarkLine = MarkLine.defaultMarkLine;
        [SerializeField] [Range(1, 10)] private int m_ShowDataDimension;
        [SerializeField] private bool m_ShowDataName;
        [SerializeField] private bool m_ShowDataIcon;
        [SerializeField] private bool m_Clip = false;
        [SerializeField] private bool m_Ignore = false;
        [SerializeField] private double m_IgnoreValue = 0;
        [SerializeField] private bool m_IgnoreLineBreak = false;
        [SerializeField] private bool m_ShowAsPositiveNumber = false;
        [SerializeField] private bool m_Large = true;
        [SerializeField] private int m_LargeThreshold = 200;
        [SerializeField] private bool m_AvoidLabelOverlap = false;
        [SerializeField] private float m_WaveHeight = 10f;
        [SerializeField] private float m_WaveLength = 20f;
        [SerializeField] private float m_WaveSpeed = 5f;
        [SerializeField] private float m_WaveOffset = 0f;
        [SerializeField] private RadarType m_RadarType = RadarType.Multiple;
 
        [SerializeField] private SerieDataSortType m_DataSortType = SerieDataSortType.Descending;
        [SerializeField] private Orient m_Orient = Orient.Vertical;
        [SerializeField] private Align m_Align = Align.Center;
        [SerializeField] private float m_Left;
        [SerializeField] private float m_Right;
        [SerializeField] private float m_Top;
        [SerializeField] private float m_Bottom;
        [SerializeField] private bool m_InsertDataToHead;
        [SerializeField] private bool m_CustomBool1;
        [SerializeField] private bool m_CustomBool2;
        [SerializeField] private int m_CustomInt1;
        [SerializeField] private int m_CustomInt2;
        [SerializeField] private float m_CustomFloat1;
        [SerializeField] private float m_CustomFloat2;
 
        [SerializeField] private List<SerieData> m_Data = new List<SerieData>();
 
        [NonSerialized] internal int m_FilterStart;
        [NonSerialized] internal int m_FilterEnd;
        [NonSerialized] internal double m_FilterStartValue;
        [NonSerialized] internal double m_FilterEndValue;
        [NonSerialized] internal int m_FilterMinShow;
        [NonSerialized] internal bool m_NeedUpdateFilterData;
        [NonSerialized] internal List<SerieData> m_FilterData = new List<SerieData>();
        [NonSerialized] internal List<SerieData> m_SortedData = new List<SerieData>();
        [NonSerialized] internal List<SerieData> m_RootData = new List<SerieData>();
        [NonSerialized] private Dictionary<int, List<Vector3>> m_UpSmoothPoints = new Dictionary<int, List<Vector3>>();
        [NonSerialized] private Dictionary<int, List<Vector3>> m_DownSmoothPoints = new Dictionary<int, List<Vector3>>();
        [NonSerialized] private List<Vector3> m_DataPoints = new List<Vector3>();
        [NonSerialized] private bool m_NameDirty;
 
        public bool show
        {
            get { return m_Show; }
            set { if (PropertyUtil.SetStruct(ref m_Show, value)) { SetVerticesDirty(); SetNameDirty(); } }
        }
        public SerieType type
        {
            get { return m_Type; }
            set { if (PropertyUtil.SetStruct(ref m_Type, value)) SetVerticesDirty(); }
        }
        public string name
        {
            get { return m_Name; }
            set { if (PropertyUtil.SetClass(ref m_Name, value)) { SetVerticesDirty(); SetNameDirty(); } }
        }
        public string legendName { get { return string.IsNullOrEmpty(name) ? ChartCached.IntToStr(index) : name; } }
        public string stack
        {
            get { return m_Stack; }
            set { if (PropertyUtil.SetClass(ref m_Stack, value)) SetVerticesDirty(); }
        }
        public int xAxisIndex
        {
            get { return m_XAxisIndex; }
            set { if (PropertyUtil.SetStruct(ref m_XAxisIndex, value)) SetVerticesDirty(); }
        }
        public int yAxisIndex
        {
            get { return m_YAxisIndex; }
            set { if (PropertyUtil.SetStruct(ref m_YAxisIndex, value)) SetVerticesDirty(); }
        }
        public int radarIndex
        {
            get { return m_RadarIndex; }
            set { if (PropertyUtil.SetStruct(ref m_RadarIndex, value)) SetVerticesDirty(); }
        }
        public int vesselIndex
        {
            get { return m_VesselIndex; }
            set { if (PropertyUtil.SetStruct(ref m_VesselIndex, value)) SetVerticesDirty(); }
        }
        public int polarIndex
        {
            get { return m_PolarIndex; }
            set { if (PropertyUtil.SetStruct(ref m_PolarIndex, value)) SetVerticesDirty(); }
        }
        public int minShow
        {
            get { return m_MinShow; }
            set { if (PropertyUtil.SetStruct(ref m_MinShow, value < 0 ? 0 : value)) { SetVerticesDirty(); } }
        }
        public int maxShow
        {
            get { return m_MaxShow; }
            set { if (PropertyUtil.SetStruct(ref m_MaxShow, value < 0 ? 0 : value)) { SetVerticesDirty(); } }
        }
        public int maxCache
        {
            get { return m_MaxCache; }
            set { if (PropertyUtil.SetStruct(ref m_MaxCache, value < 0 ? 0 : value)) { SetVerticesDirty(); } }
        }
        public AreaStyle areaStyle
        {
            get { return m_AreaStyle; }
            set { if (PropertyUtil.SetClass(ref m_AreaStyle, value, true)) SetVerticesDirty(); }
        }
        public SerieSymbol symbol
        {
            get { return m_Symbol; }
            set { if (PropertyUtil.SetClass(ref m_Symbol, value, true)) SetVerticesDirty(); }
        }
        public LineType lineType
        {
            get { return m_LineType; }
            set { if (PropertyUtil.SetStruct(ref m_LineType, value)) SetVerticesDirty(); }
        }
        public float sampleDist
        {
            get { return m_SampleDist; }
            set { if (PropertyUtil.SetStruct(ref m_SampleDist, value < 0 ? 0 : value)) SetVerticesDirty(); }
        }
        public SampleType sampleType
        {
            get { return m_SampleType; }
            set { if (PropertyUtil.SetStruct(ref m_SampleType, value)) SetVerticesDirty(); }
        }
        public float sampleAverage
        {
            get { return m_SampleAverage; }
            set { if (PropertyUtil.SetStruct(ref m_SampleAverage, value)) SetVerticesDirty(); }
        }
        public LineStyle lineStyle
        {
            get { return m_LineStyle; }
            set { if (PropertyUtil.SetClass(ref m_LineStyle, value, true)) SetVerticesDirty(); }
        }
        public BarType barType
        {
            get { return m_BarType; }
            set { if (PropertyUtil.SetStruct(ref m_BarType, value)) SetVerticesDirty(); }
        }
        public bool barPercentStack
        {
            get { return m_BarPercentStack; }
            set { if (PropertyUtil.SetStruct(ref m_BarPercentStack, value)) SetVerticesDirty(); }
        }
        public float barWidth
        {
            get { return m_BarWidth; }
            set { if (PropertyUtil.SetStruct(ref m_BarWidth, value)) SetVerticesDirty(); }
        }
        public float barGap
        {
            get { return m_BarGap; }
            set { if (PropertyUtil.SetStruct(ref m_BarGap, value)) SetVerticesDirty(); }
        }
        public float barCategoryGap
        {
            get { return m_BarCategoryGap; }
            set { if (PropertyUtil.SetStruct(ref m_BarCategoryGap, value)) SetVerticesDirty(); }
        }
        public float barZebraWidth
        {
            get { return m_BarZebraWidth; }
            set { if (PropertyUtil.SetStruct(ref m_BarZebraWidth, value < 0 ? 0 : value)) SetVerticesDirty(); }
        }
        public float barZebraGap
        {
            get { return m_BarZebraGap; }
            set { if (PropertyUtil.SetStruct(ref m_BarZebraGap, value < 0 ? 0 : value)) SetVerticesDirty(); }
        }
 
        public bool pieClickOffset
        {
            get { return m_ClickOffset; }
            set { if (PropertyUtil.SetStruct(ref m_ClickOffset, value)) SetVerticesDirty(); }
        }
        public RoseType pieRoseType
        {
            get { return m_RoseType; }
            set { if (PropertyUtil.SetStruct(ref m_RoseType, value)) SetVerticesDirty(); }
        }
        public float pieSpace
        {
            get { return m_Space; }
            set { if (PropertyUtil.SetStruct(ref m_Space, value)) SetVerticesDirty(); }
        }
        public float gap
        {
            get { return m_Space; }
            set { if (PropertyUtil.SetStruct(ref m_Space, value)) SetVerticesDirty(); }
        }
        public float[] center
        {
            get { return m_Center; }
            set { if (value != null && value.Length == 2) { m_Center = value; SetVerticesDirty(); } }
        }
        public float[] radius
        {
            get { return m_Radius; }
            set { if (value != null && value.Length == 2) { m_Radius = value; SetVerticesDirty(); } }
        }
        public float min
        {
            get { return m_Min; }
            set { if (PropertyUtil.SetStruct(ref m_Min, value)) SetVerticesDirty(); }
        }
        public float max
        {
            get { return m_Max; }
            set { if (PropertyUtil.SetStruct(ref m_Max, value)) SetVerticesDirty(); }
        }
        public float minSize
        {
            get { return m_MinSize; }
            set { if (PropertyUtil.SetStruct(ref m_MinSize, value)) SetVerticesDirty(); }
        }
        public float maxSize
        {
            get { return m_MaxSize; }
            set { if (PropertyUtil.SetStruct(ref m_MaxSize, value)) SetVerticesDirty(); }
        }
        public float startAngle
        {
            get { return m_StartAngle; }
            set { if (PropertyUtil.SetStruct(ref m_StartAngle, value)) SetVerticesDirty(); }
        }
        public float endAngle
        {
            get { return m_EndAngle; }
            set { if (PropertyUtil.SetStruct(ref m_EndAngle, value)) SetVerticesDirty(); }
        }
        public float minAngle
        {
            get { return m_MinAngle; }
            set { if (PropertyUtil.SetStruct(ref m_MinAngle, value)) SetVerticesDirty(); }
        }
        public bool clockwise
        {
            get { return m_Clockwise; }
            set { if (PropertyUtil.SetStruct(ref m_Clockwise, value)) SetVerticesDirty(); }
        }
 
        public float ringGap
        {
            get { return m_RingGap; }
            set { if (PropertyUtil.SetStruct(ref m_RingGap, value)) SetVerticesDirty(); }
        }
        public int splitNumber
        {
            get { return m_SplitNumber; }
            set { if (PropertyUtil.SetStruct(ref m_SplitNumber, value > 36 ? 36 : value)) SetVerticesDirty(); }
        }
        public bool roundCap
        {
            get { return m_RoundCap; }
            set { if (PropertyUtil.SetStruct(ref m_RoundCap, value)) SetVerticesDirty(); }
        }
        public bool ignore
        {
            get { return m_Ignore; }
            set { if (PropertyUtil.SetStruct(ref m_Ignore, value)) SetVerticesDirty(); }
        }
        public double ignoreValue
        {
            get { return m_IgnoreValue; }
            set { if (PropertyUtil.SetStruct(ref m_IgnoreValue, value)) SetVerticesDirty(); }
        }
        public bool ignoreLineBreak
        {
            get { return m_IgnoreLineBreak; }
            set { if (PropertyUtil.SetStruct(ref m_IgnoreLineBreak, value)) SetVerticesDirty(); }
        }
        public RadarType radarType
        {
            get { return m_RadarType; }
            set { if (PropertyUtil.SetStruct(ref m_RadarType, value)) SetVerticesDirty(); }
        }
        public GaugeAxis gaugeAxis
        {
            get { return m_GaugeAxis; }
            set { if (PropertyUtil.SetClass(ref m_GaugeAxis, value, true)) SetVerticesDirty(); }
        }
        public GaugePointer gaugePointer
        {
            get { return m_GaugePointer; }
            set { if (PropertyUtil.SetClass(ref m_GaugePointer, value, true)) SetVerticesDirty(); }
        }
        public GaugeType gaugeType
        {
            get { return m_GaugeType; }
            set { if (PropertyUtil.SetStruct(ref m_GaugeType, value)) SetVerticesDirty(); }
        }
        public SerieLabel label
        {
            get { return m_Label; }
            set { if (PropertyUtil.SetClass(ref m_Label, value, true)) SetAllDirty(); }
        }
        public SerieAnimation animation
        {
            get { return m_Animation; }
            set { if (PropertyUtil.SetClass(ref m_Animation, value, true)) SetVerticesDirty(); }
        }
        public LineArrow lineArrow
        {
            get { return m_LineArrow; }
            set { if (PropertyUtil.SetClass(ref m_LineArrow, value, true)) SetVerticesDirty(); }
        }
        public ItemStyle itemStyle
        {
            get { return m_ItemStyle; }
            set { if (PropertyUtil.SetClass(ref m_ItemStyle, value, true)) SetVerticesDirty(); }
        }
        public Emphasis emphasis
        {
            get { return m_Emphasis; }
            set { if (PropertyUtil.SetClass(ref m_Emphasis, value, true)) SetVerticesDirty(); }
        }
        public TitleStyle titleStyle
        {
            get { return m_TitleStyle; }
            set { if (PropertyUtil.SetClass(ref m_TitleStyle, value, true)) SetAllDirty(); }
        }
        public MarkLine markLine
        {
            get { return m_MarkLine; }
            set { if (PropertyUtil.SetClass(ref m_MarkLine, value, true)) SetAllDirty(); }
        }
        public IconStyle iconStyle
        {
            get { return m_IconStyle; }
            set { if (PropertyUtil.SetClass(ref m_IconStyle, value, true)) SetAllDirty(); }
        }
        public int showDataDimension { get { return m_ShowDataDimension; } set { m_ShowDataDimension = value; } }
        public bool showDataName { get { return m_ShowDataName; } set { m_ShowDataName = value; } }
        public bool clip
        {
            get { return m_Clip; }
            set { if (PropertyUtil.SetStruct(ref m_Clip, value)) SetVerticesDirty(); }
        }
        public bool showAsPositiveNumber
        {
            get { return m_ShowAsPositiveNumber; }
            set { if (PropertyUtil.SetStruct(ref m_ShowAsPositiveNumber, value)) SetComponentDirty(); }
        }
        public bool large
        {
            get { return m_Large; }
            set
            {
                if (PropertyUtil.SetStruct(ref m_Large, value))
                {
                    SetAllDirty();
                    label.SetComponentDirty();
                }
            }
        }
        public int largeThreshold
        {
            get { return m_LargeThreshold; }
            set
            {
                if (PropertyUtil.SetStruct(ref m_LargeThreshold, value))
                {
                    SetAllDirty();
                    label.SetComponentDirty();
                }
            }
        }
        public bool avoidLabelOverlap
        {
            get { return m_AvoidLabelOverlap; }
            set { if (PropertyUtil.SetStruct(ref m_AvoidLabelOverlap, value)) SetVerticesDirty(); }
        }
        public float waveLength
        {
            get { return m_WaveLength; }
            set { if (PropertyUtil.SetStruct(ref m_WaveLength, value)) SetVerticesDirty(); }
        }
        public float waveHeight
        {
            get { return m_WaveHeight; }
            set { if (PropertyUtil.SetStruct(ref m_WaveHeight, value)) SetVerticesDirty(); }
        }
        public float waveOffset
        {
            get { return m_WaveOffset; }
            set { if (PropertyUtil.SetStruct(ref m_WaveOffset, value)) SetVerticesDirty(); }
        }
        public float waveSpeed
        {
            get { return m_WaveSpeed; }
            set { if (PropertyUtil.SetStruct(ref m_WaveSpeed, value)) SetVerticesDirty(); }
        }
        public float left
        {
            get { return m_Left; }
            set { if (PropertyUtil.SetStruct(ref m_Left, value)) SetAllDirty(); }
        }
        public float right
        {
            get { return m_Right; }
            set { if (PropertyUtil.SetStruct(ref m_Right, value)) SetAllDirty(); }
        }
        public float top
        {
            get { return m_Top; }
            set { if (PropertyUtil.SetStruct(ref m_Top, value)) SetAllDirty(); }
        }
        public float bottom
        {
            get { return m_Bottom; }
            set { if (PropertyUtil.SetStruct(ref m_Bottom, value)) SetAllDirty(); }
        }
        public bool customBool1
        {
            get { return m_CustomBool1; }
            set { if (PropertyUtil.SetStruct(ref m_CustomBool1, value)) SetAllDirty(); }
        }
        public bool customBool2
        {
            get { return m_CustomBool2; }
            set { if (PropertyUtil.SetStruct(ref m_CustomBool2, value)) SetAllDirty(); }
        }
        public int customInt1
        {
            get { return m_CustomInt1; }
            set { if (PropertyUtil.SetStruct(ref m_CustomInt1, value)) SetAllDirty(); }
        }
        public int customInt2
        {
            get { return m_CustomInt2; }
            set { if (PropertyUtil.SetStruct(ref m_CustomInt2, value)) SetAllDirty(); }
        }
        public float customFloat1
        {
            get { return m_CustomFloat1; }
            set { if (PropertyUtil.SetStruct(ref m_CustomFloat1, value)) SetAllDirty(); }
        }
        public float customFloat2
        {
            get { return m_CustomFloat2; }
            set { if (PropertyUtil.SetStruct(ref m_CustomFloat2, value)) SetAllDirty(); }
        }
        public bool insertDataToHead
        {
            get { return m_InsertDataToHead; }
            set { if (PropertyUtil.SetStruct(ref m_InsertDataToHead, value)) SetAllDirty(); }
        }
        public SerieDataSortType dataSortType
        {
            get { return m_DataSortType; }
            set { if (PropertyUtil.SetStruct(ref m_DataSortType, value)) SetVerticesDirty(); }
        }
        public Orient orient
        {
            get { return m_Orient; }
            set { if (PropertyUtil.SetStruct(ref m_Orient, value)) SetVerticesDirty(); }
        }
        public Align align
        {
            get { return m_Align; }
            set { if (PropertyUtil.SetStruct(ref m_Align, value)) SetVerticesDirty(); }
        }
        public List<SerieData> data { get { return m_Data; } }
 
        public override bool vertsDirty
        {
            get
            {
                return m_VertsDirty ||
                    symbol.vertsDirty ||
                    lineStyle.vertsDirty ||
                    lineArrow.vertsDirty ||
                    itemStyle.vertsDirty ||
                    areaStyle.vertsDirty ||
                    label.vertsDirty ||
                    emphasis.vertsDirty ||
                    gaugeAxis.vertsDirty ||
                    gaugePointer.vertsDirty ||
                    markLine.vertsDirty;
            }
        }
 
        public override bool componentDirty { get { return m_ComponentDirty || titleStyle.componentDirty; } }
        public override void ClearVerticesDirty()
        {
            base.ClearVerticesDirty();
            symbol.ClearVerticesDirty();
            lineStyle.ClearVerticesDirty();
            lineArrow.ClearVerticesDirty();
            itemStyle.ClearVerticesDirty();
            areaStyle.ClearVerticesDirty();
            label.ClearVerticesDirty();
            emphasis.ClearVerticesDirty();
            gaugeAxis.ClearVerticesDirty();
            gaugePointer.ClearVerticesDirty();
            titleStyle.ClearVerticesDirty();
            markLine.ClearVerticesDirty();
            iconStyle.ClearVerticesDirty();
        }
 
        public override void ClearComponentDirty()
        {
            base.ClearComponentDirty();
            symbol.ClearComponentDirty();
            lineStyle.ClearComponentDirty();
            lineArrow.ClearComponentDirty();
            itemStyle.ClearComponentDirty();
            areaStyle.ClearComponentDirty();
            label.ClearComponentDirty();
            emphasis.ClearComponentDirty();
            gaugeAxis.ClearComponentDirty();
            gaugePointer.ClearComponentDirty();
            titleStyle.ClearComponentDirty();
            markLine.ClearComponentDirty();
            iconStyle.ClearComponentDirty();
        }
 
        public int index { get; internal set; }
        public bool highlighted { get; internal set; }
        public int dataCount { get { return m_Data.Count; } }
        public List<Vector3> dataPoints { get { return m_DataPoints; } }
        public Vector3 runtimeCenterPos { get; internal set; }
        public float runtimeInsideRadius { get; internal set; }
        public float runtimeOutsideRadius { get; internal set; }
        public double runtimeDataMax { get; internal set; }
        public double runtimeDataMin { get; internal set; }
        public double runtimePieDataTotal { get; internal set; }
        public float runtimeWaveSpeed { get; internal set; }
        public Painter runtimeCanvas { get; internal set; }
        public double runtimeCheckValue { get; set; }
        public int runtimeGridIndex { get; internal set; }
        public float runtimeX { get; internal set; }
        public float runtimeY { get; internal set; }
        public float runtimeWidth { get; internal set; }
        public float runtimeHeight { get; internal set; }
        public Rect runtimeRect { get; internal set; }
        public List<SerieData> runtimeSortedData { get { return m_SortedData; } }
        public List<SerieData> rootData { get { return m_RootData; } }
        public bool nameDirty { get { return m_NameDirty; } }
 
        private void SetNameDirty()
        {
            m_NameDirty = true;
        }
 
        public void ClearNameDirty()
        {
            m_NameDirty = false;
        }
 
        public override void ClearDirty()
        {
            base.ClearDirty();
        }
        internal List<Vector3> GetUpSmoothList(int dataIndex, int size = 100)
        {
            if (m_UpSmoothPoints.ContainsKey(dataIndex))
            {
                return m_UpSmoothPoints[dataIndex];
            }
            else
            {
                var list = ListPool<Vector3>.Get();
                m_UpSmoothPoints[dataIndex] = list;
                return list;
            }
        }
 
        internal List<Vector3> GetDownSmoothList(int dataIndex, int size = 100)
        {
            if (m_DownSmoothPoints.ContainsKey(dataIndex))
            {
                return m_DownSmoothPoints[dataIndex];
            }
            else
            {
                var list = ListPool<Vector3>.Get();
                m_DownSmoothPoints[dataIndex] = list;
                return list;
            }
        }
 
        internal void ClearSmoothList(int dataIndex)
        {
            if (m_UpSmoothPoints.ContainsKey(dataIndex))
            {
                m_UpSmoothPoints[dataIndex].Clear();
            }
            if (m_DownSmoothPoints.ContainsKey(dataIndex))
            {
                m_DownSmoothPoints[dataIndex].Clear();
            }
        }
 
        public double yMax
        {
            get
            {
                var max = double.MinValue;
                foreach (var sdata in data)
                {
                    if (sdata.show && !IsIgnoreValue(sdata.data[1]) && sdata.data[1] > max)
                    {
                        max = sdata.data[1];
                    }
                }
                return max;
            }
        }
 
        public double xMax
        {
            get
            {
                var max = double.MinValue;
                foreach (var sdata in data)
                {
                    if (sdata.show && !IsIgnoreValue(sdata.data[0]) && sdata.data[0] > max)
                    {
                        max = sdata.data[0];
                    }
                }
                return max;
            }
        }
 
        public double yMin
        {
            get
            {
                var min = double.MaxValue;
                foreach (var sdata in data)
                {
                    if (sdata.show && !IsIgnoreValue(sdata.data[1]) && sdata.data[1] < min)
                    {
                        min = sdata.data[1];
                    }
                }
                return min;
            }
        }
 
        public double xMin
        {
            get
            {
                var min = double.MaxValue;
                foreach (var sdata in data)
                {
                    if (sdata.show && !IsIgnoreValue(sdata.data[0]) && sdata.data[0] < min)
                    {
                        min = sdata.data[0];
                    }
                }
                return min;
            }
        }
 
        public double yTotal
        {
            get
            {
                double total = 0;
                foreach (var sdata in data)
                {
                    if (sdata.show && !IsIgnoreValue(sdata.data[1]))
                        total += sdata.GetCurrData(1, animation.GetUpdateAnimationDuration());
                }
                return total;
            }
        }
 
        public double xTotal
        {
            get
            {
                double total = 0;
                foreach (var sdata in data)
                {
                    if (sdata.show && !IsIgnoreValue(sdata.data[1]))
                        total += sdata.data[0];
                }
                return total;
            }
        }
 
        public void ClearData()
        {
            while (m_Data.Count > 0)
            {
                RemoveData(0);
            }
            m_Data.Clear();
            m_NeedUpdateFilterData = true;
            SetVerticesDirty();
        }
 
        public void RemoveData(int index)
        {
            if (index >= 0 && index < m_Data.Count)
            {
                if (!string.IsNullOrEmpty(m_Data[index].name))
                {
                    SetNameDirty();
                }
                SetVerticesDirty();
                var serieData = m_Data[index];
                SerieDataPool.Release(serieData);
                if (serieData.labelObject != null)
                {
                    SerieLabelPool.Release(serieData.labelObject.gameObject);
                }
                if (m_UpSmoothPoints.ContainsKey(serieData.index))
                {
                    ListPool<Vector3>.Release(m_UpSmoothPoints[serieData.index]);
                    m_UpSmoothPoints.Remove(serieData.index);
                }
                if (m_DownSmoothPoints.ContainsKey(serieData.index))
                {
                    ListPool<Vector3>.Release(m_DownSmoothPoints[serieData.index]);
                    m_DownSmoothPoints.Remove(serieData.index);
                }
                m_Data.RemoveAt(index);
                m_NeedUpdateFilterData = true;
            }
        }
 
        public SerieData AddYData(double value, string dataName = null)
        {
            CheckMaxCache();
            int xValue = m_Data.Count;
            var serieData = SerieDataPool.Get();
            serieData.data.Add(xValue);
            serieData.data.Add(value);
            serieData.name = dataName;
            serieData.index = xValue;
            AddSerieDataHeadOrTail(serieData);
            m_ShowDataDimension = 1;
            SetVerticesDirty();
            CheckDataName(dataName);
            return serieData;
        }
 
        private void AddSerieDataHeadOrTail(SerieData serieData)
        {
            if (m_InsertDataToHead) m_Data.Insert(0, serieData);
            else m_Data.Add(serieData);
            m_NeedUpdateFilterData = true;
        }
 
        private void CheckDataName(string dataName)
        {
            if (string.IsNullOrEmpty(dataName))
            {
                SetNameDirty();
            }
            else
            {
                m_ShowDataName = true;
            }
        }
 
        public SerieData AddXYData(double xValue, double yValue, string dataName = null)
        {
            CheckMaxCache();
            var serieData = SerieDataPool.Get();
            serieData.data.Clear();
            serieData.data.Add(xValue);
            serieData.data.Add(yValue);
            serieData.name = dataName;
            serieData.index = m_Data.Count;
            AddSerieDataHeadOrTail(serieData);
            m_ShowDataDimension = 2;
            SetVerticesDirty();
            CheckDataName(dataName);
            return serieData;
        }
 
        public SerieData AddData(double open, double close, double lowest, double heighest, string dataName = null)
        {
            CheckMaxCache();
            var serieData = SerieDataPool.Get();
            serieData.data.Clear();
            serieData.data.Add(open);
            serieData.data.Add(close);
            serieData.data.Add(lowest);
            serieData.data.Add(heighest);
            serieData.name = dataName;
            serieData.index = m_Data.Count;
            AddSerieDataHeadOrTail(serieData);
            m_ShowDataDimension = 4;
            SetVerticesDirty();
            CheckDataName(dataName);
            return serieData;
        }
 
        public SerieData AddData(List<double> valueList, string dataName = null)
        {
            if (valueList == null || valueList.Count == 0) return null;
            if (valueList.Count == 1)
            {
                return AddYData(valueList[0], dataName);
            }
            else if (valueList.Count == 2)
            {
                return AddXYData(valueList[0], valueList[1], dataName);
            }
            else
            {
                CheckMaxCache();
                m_ShowDataDimension = valueList.Count;
                var serieData = SerieDataPool.Get();
                serieData.name = dataName;
                serieData.index = m_Data.Count;
                for (int i = 0; i < valueList.Count; i++)
                {
                    serieData.data.Add(valueList[i]);
                }
                AddSerieDataHeadOrTail(serieData);
                SetVerticesDirty();
                CheckDataName(dataName);
                return serieData;
            }
        }
 
        public SerieData AddChildData(SerieData parent, double value, string name = null)
        {
            var serieData = new SerieData();
            serieData.name = name;
            serieData.index = m_Data.Count;
            serieData.data = new List<double>() { parent.children.Count, value };
            serieData.parentIndex = parent.index;
            serieData.runtimeParent = parent;
            AddSerieDataHeadOrTail(serieData);
            parent.children.Add(serieData.index);
            parent.runtimeChildren.Add(serieData);
            return serieData;
        }
        public SerieData AddChildData(SerieData parent, List<double> value, string name = null)
        {
            var serieData = new SerieData();
            serieData.name = name;
            serieData.index = m_Data.Count;
            serieData.data = new List<double>(value);
            serieData.parentIndex = parent.index;
            serieData.runtimeParent = parent;
            AddSerieDataHeadOrTail(serieData);
            parent.children.Add(serieData.index);
            parent.runtimeChildren.Add(serieData);
            return serieData;
        }
 
        private void CheckMaxCache()
        {
            if (m_MaxCache <= 0) return;
            while (m_Data.Count >= m_MaxCache)
            {
                m_NeedUpdateFilterData = true;
                if (m_InsertDataToHead) RemoveData(m_Data.Count - 1);
                else RemoveData(0);
            }
        }
 
        public double GetData(int index, int dimension, DataZoom dataZoom = null)
        {
            if (index < 0 || dimension < 0) return 0;
            var serieData = GetSerieData(index, dataZoom);
            if (serieData != null && dimension < serieData.data.Count)
            {
                var value = serieData.GetData(dimension);
                if (showAsPositiveNumber)
                {
                    value = Math.Abs(value);
                }
                return value;
            }
            else
            {
                return 0;
            }
        }
 
        public double GetYData(int index, DataZoom dataZoom = null)
        {
            if (index < 0) return 0;
            var serieData = GetDataList(dataZoom);
            if (index < serieData.Count)
            {
                var value = serieData[index].data[1];
                if (showAsPositiveNumber)
                {
                    value = Math.Abs(value);
                }
                return value;
            }
            return 0;
        }
 
        public double GetYCurrData(int index, DataZoom dataZoom = null)
        {
            if (index < 0) return 0;
            var serieData = GetDataList(dataZoom);
            if (index < serieData.Count)
            {
                var value = serieData[index].GetCurrData(1, animation.GetUpdateAnimationDuration());
                if (showAsPositiveNumber)
                {
                    value = Math.Abs(value);
                }
                return value;
            }
            return 0;
        }
 
        public void GetYData(int index, out double yData, out string dataName, DataZoom dataZoom = null)
        {
            yData = 0;
            dataName = null;
            if (index < 0) return;
            var serieData = GetDataList(dataZoom);
            if (index < serieData.Count)
            {
                yData = serieData[index].data[1];
                if (showAsPositiveNumber)
                {
                    yData = Math.Abs(yData);
                }
                dataName = serieData[index].name;
            }
        }
 
        public SerieData GetSerieData(int index, DataZoom dataZoom = null)
        {
            var data = GetDataList(dataZoom);
            if (index >= 0 && index <= data.Count - 1)
            {
                return data[index];
            }
            return null;
        }
 
        public SerieData GetSerieData(string id, DataZoom dataZoom = null)
        {
            var data = GetDataList(dataZoom);
            foreach (var serieData in data)
            {
                var target = GetSerieData(serieData, id);
                if (target != null) return target;
            }
            return null;
        }
 
        public SerieData GetSerieData(SerieData parent, string id)
        {
            if (id.Equals(parent.id)) return parent;
            foreach (var child in parent.children)
            {
                var data = GetSerieData(GetSerieData(child), id);
                if (data != null)
                {
                    return data;
                }
            }
            return null;
        }
 
        public void GetXYData(int index, DataZoom dataZoom, out double xValue, out double yVlaue)
        {
            xValue = 0;
            yVlaue = 0;
            if (index < 0) return;
            var showData = GetDataList(dataZoom);
            if (index < showData.Count)
            {
                var serieData = showData[index];
                xValue = serieData.data[0];
                yVlaue = serieData.data[1];
                if (showAsPositiveNumber)
                {
                    xValue = Math.Abs(xValue);
                    yVlaue = Math.Abs(yVlaue);
                }
            }
        }
 
        public double GetDataTotal(int dimension)
        {
            double total = 0;
            foreach (var sdata in data)
            {
                if (sdata.show)
                    total += sdata.GetData(dimension);
            }
            return total;
        }
 
        public List<SerieData> GetDataList(DataZoom dataZoom = null)
        {
            if (dataZoom != null && dataZoom.enable
                && (dataZoom.IsContainsXAxis(xAxisIndex) || dataZoom.IsContainsYAxis(yAxisIndex)))
            {
                SerieHelper.UpdateFilterData(this, dataZoom);
                return m_FilterData;
            }
            else
            {
                return runtimeSortedData.Count > 0 ? runtimeSortedData : m_Data;
            }
        }
 
        public bool UpdateYData(int index, double value)
        {
            UpdateData(index, 1, value);
            return true;
        }
 
        public bool UpdateXYData(int index, float xValue, float yValue)
        {
            var flag1 = UpdateData(index, 0, xValue);
            var flag2 = UpdateData(index, 1, yValue);
            return flag1 || flag2;
        }
 
        public bool UpdateData(int index, int dimension, double value)
        {
            if (index >= 0 && index < m_Data.Count)
            {
                var animationOpen = animation.enable;
                var animationDuration = animation.GetUpdateAnimationDuration();
                var flag = m_Data[index].UpdateData(dimension, value, animationOpen, animationDuration);
                if (flag) SetVerticesDirty();
                return flag;
            }
            else
            {
                return false;
            }
        }
 
        public bool UpdateData(int index, List<double> values)
        {
            if (index >= 0 && index < m_Data.Count && values != null)
            {
                var serieData = m_Data[index];
                var animationOpen = animation.enable;
                var animationDuration = animation.GetUpdateAnimationDuration();
                for (int i = 0; i < values.Count; i++)
                    serieData.UpdateData(i, values[i], animationOpen, animationDuration);
                SetVerticesDirty();
                return true;
            }
            return false;
        }
 
        public bool UpdateDataName(int index, string name)
        {
            if (index >= 0 && index < m_Data.Count)
            {
                var serieData = m_Data[index];
                serieData.name = name;
                SetNameDirty();
                if (serieData.labelObject != null)
                {
                    serieData.labelObject.SetText(name == null ? "" : name);
                }
                return true;
            }
            return false;
        }
 
        public void ClearHighlight()
        {
            highlighted = false;
            foreach (var serieData in m_Data)
            {
                serieData.highlighted = false;
            }
        }
 
        public void SetHighlight(int index, bool flag)
        {
            var serieData = GetSerieData(index);
            if (serieData != null)
            {
                serieData.highlighted = flag;
            }
        }
 
        public float GetBarWidth(float categoryWidth)
        {
            if (m_BarWidth > 1) return m_BarWidth;
            else return m_BarWidth * categoryWidth;
        }
 
        public bool IsIgnoreIndex(int index, int dimension = 1)
        {
            var serieData = GetSerieData(index);
            if (serieData != null)
            {
                return IsIgnoreValue(serieData, dimension);
            }
            return false;
        }
 
        public bool IsIgnoreValue(SerieData serieData, int dimension = 1)
        {
            if (serieData.ignore) return true;
            return IsIgnoreValue(serieData.GetData(dimension));
        }
 
        public bool IsIgnoreValue(double value)
        {
            return m_Ignore && MathUtil.Approximately(value, m_IgnoreValue);
        }
 
        public bool IsIgnorePoint(int index)
        {
            if (index >= 0 && index < dataPoints.Count)
            {
                return ChartHelper.IsIngore(dataPoints[index]);
            }
            return false;
        }
 
        public bool IsPerformanceMode()
        {
            if (m_Type == SerieType.Line || m_Type == SerieType.Bar)
                return m_Large && m_Data.Count > m_LargeThreshold;
            else
                return false;
        }
 
        public bool IsCoordinateSerie()
        {
            return type == SerieType.Line
                || type == SerieType.Bar
                || type == SerieType.Scatter
                || type == SerieType.Heatmap
                || type == SerieType.Candlestick;
        }
 
        public void SetDataIconSize(int dataIndex, float width, float height)
        {
            if (dataIndex >= 0 && dataIndex < m_Data.Count)
            {
                var data = m_Data[dataIndex];
                data.iconStyle.width = width;
                data.iconStyle.height = height;
            }
        }
 
        public void SetDataIconColor(int dataIndex, Color color)
        {
            if (dataIndex >= 0 && dataIndex < m_Data.Count)
            {
                var data = m_Data[dataIndex];
                data.iconStyle.color = color;
            }
        }
 
        public void AnimationEnable(bool flag)
        {
            if (animation.enable) animation.enable = flag;
            if (markLine.show && markLine.animation.enable) markLine.animation.enable = flag;
            SetVerticesDirty();
        }
 
        public void AnimationFadeIn()
        {
            if (animation.enable) animation.FadeIn();
            if (markLine.show && markLine.animation.enable) markLine.animation.FadeIn();
            SetVerticesDirty();
        }
 
        public void AnimationFadeOut()
        {
            if (animation.enable) animation.FadeOut();
            if (markLine.show && markLine.animation.enable) markLine.animation.FadeOut();
            SetVerticesDirty();
        }
 
        public void AnimationPause()
        {
            if (animation.enable) animation.Pause();
            if (markLine.show && markLine.animation.enable) markLine.animation.Pause();
            SetVerticesDirty();
        }
 
        public void AnimationResume()
        {
            if (animation.enable) animation.Resume();
            if (markLine.show && markLine.animation.enable) markLine.animation.Resume();
            SetVerticesDirty();
        }
 
        public void AnimationReset()
        {
            if (animation.enable) animation.Reset();
            if (markLine.show && markLine.animation.enable) markLine.animation.Reset();
            SetVerticesDirty();
        }
        public void AnimationRestart()
        {
            if (animation.enable) animation.Restart();
            if (markLine.show && markLine.animation.enable) markLine.animation.Restart();
            SetVerticesDirty();
        }
 
        public void ParseJsonData(string jsonData)
        {
            if (string.IsNullOrEmpty(jsonData)) return;
            jsonData = jsonData.Replace("\r\n", "");
            jsonData = jsonData.Replace(" ", "");
            jsonData = jsonData.Replace("\n", "");
            int startIndex = jsonData.IndexOf("[");
            int endIndex = jsonData.LastIndexOf("]");
            if (startIndex == -1 || endIndex == -1)
            {
                Debug.LogError("json data need include in [ ]");
                return;
            }
            ClearData();
            string temp = jsonData.Substring(startIndex + 1, endIndex - startIndex - 1);
            if (temp.IndexOf("],") > -1 || temp.IndexOf("] ,") > -1)
            {
                string[] datas = temp.Split(new string[] { "],", "] ," }, StringSplitOptions.RemoveEmptyEntries);
                for (int i = 0; i < datas.Length; i++)
                {
                    var data = datas[i].Split(new char[] { '[', ',' }, StringSplitOptions.RemoveEmptyEntries);
                    var serieData = new SerieData();
                    for (int j = 0; j < data.Length; j++)
                    {
                        var txt = data[j].Trim().Replace("]", "");
                        double value;
                        var flag = double.TryParse(txt, out value);
                        if (flag)
                        {
                            serieData.data.Add(value);
                        }
                        else serieData.name = txt.Replace("\"", "").Trim();
                    }
                    AddSerieDataHeadOrTail(serieData);
                }
            }
            else if (temp.IndexOf("value") > -1 && temp.IndexOf("name") > -1)
            {
                string[] datas = temp.Split(new string[] { "},", "} ,", "}" }, StringSplitOptions.RemoveEmptyEntries);
                for (int i = 0; i < datas.Length; i++)
                {
                    var arr = datas[i].Replace("{", "").Split(',');
                    var serieData = new SerieData();
                    foreach (var a in arr)
                    {
                        if (a.StartsWith("value:"))
                        {
                            double value = double.Parse(a.Substring(6, a.Length - 6));
                            serieData.data = new List<double>() { i, value };
                        }
                        else if (a.StartsWith("name:"))
                        {
                            string name = a.Substring(6, a.Length - 6 - 1);
                            serieData.name = name;
                        }
                        else if (a.StartsWith("selected:"))
                        {
                            string selected = a.Substring(9, a.Length - 9);
                            serieData.selected = bool.Parse(selected);
                        }
                    }
                    AddSerieDataHeadOrTail(serieData);
                }
            }
            else
            {
                string[] datas = temp.Split(',');
                for (int i = 0; i < datas.Length; i++)
                {
                    double value;
                    var flag = double.TryParse(datas[i].Trim(), out value);
                    if (flag)
                    {
                        var serieData = new SerieData();
                        serieData.data = new List<double>() { i, value };
                        AddSerieDataHeadOrTail(serieData);
                    }
                }
            }
            SetAllDirty();
        }
    }
}