PolarChart.xaml.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Collections.ObjectModel;
using System.ComponentModel;
using Microsoft.Expression.Shapes;
using Misc;

namespace FLY.Thick.Blowing.UI.UiModule
{
    /// <summary>
    /// UserControl1.xaml 的交互逻辑
    /// </summary>
    public partial class PolarChart : UserControl, IPolarChart, INotifyPropertyChanged
    {
        #region IPolarChart
        #region BoltCnt
        public static readonly DependencyProperty BoltCntProperty =
            DependencyProperty.Register(nameof(BoltCnt), typeof(int), typeof(PolarChart), new PropertyMetadata(
            88,
            new PropertyChangedCallback(delegate (DependencyObject d, DependencyPropertyChangedEventArgs e)
            {
                (d as PolarChart).NotifyPropertyChanged(nameof(BoltCnt));
            })));
        public int BoltCnt
        {
            get
            {
                return (int)GetValue(BoltCntProperty);
            }
            set
            {
                SetValue(BoltCntProperty, value);
            }
        }
        public static int GetBoltCnt(UIElement element)
        {
            return (int)element.GetValue(BoltCntProperty);
        }
        public static void SetBoltCnt(UIElement element, int boltCnt)
        {
            element.SetValue(BoltCntProperty, boltCnt);
        }
        #endregion

        #region BPC
        public static readonly DependencyProperty BPCProperty =
            DependencyProperty.Register(nameof(BPC), typeof(int), typeof(PolarChart), new PropertyMetadata(
            1,
            new PropertyChangedCallback(delegate (DependencyObject d, DependencyPropertyChangedEventArgs e)
            {
                (d as PolarChart).NotifyPropertyChanged(nameof(BPC));
            })));
        public int BPC
        {
            get
            {
                return (int)GetValue(BPCProperty);
            }
            set
            {
                SetValue(BPCProperty, value);
            }
        }
        public static int GetBPC(UIElement element)
        {
            return (int)element.GetValue(BPCProperty);
        }
        public static void SetBPC(UIElement element, int bpc)
        {
            element.SetValue(BPCProperty, bpc);
        }
        #endregion

        #region XStep
        public static readonly DependencyProperty XStepProperty =
            DependencyProperty.Register(nameof(XStep), typeof(int), typeof(PolarChart), new PropertyMetadata(
            5,
            new PropertyChangedCallback(delegate (DependencyObject d, DependencyPropertyChangedEventArgs e)
            {
                (d as PolarChart).NotifyPropertyChanged(nameof(XStep));
            })));
        public int XStep
        {
            get
            {
                return (int)GetValue(XStepProperty);
            }
            set
            {
                SetValue(XStepProperty, value);
            }
        }
        public static int GetXStep(UIElement element)
        {
            return (int)element.GetValue(XStepProperty);
        }
        public static void SetXStep(UIElement element, int xstep)
        {
            element.SetValue(XStepProperty, xstep);
        }
        #endregion

        #region IsForwCW

        public static readonly DependencyProperty IsForwCWProperty =
            DependencyProperty.Register(nameof(IsForwCW), typeof(bool), typeof(PolarChart), new PropertyMetadata(
            true,
            new PropertyChangedCallback(delegate (DependencyObject d, DependencyPropertyChangedEventArgs e)
            {
                (d as PolarChart).NotifyPropertyChanged(nameof(IsForwCW));
            })));
        public bool IsForwCW
        {
            get
            {
                return (bool)GetValue(IsForwCWProperty);
            }
            set
            {
                SetValue(IsForwCWProperty, value);
            }
        }

        public static bool GetIsForwCW(UIElement element)
        {
            return (bool)element.GetValue(IsForwCWProperty);
        }
        public static void SetIsForwCW(UIElement element, bool value)
        {
            element.SetValue(IsForwCWProperty, value);
        }


        #endregion

        #region MPIsRight

        public static readonly DependencyProperty MPIsRightProperty =
DependencyProperty.Register(nameof(MPIsRight), typeof(bool), typeof(PolarChart), new PropertyMetadata(
true,
new PropertyChangedCallback(delegate (DependencyObject d, DependencyPropertyChangedEventArgs e)
{
    (d as PolarChart).NotifyPropertyChanged(nameof(MPIsRight));
})));
        public bool MPIsRight
        {
            get
            {
                return (bool)GetValue(MPIsRightProperty);
            }
            set
            {
                SetValue(MPIsRightProperty, value);
            }
        }

        public static bool GetMPIsRight(UIElement element)
        {
            return (bool)element.GetValue(MPIsRightProperty);
        }
        public static void SetMPIsRight(UIElement element, bool value)
        {
            element.SetValue(MPIsRightProperty, value);
        }


        #endregion

        #region OrgBoltNo
        public static readonly DependencyProperty OrgBoltNoProperty =
    DependencyProperty.Register(nameof(OrgBoltNo), typeof(int), typeof(PolarChart), new PropertyMetadata(
    1,
    new PropertyChangedCallback(delegate (DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        (d as PolarChart).NotifyPropertyChanged(nameof(OrgBoltNo));
    })));
        public int OrgBoltNo
        {
            get
            {
                return (int)GetValue(OrgBoltNoProperty);
            }
            set
            {
                SetValue(OrgBoltNoProperty, value);
            }
        }


        public static int GetOrgBoltNo(UIElement element)
        {
            return (int)element.GetValue(OrgBoltNoProperty);
        }
        public static void SetOrgBoltNo(UIElement element, int value)
        {
            element.SetValue(OrgBoltNoProperty, value);
        }
        #endregion

        #region TolerancePercent
        public static readonly DependencyProperty TolerancePercentProperty =
    DependencyProperty.Register(nameof(TolerancePercent), typeof(double), typeof(PolarChart), new PropertyMetadata(
0.05,
new PropertyChangedCallback(delegate (DependencyObject d, DependencyPropertyChangedEventArgs e)
{
    (d as PolarChart).NotifyPropertyChanged(nameof(TolerancePercent));
})));
        public double TolerancePercent
        {
            get
            {
                return (double)GetValue(TolerancePercentProperty);
            }
            set
            {
                SetValue(TolerancePercentProperty, value);
            }
        }

        public static double GetTolerancePercent(UIElement element)
        {
            return (double)element.GetValue(TolerancePercentProperty);
        }
        public static void SetTolerancePercent(UIElement element, double value)
        {
            element.SetValue(TolerancePercentProperty, value);
        }
        #endregion

        #region YRangePercent
        public static readonly DependencyProperty YRangePercentProperty =
DependencyProperty.Register(nameof(YRangePercent), typeof(double), typeof(PolarChart), new PropertyMetadata(
3.0,
new PropertyChangedCallback(delegate (DependencyObject d, DependencyPropertyChangedEventArgs e)
{
    (d as PolarChart).NotifyPropertyChanged(nameof(YRangePercent));
})));
        public double YRangePercent
        {
            get
            {
                return (double)GetValue(YRangePercentProperty);
            }
            set
            {
                SetValue(YRangePercentProperty, value);
            }
        }

        public static double GetYRangePercent(UIElement element)
        {
            return (double)element.GetValue(YRangePercentProperty);
        }
        public static void SetYRangePercent(UIElement element, double value)
        {
            element.SetValue(YRangePercentProperty, value);
        }
        #endregion

        #region Target
        public static readonly DependencyProperty TargetProperty =
            DependencyProperty.Register(nameof(Target), typeof(double), typeof(PolarChart), new PropertyMetadata(
            100.0,
            new PropertyChangedCallback(delegate (DependencyObject d, DependencyPropertyChangedEventArgs e)
            {
                (d as PolarChart).NotifyPropertyChanged(nameof(Target));
            })));
        public double Target
        {
            get
            {
                return (double)GetValue(TargetProperty);
            }
            set
            {
                SetValue(TargetProperty, value);
            }
        }

        public static double GetTarget(UIElement element)
        {
            return (double)element.GetValue(TargetProperty);
        }
        public static void SetTarget(UIElement element, double value)
        {
            element.SetValue(TargetProperty, value);
        }
        #endregion

        #region IsPercent
        public static readonly DependencyProperty IsPercentProperty =
DependencyProperty.Register(nameof(IsPercent), typeof(bool), typeof(PolarChart), new PropertyMetadata(
true,
new PropertyChangedCallback(delegate (DependencyObject d, DependencyPropertyChangedEventArgs e)
{
    (d as PolarChart).NotifyPropertyChanged(nameof(IsPercent));
})));
        public bool IsPercent
        {
            get
            {
                return (bool)GetValue(IsPercentProperty);
            }
            set
            {
                SetValue(IsPercentProperty, value);
            }
        }

        public static bool GetIsPercent(UIElement element)
        {
            return (bool)element.GetValue(IsPercentProperty);
        }
        public static void SetIsPercent(UIElement element, bool value)
        {
            element.SetValue(IsPercentProperty, value);
        }
        #endregion

        #region IsAutoTarget
        public static readonly DependencyProperty IsAutoTargetProperty =
DependencyProperty.Register(nameof(IsAutoTarget), typeof(bool), typeof(PolarChart), new PropertyMetadata(
true,
new PropertyChangedCallback(delegate (DependencyObject d, DependencyPropertyChangedEventArgs e)
{
    (d as PolarChart).NotifyPropertyChanged(nameof(IsAutoTarget));
})));
        public bool IsAutoTarget
        {
            get
            {
                return (bool)GetValue(IsAutoTargetProperty);
            }
            set
            {
                SetValue(IsAutoTargetProperty, value);
            }
        }

        public static bool GetIsAutoTarget(UIElement element)
        {
            return (bool)element.GetValue(IsAutoTargetProperty);
        }
        public static void SetIsAutoTarget(UIElement element, bool value)
        {
            element.SetValue(IsAutoTargetProperty, value);
        }
        #endregion

        #region HasAlianZone
        public static readonly DependencyProperty HasAlianZoneProperty =
DependencyProperty.Register(nameof(HasAlianZone), typeof(bool), typeof(PolarChart), new PropertyMetadata(
false,
new PropertyChangedCallback(delegate (DependencyObject d, DependencyPropertyChangedEventArgs e)
{
    (d as PolarChart).NotifyPropertyChanged(nameof(HasAlianZone));
})));
        public bool HasAlianZone
        {
            get
            {
                return (bool)GetValue(HasAlianZoneProperty);
            }
            set
            {
                SetValue(HasAlianZoneProperty, value);
            }
        }

        public static bool GetHasAlianZone(UIElement element)
        {
            return (bool)element.GetValue(HasAlianZoneProperty);
        }
        public static void SetHasAlianZone(UIElement element, bool value)
        {
            element.SetValue(HasAlianZoneProperty, value);
        }
        #endregion

        #region AlianZoneBoltNoOf3oClock
        public static readonly DependencyProperty AlianZoneBoltNoOf3oClockProperty =
            DependencyProperty.Register(nameof(AlianZoneBoltNoOf3oClock), typeof(double), typeof(PolarChart), new PropertyMetadata(
            1.0,
            new PropertyChangedCallback(delegate (DependencyObject d, DependencyPropertyChangedEventArgs e)
            {
                (d as PolarChart).NotifyPropertyChanged(nameof(AlianZoneBoltNoOf3oClock));
            })));
        public double AlianZoneBoltNoOf3oClock
        {
            get
            {
                return (double)GetValue(AlianZoneBoltNoOf3oClockProperty);
            }
            set
            {
                SetValue(AlianZoneBoltNoOf3oClockProperty, value);
            }
        }

        public static double GetAlianZoneBoltNoOf3oClock(UIElement element)
        {
            return (double)element.GetValue(AlianZoneBoltNoOf3oClockProperty);
        }
        public static void SetAlianZoneBoltNoOf3oClock(UIElement element, double value)
        {
            element.SetValue(AlianZoneBoltNoOf3oClockProperty, value);
        }
        #endregion

        #region AlianZoneBoltCnt
        public static readonly DependencyProperty AlianZoneBoltCntProperty =
DependencyProperty.Register(nameof(AlianZoneBoltCnt), typeof(int), typeof(PolarChart), new PropertyMetadata(
8,
new PropertyChangedCallback(delegate (DependencyObject d, DependencyPropertyChangedEventArgs e)
{
    (d as PolarChart).NotifyPropertyChanged(nameof(AlianZoneBoltCnt));
})));
        public int AlianZoneBoltCnt
        {
            get
            {
                return (int)GetValue(AlianZoneBoltCntProperty);
            }
            set
            {
                SetValue(AlianZoneBoltCntProperty, value);
            }
        }

        public static int GetAlianZoneBoltCnt(UIElement element)
        {
            return (int)element.GetValue(AlianZoneBoltCntProperty);
        }
        public static void SetAlianZoneBoltCnt(UIElement element, int value)
        {
            element.SetValue(AlianZoneBoltCntProperty, value);
        }
        #endregion

        #region AlianZoneIsCCW
        public static readonly DependencyProperty AlianZoneIsCCWProperty =
DependencyProperty.Register(nameof(AlianZoneIsCCW), typeof(bool), typeof(PolarChart), new PropertyMetadata(
false,
new PropertyChangedCallback(delegate (DependencyObject d, DependencyPropertyChangedEventArgs e)
{
    (d as PolarChart).NotifyPropertyChanged(nameof(AlianZoneIsCCW));
})));
        public bool AlianZoneIsCCW
        {
            get
            {
                return (bool)GetValue(AlianZoneIsCCWProperty);
            }
            set
            {
                SetValue(AlianZoneIsCCWProperty, value);
            }
        }

        public static bool GetAlianZoneIsCCW(UIElement element)
        {
            return (bool)element.GetValue(AlianZoneIsCCWProperty);
        }
        public static void SetAlianZoneIsCCW(UIElement element, bool value)
        {
            element.SetValue(AlianZoneIsCCWProperty, value);
        }
        #endregion


        #region AlianZoneIsShowXStep
        public static readonly DependencyProperty AlianZoneIsShowXStepProperty =
DependencyProperty.Register(nameof(AlianZoneIsShowXStep), typeof(bool), typeof(PolarChart), new PropertyMetadata(
false,
new PropertyChangedCallback(delegate (DependencyObject d, DependencyPropertyChangedEventArgs e)
{
    (d as PolarChart).NotifyPropertyChanged(nameof(AlianZoneIsShowXStep));
})));
        public bool AlianZoneIsShowXStep
        {
            get
            {
                return (bool)GetValue(AlianZoneIsShowXStepProperty);
            }
            set
            {
                SetValue(AlianZoneIsShowXStepProperty, value);
            }
        }

        public static bool GetAlianZoneIsShowXStep(UIElement element)
        {
            return (bool)element.GetValue(AlianZoneIsShowXStepProperty);
        }
        public static void SetAlianZoneIsShowXStep(UIElement element, bool value)
        {
            element.SetValue(AlianZoneIsShowXStepProperty, value);
        }
        #endregion



        ObservableCollection<double> values = new ObservableCollection<double>();
        public ObservableCollection<double> Values
        {
            get
            {
                return values;
            }
            set
            {
                if (values != value)
                {
                    if (values != null)
                        values.CollectionChanged -= _values_CollectionChanged;

                    values = value;

                    values.CollectionChanged += _values_CollectionChanged;
                    NotifyPropertyChanged(nameof(Values));
                }
            }
        }

        ObservableCollection<double> lineValues = new ObservableCollection<double>();
        public ObservableCollection<double> LineValues
        {
            get
            {
                return lineValues;
            }
            set
            {
                if (lineValues != value)
                {
                    if (lineValues != null)
                        lineValues.CollectionChanged -= _lineValues_CollectionChanged;

                    lineValues = value;

                    lineValues.CollectionChanged += _lineValues_CollectionChanged;
                    NotifyPropertyChanged(nameof(LineValues));
                }
            }
        }


        System.Collections.Specialized.NotifyCollectionChangedEventHandler _values_CollectionChanged;
        System.Collections.Specialized.NotifyCollectionChangedEventHandler _lineValues_CollectionChanged;

        List<Brush> AreaColors;
        #endregion

        /// <summary>
        /// 实际目标值
        /// </summary>
        public double ActualTarget { get; set; } = 100;

        /// <summary>
        /// 中心
        /// </summary>
        Point Center;
        /// <summary>
        /// 总半径
        /// </summary>
        double Radius;
        /// <summary>
        /// 每个额外分区环，宽度
        /// </summary>
        double AlianZoneRingThickness;
        /// <summary>
        ///  分区环，宽度
        /// </summary>
        double BoltNoRingThickness;
        /// <summary>
        /// 最内环，宽度
        /// </summary>
        double InnerRingThickness;
        /// <summary>
        /// 图表，宽度
        /// </summary>
        double GraphThickness;

        double Avg;

        List<Arc> UIElement_DataArc = new List<Arc>();
        Path linePath;
        //List<UIElement> UIElement_AxisYLine = new List<UIElement>();
        //List<UIElement> UIElement_AlianZone = new List<UIElement>();
        //List<UIElement> UIElement_AxisXLine = new List<UIElement>();
        //List<UIElement> UIElement_BoltNo = new List<UIElement>();

        public PolarChart()
        {
            InitializeComponent();

            AreaColors = FLY.Thick.Blowing.UI.Themes.Colors.AreaColors;

            _values_CollectionChanged = new System.Collections.Specialized.NotifyCollectionChangedEventHandler(values_CollectionChanged);
            _lineValues_CollectionChanged = new System.Collections.Specialized.NotifyCollectionChangedEventHandler(lineValues_CollectionChanged);

            this.PropertyChanged += new PropertyChangedEventHandler(PolarChart_PropertyChanged);

            Init();

            DataBindAll_Init();
        }
        /// <summary>
        /// 需要重画全部的属性
        /// </summary>
        string[] propertynames_draw = new string[] {
            nameof(BoltCnt),nameof(BPC), nameof(XStep), nameof(OrgBoltNo), nameof(MPIsRight), nameof(TolerancePercent), nameof(YRangePercent),
            nameof(IsPercent),nameof(IsAutoTarget),nameof(Target), nameof(IsForwCW)
        };

        string[] propertynames_drawAlian = new string[] {
            nameof(AlianZoneIsShowXStep), nameof(HasAlianZone),nameof(AlianZoneBoltNoOf3oClock),  nameof(AlianZoneBoltCnt), nameof(AlianZoneIsCCW) };

        void PolarChart_PropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            if (propertynames_draw.Contains(e.PropertyName))
            {
                draw_flag = true;
            }
            else if (propertynames_drawAlian.Contains(e.PropertyName))
            {
                draw_flag = true;
            }
        }
        void values_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
        {
            DataBindAll();
        }

        void lineValues_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
        {
            DataBindAll_line();
        }

        void Init()
        {
            Center = new Point(LayoutRoot.Width / 2, LayoutRoot.Width / 2);
            Radius = LayoutRoot.Width / 2;
            BoltNoRingThickness = 20;
            AlianZoneRingThickness = 20;


            InnerRingThickness = (Radius - BoltNoRingThickness - AlianZoneRingThickness) / 4;
            GraphThickness = (Radius - BoltNoRingThickness - AlianZoneRingThickness - InnerRingThickness);

        }

        void Draw()
        {
            Clear();
            UpdateAvg();
            UpdateActualTarget();

            Draw_AxisYLine();
            Draw_AxisX2Label();
            Draw_AxisXLine();
            Draw_AxisXLabel();
            Draw_Series();
            Draw_LineSeries();
            Draw_AxisYLabel();
        }
        void UpdateActualTarget()
        {
            if (IsAutoTarget && !double.IsNaN(Avg) && Avg > 1)
            {
                ActualTarget = Avg;
            }
            else if (!double.IsNaN(Target) && Target > 1)
            {
                ActualTarget = Target;
            }
        }

        //角度 转 (X,Y)
        Point DegreesToPoint(Point center, double r, double degrees)
        {
            Point p = new Point();
            p.X = center.X + r * Math.Sin(degrees / 180 * Math.PI);
            p.Y = center.Y - r * Math.Cos(degrees / 180 * Math.PI);
            return p;
        }



        /// <summary>
        /// 3点为0° 的逆时钟角度坐标 转为 WPF 的 12点为0°顺时钟角度坐标
        /// </summary>
        /// <param name="degrees"></param>
        /// <returns></returns>
        double TransformDegreesOrg(double degrees)
        {
            return -degrees + 90;
        }

        /// <summary>
        /// 与 TransformDegreesOrg 一样，但考虑 探头是否在右边
        /// </summary>
        /// <param name="degrees"></param>
        /// <returns></returns>
        double TransformDegrees(double degrees)
        {
            if (MPIsRight)
                return -degrees + 90;
            else
                return -degrees - 90;
        }
        (double, double) BoltIndex2WpfAngle(bool isCCW, double boltNoOf3oClock, int boltCnt, bool isOrg, double start_index, double end_index) 
        {
            double startAngle;
            double endAngle;
            double oclock;
            if (isCCW)
            {
                //逆时钟排列
                oclock = boltNoOf3oClock;
            }
            else
            {
                //顺时钟排列
                oclock = 2 - boltNoOf3oClock; //这个2-x 很特别,  正常是 3-x,  3代表3点钟
                double distance = end_index - start_index;
                start_index = -start_index;
                end_index = start_index + distance;

            }

            double start_degrees = (start_index - (oclock - 1) - 0.5) * 360 / boltCnt;
            double end_degrees = (end_index - (oclock - 1) - 0.5) * 360 / boltCnt;
            if (isOrg)
            {
                startAngle = TransformDegreesOrg(start_degrees);
                endAngle = TransformDegreesOrg(end_degrees);
            }
            else 
            {
                startAngle = TransformDegrees(start_degrees);
                endAngle = TransformDegrees(end_degrees);
            }

            if (startAngle > endAngle)
            {
                double tmp = endAngle;
                endAngle = startAngle;
                startAngle = tmp;
            }
            return (startAngle, endAngle);
        }
        double BoltIndex2WpfAngle(bool isCCW, double boltNoOf3oClock, int boltCnt, bool isOrg, double start_index)
        {
            double oclock;
            if (isCCW)
            {
                //逆时钟排列
                oclock = boltNoOf3oClock;
            }
            else
            {
                //顺时钟排列
                oclock = 2 - boltNoOf3oClock; //这个2-x 很特别,  正常是 3-x,  3代表3点钟
                start_index = -start_index;
            }
            double degrees = (start_index - (oclock - 1) - 0.5) * 360 / boltCnt;

            if (isOrg)
                return TransformDegreesOrg(degrees);
            else
                return TransformDegrees(degrees);

        }

        double GetBoltNoOf3oClock() 
        {
            double midBoltNo = OrgBoltNo + BoltCnt / 2;
            if (midBoltNo > BoltCnt)
                midBoltNo -= BoltCnt;
            double boltNoOf3oClock = MPIsRight ? OrgBoltNo : midBoltNo;
            return boltNoOf3oClock;
        }
        void GetArcText(int start_index, int end_index, string no, out Arc arc, out TextBlock t)
        {
            double boltNoOf3oClock = GetBoltNoOf3oClock();

            (double startAngle, double endAngle) = BoltIndex2WpfAngle(!IsForwCW, boltNoOf3oClock, BoltCnt, false, start_index, end_index);

            arc = new Arc()
            {
                ArcThickness = BoltNoRingThickness,
                ArcThicknessUnit = Microsoft.Expression.Media.UnitType.Pixel,
                StartAngle = startAngle,
                EndAngle = endAngle,
                Stretch = System.Windows.Media.Stretch.None,
                Stroke = System.Windows.Media.Brushes.White,
                Fill = System.Windows.Media.Brushes.Black,
                Width = (Radius - AlianZoneRingThickness) * 2,
                Height = (Radius - AlianZoneRingThickness) * 2,
                Margin = new Thickness(AlianZoneRingThickness),
                Opacity = 1
            };

            //分区块的中心
            Point p = Polar.ToPoint(
                new Polar() { Degrees = (endAngle + startAngle) / 2, Radius = Radius - AlianZoneRingThickness - BoltNoRingThickness / 2 },
                Center);

            t = new TextBlock()
            {
                TextWrapping = System.Windows.TextWrapping.NoWrap,

                TextAlignment = System.Windows.TextAlignment.Center,
                Width = 20,
                Height = 15,
                Text = no,
                FontFamily = new System.Windows.Media.FontFamily("Trebuchet MS"),
                FontWeight = System.Windows.FontWeights.Bold,
                Foreground = System.Windows.Media.Brushes.White
            };

            t.SetValue(Canvas.LeftProperty, p.X - t.Width / 2);
            t.SetValue(Canvas.TopProperty, p.Y - t.Height / 2);
        }
        void Draw_AxisXLabel()
        {
            Arc arc_org = null;
            TextBlock t_org = null;

            for (int i = 0; i < BoltCnt / BPC; i++)
            {

                GetArcText(i * BPC, (i + 1) * BPC, $"{i + 1}", out Arc arc, out TextBlock t);

                if ((i + 1) == 1)
                {
                    arc.Fill = System.Windows.Media.Brushes.Red;
                }

                if (BPC == 1 && (i + 1) == OrgBoltNo)
                {
                    //凸显！！！！！！
                    arc_org = arc;
                    t_org = t;
                }
                else
                {
                    LayoutRoot.Children.Add(arc);
                    LayoutRoot.Children.Add(t);
                }
            }

            if (arc_org == null)
            {
                //因为 BPC !=1 手动添加一个
                int index = OrgBoltNo - 1;
                GetArcText(index, index + 1, $"{ 1.0*OrgBoltNo / BPC:F1}", out arc_org, out t_org);
            }

            if (arc_org != null)
            {
                double zoomIn_angle = (arc_org.EndAngle - arc_org.StartAngle) / 4;
                arc_org.Fill = Brushes.White;// new SolidColorBrush(Color.FromRgb(0x57, 0x9a, 0xab));
                double zoomIn_thickness = arc_org.ArcThickness / 2;
                arc_org.Stroke = Brushes.Black;
                arc_org.Width += zoomIn_thickness;
                arc_org.ArcThickness += zoomIn_thickness;
                arc_org.Height = arc_org.Width;
                arc_org.Margin = new Thickness(arc_org.Margin.Left - zoomIn_thickness / 2);
                arc_org.StartAngle -= zoomIn_angle;
                arc_org.EndAngle += zoomIn_angle;

                LayoutRoot.Children.Add(arc_org);

                t_org.Foreground = Brushes.Black;
                //if (OrgBoltNo == 1)
                //{
                //    t_org.Foreground = Brushes.White;
                //}
                LayoutRoot.Children.Add(t_org);
            }
        }
        /// <summary>
        /// 画X轴的线
        /// </summary>
        void Draw_AxisXLine()
        {

            if (HasAlianZone && AlianZoneBoltCnt > 0 && AlianZoneIsShowXStep)
            {
                for (int i = 0; i < AlianZoneBoltCnt; i++)
                {
                    double angle = BoltIndex2WpfAngle(AlianZoneIsCCW, AlianZoneBoltNoOf3oClock, AlianZoneBoltCnt,true, i);

                    Point p1 = Polar.ToPoint(
                        new Polar() { Degrees = angle, Radius = InnerRingThickness + GraphThickness },
                        Center);

                    Point p2 = Polar.ToPoint(
                        new Polar() { Degrees = angle, Radius = InnerRingThickness },
                        Center);

                    Line l = new Line() { X1 = p1.X, Y1 = p1.Y, X2 = p2.X, Y2 = p2.Y, Stroke = new SolidColorBrush(Colors.LightGray) };
                    LayoutRoot.Children.Add(l);
                }
            }
            else
            {
                double boltNoOf3oClock = GetBoltNoOf3oClock();

                for (int i = 0; i < BoltCnt / BPC; i += XStep)
                {
                    int start_boltindex = i * BPC;

                    double angle = BoltIndex2WpfAngle(!IsForwCW, boltNoOf3oClock, BoltCnt, false, start_boltindex);

                    Point p1 = Polar.ToPoint(
                        new Polar() { Degrees = angle, Radius = InnerRingThickness + GraphThickness },
                        Center);

                    Point p2 = Polar.ToPoint(
                        new Polar() { Degrees = angle, Radius = InnerRingThickness },
                        Center);

                    Line l = new Line() { X1 = p1.X, Y1 = p1.Y, X2 = p2.X, Y2 = p2.Y, Stroke = new SolidColorBrush(Colors.LightGray) };
                    LayoutRoot.Children.Add(l);
                }
            }
        }


        /// <summary>
        /// 画外圈的轴2 标签
        /// </summary>
        void Draw_AxisX2Label()
        {
            if (!HasAlianZone || AlianZoneBoltCnt <= 1)
                return;

            for (int i = 0; i < AlianZoneBoltCnt; i++)
            {
                (double startAngle, double endAngle) = BoltIndex2WpfAngle(AlianZoneIsCCW, AlianZoneBoltNoOf3oClock, AlianZoneBoltCnt, true, i, i+1);

                Arc arc = new Arc();
                arc.ArcThickness = AlianZoneRingThickness;
                arc.ArcThicknessUnit = Microsoft.Expression.Media.UnitType.Pixel;
                arc.StartAngle = startAngle;
                arc.EndAngle = endAngle;
                arc.Stretch = System.Windows.Media.Stretch.None;
                arc.Stroke = System.Windows.Media.Brushes.Black;
                arc.Fill = System.Windows.Media.Brushes.LightGray;
                arc.Width = (Radius - 0 * arc.ArcThickness) * 2;
                arc.Height = arc.Width;
                arc.Margin = new Thickness(Radius - arc.Width / 2);
                arc.Opacity = 1;


                //分区块的中心
                Point p = Polar.ToPoint(
                    new Polar()
                    {
                        Degrees = (endAngle + startAngle) / 2,
                        Radius = arc.Width / 2 - arc.ArcThickness / 2
                    },
                    Center);

                TextBlock t = new TextBlock()
                {
                    TextWrapping = System.Windows.TextWrapping.NoWrap,

                    TextAlignment = System.Windows.TextAlignment.Center,
                    Width = 20,
                    Height = 15,
                    Text = (i + 1).ToString(),
                    FontFamily = new System.Windows.Media.FontFamily("Trebuchet MS"),
                    FontWeight = System.Windows.FontWeights.Bold,
                    Foreground = System.Windows.Media.Brushes.Black
                };

                t.SetValue(Canvas.LeftProperty, p.X - t.Width / 2);
                t.SetValue(Canvas.TopProperty, p.Y - t.Height / 2);

                LayoutRoot.Children.Add(arc);
                LayoutRoot.Children.Add(t);
            }
        }

        /// <summary>
        /// 画Y轴
        /// </summary>
        void Draw_AxisYLine()
        {

            var resourceDictionary = new ResourceDictionary() { Source = new Uri("pack://application:,,,/FLY.Thick.Blowing.UI;component/Themes/Colors.xaml") };
            var chartSeparator = resourceDictionary["Brushes.ChartSeparator"] as SolidColorBrush;
            var chartAxisLabel1 = resourceDictionary["Brushes.ChartAxisLabel1"] as SolidColorBrush;
            var chartAxisLabel2 = resourceDictionary["Brushes.ChartAxisLabel2"] as SolidColorBrush;
            var chartAxisLabel0 = resourceDictionary["Brushes.ChartAxisLabel0"] as SolidColorBrush;

            double r = InnerRingThickness;
            //最里面的圆
            Ellipse ellipse_inner = new Ellipse()
            {
                Width = r * 2,
                Height = r * 2,
                Stroke = Brushes.Black,
                Margin = new Thickness(Radius - r)
            };
            LayoutRoot.Children.Add(ellipse_inner);
            //目标线
            r = InnerRingThickness + GraphThickness * 0.5;
            Ellipse ellipse_target = new Ellipse()
            {
                Width = r * 2,
                Height = r * 2,
                Stroke = AreaColors[0],
                Margin = new Thickness(Radius - r),
                StrokeThickness = 1
            };
            LayoutRoot.Children.Add(ellipse_target);

            double toleranceThickness = GraphThickness / (2 * YRangePercent);
            double target_r = r;

            for (int i = 1; i < YRangePercent; i++)
            {
                Brush stroke;
                if (i == 1)
                {
                    stroke = chartAxisLabel1;
                }
                else if (i == 2)
                {
                    stroke = chartAxisLabel2;
                }
                else
                {
                    stroke = chartSeparator;
                }


                //-公差线
                r = target_r + toleranceThickness * i;
                Ellipse ellipse_alarm1 = new Ellipse()
                {
                    Width = r * 2,
                    Height = r * 2,
                    Stroke = stroke,
                    Margin = new Thickness(Radius - r),
                    StrokeThickness = 1
                };

                //+公差线
                r = target_r - toleranceThickness * i;
                Ellipse ellipse_alarm2 = new Ellipse()
                {
                    Width = r * 2,
                    Height = r * 2,
                    Stroke = stroke,
                    Margin = new Thickness(Radius - r),
                    StrokeThickness = 1
                };

                LayoutRoot.Children.Add(ellipse_alarm1);
                LayoutRoot.Children.Add(ellipse_alarm2);
            }
        }

        /// <summary>
        /// 初始化所有 BoltArc
        /// </summary>
        void Draw_Series()
        {
            double boltNoOf3oClock = GetBoltNoOf3oClock();

            if (UIElement_DataArc.Count > 0)
            {
                foreach (Arc arc in UIElement_DataArc)
                    LayoutRoot.Children.Remove(arc);
                UIElement_DataArc.Clear();
            }


            for (int i = 0; i < BoltCnt; i++)
            {
                (double startAngle, double endAngle) = BoltIndex2WpfAngle(!IsForwCW, boltNoOf3oClock, BoltCnt,false, i, i + 1);

                Arc arc = new Arc()
                {
                    ArcThicknessUnit = Microsoft.Expression.Media.UnitType.Pixel,
                    StartAngle = startAngle,
                    EndAngle = endAngle,
                    Stretch = System.Windows.Media.Stretch.None,
                    Stroke = System.Windows.Media.Brushes.Black,
                    StrokeThickness = 1,

                };

                Update_OneData(i, arc);

                LayoutRoot.Children.Add(arc);
                UIElement_DataArc.Add(arc);
            }
        }
        void Draw_LineSeries()
        {
            PathGeometry aPathGeometry = new PathGeometry();
            if (linePath != null)
            {
                LayoutRoot.Children.Remove(linePath);
            }
            linePath = new Path() { Stroke = new SolidColorBrush(Colors.Blue), StrokeThickness = 4.0 };
            linePath.Data = aPathGeometry;
            aPathGeometry.Figures = new PathFigureCollection();

            LayoutRoot.Children.Add(linePath);

            //aPathGeometry.Figures.Add(new PathFigure() { StartPoint =}

            PathFigure lastPathFigure = null;
            for (int i = 0; i < BoltCnt; i++)
            {
                Point p = Get_LineDataPoint(i);
                if (double.IsNaN(p.X))
                {
                    //这个空点，结束上一个figure
                    lastPathFigure = null;
                    continue;
                }

                if (lastPathFigure == null)
                {
                    lastPathFigure = new PathFigure() { StartPoint = p };
                    aPathGeometry.Figures.Add(lastPathFigure);
                    continue;
                }

                lastPathFigure.Segments.Add(new LineSegment() { Point = p });
            }

            //最后一个点，需要与第1个点连在一起
            {
                Point p = Get_LineDataPoint(0);
                if (double.IsNaN(p.X))
                {
                    //这个空点，结束上一个figure
                    lastPathFigure = null;
                    //完成
                }
                else if (lastPathFigure == null)
                {
                    //完成
                }
                else
                {
                    lastPathFigure.Segments.Add(new LineSegment() { Point = p });
                }
            }
        }

        /// <summary>
        /// 画Y轴上 +5% ，-5%
        /// </summary>
        void Draw_AxisYLabel()
        {
            //永远画在探头方向 的Y轴上
            double startAngle = TransformDegrees(0);
            double percent = TolerancePercent;
            if (percent < 0.01)
                percent = 0.01;
            double toleranceThickness = GraphThickness / (2 * YRangePercent);
            double target_r = InnerRingThickness + GraphThickness * 0.5;

            if (IsPercent)
            {
                string text = $"{(100 * percent):F0}%";
                //Value 外大 内小
                //负公差
                Draw_Marker(new Polar() { Degrees = startAngle, Radius = target_r - toleranceThickness }, $"-{text}");

                //正公差
                Draw_Marker(new Polar() { Degrees = startAngle, Radius = target_r + toleranceThickness }, $"+{text}");
            }
            else
            {
                var tolerance = ActualTarget * percent;

                string text = $"{ActualTarget - tolerance:F1}";
                //Value 外大 内小
                //负公差
                Draw_Marker(new Polar() { Degrees = startAngle, Radius = target_r - toleranceThickness }, text);

                text = $"{ActualTarget + tolerance:F1}";
                //正公差
                Draw_Marker(new Polar() { Degrees = startAngle, Radius = target_r + toleranceThickness }, text);
            }

        }

        /// <summary>
        /// 画标记，就是 画Y轴上 +5% 圆形中间有字
        /// </summary>
        /// <param name="polar"></param>
        /// <param name="s"></param>
        void Draw_Marker(Polar polar, string s)
        {
            Point p1 = Polar.ToPoint(
                polar,
                Center);

            SolidColorBrush brush_alarm = new SolidColorBrush(Color.FromRgb(0xff, 0xc1, 0xc1));
            SolidColorBrush brush_line = new SolidColorBrush(Color.FromRgb(208, 208, 208));
            double r = 15;
            //底
            Ellipse ellipse_background = new Ellipse()
            {
                Width = r * 2,
                Height = r * 2,
                Fill = System.Windows.Media.Brushes.Red,
                Opacity = 0.8,
                Stroke = System.Windows.Media.Brushes.Black,
                StrokeThickness = 1
            };
            //Rectangle ellipse_background = new Rectangle()
            //{
            //    Width = r * 2,
            //    Height = r*2,
            //    Fill = System.Windows.Media.Brushes.Red,
            //    Opacity = 0.8,
            //    Stroke = System.Windows.Media.Brushes.Black,
            //    StrokeThickness = 1
            //};
            ellipse_background.SetValue(Canvas.LeftProperty, p1.X - ellipse_background.Width / 2);
            ellipse_background.SetValue(Canvas.TopProperty, p1.Y - ellipse_background.Width / 2);

            TextBlock t = new TextBlock()
            {
                TextWrapping = System.Windows.TextWrapping.NoWrap,
                TextAlignment = System.Windows.TextAlignment.Center,
                Width = 22,
                Height = 14,
                Text = s,
                FontFamily = new System.Windows.Media.FontFamily("Trebuchet MS"),
                FontWeight = System.Windows.FontWeights.Bold,
                Foreground = System.Windows.Media.Brushes.White,
                FontSize = 10,
            };

            t.SetValue(Canvas.LeftProperty, p1.X - t.Width / 2);
            t.SetValue(Canvas.TopProperty, p1.Y - t.Height / 2);

            LayoutRoot.Children.Add(ellipse_background);
            LayoutRoot.Children.Add(t);
        }
        void Clear()
        {
            LayoutRoot.Children.Clear();
            UIElement_DataArc.Clear();
            linePath = null;
        }

        /// <summary>
        /// 只画1个Data数据
        /// </summary>
        /// <param name="index"></param>
        void Update_OneData(int index)
        {
            if (index >= UIElement_DataArc.Count)
                return;

            Update_OneData(index, UIElement_DataArc[index]);
        }

        void Update_OneData(int index, Arc arc)
        {
            double percent = TolerancePercent;
            if (percent < 0.01)
                percent = 0.01;

            double r = 0;
            if (Values != null && index < Values.Count && !double.IsNaN(Values[index]))
            {
                r = ((Values[index] - ActualTarget) / ActualTarget) / (2 * YRangePercent * percent) * GraphThickness;
                arc.Visibility = Visibility.Visible;
            }
            else
            {
                arc.Visibility = Visibility.Hidden;
            }

            double target_r = InnerRingThickness + GraphThickness * 0.5;

            //--------------------------------------------------------------
            //限制
            if (r > GraphThickness * 0.5)
            {
                r = GraphThickness * 0.5;
            }
            else if (r < -GraphThickness * 0.5)
            {
                r = -GraphThickness * 0.5;
            }


            //--------------------------------------------------------------
            //改变颜色
            double toleranceThickness = GraphThickness / (YRangePercent * 2);

            if (r > toleranceThickness * 2)
            {
                arc.Fill = AreaColors[2];
            }
            else if (r < -toleranceThickness * 2)
            {
                arc.Fill = AreaColors[2];
            }

            else if (r > toleranceThickness)
            {
                arc.Fill = AreaColors[1];
            }
            else if (r < -toleranceThickness)
            {
                arc.Fill = AreaColors[1];
            }
            else
            {
                arc.Fill = AreaColors[0];
            }

            //扇型的厚度
            arc.ArcThickness = Math.Abs(r);

            //扇型最外圆直径

            //Value 外小 内大
            //if (r < 0)
            //    arc.Width = (target_r - r) * 2;
            //else
            //    arc.Width = target_r * 2;
            //Value 外大 内小
            if (r > 0)
                arc.Width = (target_r + r) * 2;
            else
                arc.Width = target_r * 2;


            arc.Height = arc.Width;
            arc.Margin = new Thickness(Radius - arc.Width / 2);

        }
        Point Get_LineDataPoint(int index)
        {
            double boltNoOf3oClock = GetBoltNoOf3oClock();
            double angle = BoltIndex2WpfAngle(!IsForwCW, boltNoOf3oClock, BoltCnt, false, index + 0.5);

            Point center = new Point(Radius, Radius);
            double percent = TolerancePercent;
            if (percent < 0.01)
                percent = 0.01;

            double r = 0;
            if (LineValues != null && index < LineValues.Count && !double.IsNaN(LineValues[index]))
            {
                r = ((LineValues[index] - ActualTarget) / ActualTarget) / (2 * YRangePercent * percent) * GraphThickness;

            }
            else
            {
                return new Point(double.NaN, double.NaN);
            }

            double target_r = InnerRingThickness + GraphThickness * 0.5;

            //--------------------------------------------------------------
            //限制
            if (r > GraphThickness * 0.5)
            {
                r = GraphThickness * 0.5;
            }
            else if (r < -GraphThickness * 0.5)
            {
                r = -GraphThickness * 0.5;
            }

            //--------------------------------------------------------------
            //改变颜色
            //double toleranceThickness = GraphThickness / (YRangePercent * 2);

            return DegreesToPoint(center, target_r + r, angle);
        }
        void Update_Line()
        {
            PathGeometry aPathGeometry = linePath.Data as PathGeometry;
            aPathGeometry.Figures.Clear();

            PathFigure lastPathFigure = null;
            for (int i = 0; i < BoltCnt; i++)
            {
                Point p = Get_LineDataPoint(i);
                if (double.IsNaN(p.X))
                {
                    //这个空点，结束上一个figure
                    lastPathFigure = null;
                    continue;
                }

                if (lastPathFigure == null)
                {
                    lastPathFigure = new PathFigure() { StartPoint = p };
                    aPathGeometry.Figures.Add(lastPathFigure);
                    continue;
                }

                lastPathFigure.Segments.Add(new LineSegment() { Point = p });
            }

            //最后一个点，需要与第1个点连在一起
            {
                Point p = Get_LineDataPoint(0);
                if (double.IsNaN(p.X))
                {
                    //这个空点，结束上一个figure
                    lastPathFigure = null;
                    //完成
                }
                else if (lastPathFigure == null)
                {
                    //完成
                }
                else
                {
                    lastPathFigure.Segments.Add(new LineSegment() { Point = p });
                }
            }
        }
        /// <summary>
        /// 与 Multi,EmptyValue,DataFirst,DataLast 相关
        /// </summary>
        void UpdateAvg()
        {
            if (Values == null)
                return;
            List<double> datlist;
            if (BoltCnt >= Values.Count())
            {
                datlist = Values.ToList();
            }
            else
            {
                datlist = Values.ToList().GetRange(0, BoltCnt);
            }
            double avg = datlist.AverageNoNull();
            Avg = avg;
            return;
        }
        void Update_Datas()
        {
            UpdateAvg();
            UpdateActualTarget();
            for (int i = 0; i < BoltCnt; i++)
                Update_OneData(i);
        }
        void Update_LineDatas()
        {
            Update_Line();
        }
        //public void Draw

        #region INotifyPropertyChanged 成员
        public void NotifyPropertyChanged(string propertyName)
        {
            if (PropertyChanged != null)
                PropertyChanged.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
        public event PropertyChangedEventHandler PropertyChanged;

        #endregion

        private void UserControl_Loaded(object sender, RoutedEventArgs e)
        {
            Draw();
        }



        bool batabindall_flag = false;
        bool batabindall_line_flag = false;
        bool draw_flag = false;
        System.Windows.Threading.DispatcherTimer timer = new System.Windows.Threading.DispatcherTimer();
        void DataBindAll_Init()
        {
            timer = new System.Windows.Threading.DispatcherTimer();
            timer.Tick += new EventHandler(delegate (object sender, EventArgs e)
            {
                if (draw_flag)
                {
                    draw_flag = false;
                    batabindall_flag = false;
                    batabindall_line_flag = false;
                    Draw();
                }
                if (batabindall_flag)
                {
                    batabindall_flag = false;
                    Update_Datas();
                }
                if (batabindall_line_flag)
                {
                    batabindall_line_flag = false;
                    Update_LineDatas();
                }
            });

            timer.Interval = TimeSpan.FromSeconds(0.2);
            timer.Start();
        }
        void DataBindAll()
        {
            batabindall_flag = true;
        }
        void DataBindAll_line()
        {
            batabindall_line_flag = true;
        }
    }
    public interface IPolarChart
    {
        /// <summary>
        /// 分区数
        /// </summary>
        int BoltCnt { get; set; }

        /// <summary>
        /// 分区/加热通道
        /// </summary>
        int BPC { get; set; }

        /// <summary>
        /// X轴间隔
        /// </summary>
        int XStep { get; set; }

        /// <summary>
        /// 测厚仪测量点位置方向：Left， Right （也就是三角形在左还是右）
        /// </summary>
        bool MPIsRight { get; set; }

        /// <summary>
        /// X轴排列的方向是顺时钟方向 CW, 默认是逆时钟方向 CCW
        /// </summary>
        bool IsForwCW { get; set; }

        /// <summary>
        /// 复位分区号，也就是三角形对应的 分区号
        /// </summary>
        int OrgBoltNo { get; set; }

        /// <summary>
        /// 公差%
        /// </summary>
        double TolerancePercent { get; set; }

        /// <summary>
        /// Y轴是 TolerancePercent 的倍数
        /// </summary>
        double YRangePercent { get; set; }

        /// <summary>
        /// 目标值
        /// </summary>
        double Target { get; set; }

        /// <summary>
        /// 实际目标值
        /// </summary>
        double ActualTarget { get; }

        /// <summary>
        /// Y轴%显示
        /// </summary>
        bool IsPercent { get; set; }

        /// <summary>
        /// Y轴自动目标值
        /// </summary>
        bool IsAutoTarget { get; set; }

        /// <summary>
        /// 数据源
        /// </summary>
        ObservableCollection<double> Values { get; set; }

        /// <summary>
        /// 数据源
        /// </summary>
        ObservableCollection<double> LineValues { get; set; }

        /// <summary>
        /// 显示格外分区
        /// </summary>
        bool HasAlianZone { get; set; }

        /// <summary>
        /// 3点方向，对应的No 
        /// </summary>
        double AlianZoneBoltNoOf3oClock { get; set; }

        /// <summary>
        /// 额外分区数
        /// </summary>
        int AlianZoneBoltCnt { get; set; }

        /// <summary>
        /// 是逆时针排列 counter-clockwise
        /// </summary>
        bool AlianZoneIsCCW { get; set; }

        /// <summary>
        /// X轴线 显示为额外分区的间隔
        /// </summary>
        bool AlianZoneIsShowXStep { get; set; }
    }

    /// <summary>
    /// Polar 12点方向=0°，3点方向=90°，6点方向=180°，9点方向=270°
    /// Point 左上角 x=0,y=0; 右上角 x=100, y=0; 左下角 x=0,y=100;
    /// </summary>
    class Polar
    {
        public double Degrees;//角度制！！！
        public double Radius;
        public static Point ToPoint(Polar polar, Point center)
        {
            Point p = new Point();
            Vector v = new Vector();
            v.Y = -polar.Radius * Math.Cos(DegreesToRadians(polar.Degrees));
            v.X = polar.Radius * Math.Sin(DegreesToRadians(polar.Degrees));
            p = center + v;
            return p;
        }
        public static double DegreesToRadians(double degrees)
        {
            double radians = Math.PI / 180 * degrees;
            return radians;
        }

    }
}