MARKUS

using System;

using System.Net;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Documents;

using System.Windows.Ink;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Animation;

using System.Windows.Shapes;

using System.Collections.Generic;

using System.ComponentModel;

using MarkupToPDF.Controls.Common;

using MarkupToPDF.Common;

using MarkupToPDF.Serialize.Core;

using MarkupToPDF.Serialize.S_Control;

using System.Linq;

namespace MarkupToPDF.Controls.Polygon

{

    public class CloudControl : CommentUserInfo, IDisposable, INotifyPropertyChanged, IShapeControl, ICloudControl, IDashControl

    {

        private const string PART_CloudPath = "PART_CloudPath";

        private const string PART_CloudSubPath = "PART_CloudSubPath";

        public Path Base_CloudPath = null;

        public Path Base_CloudSubPath = null;

        private const double _CloudArcDepth =0.8;  /// 2018.05.14 added by humkyung

        static CloudControl()

        {

            DefaultStyleKeyProperty.OverrideMetadata(typeof(CloudControl), new FrameworkPropertyMetadata(typeof(CloudControl)));

            //Application.Current.Resources.MergedDictionaries.Add(Application.LoadComponent(new Uri("/MarkupToPDF;Component/Themes/generic.xaml")) as ResourceDictionary);

            //ResourceDictionary dictionary = new ResourceDictionary();

            //dictionary.Source = new Uri("/MarkupToPDF;component/themes/generic.xaml", UriKind.RelativeOrAbsolute);

            //Application.Current.Resources.MergedDictionaries.Add(dictionary);

        }

        public CloudControl()

        {

            //this.DefaultStyleKey = typeof(CloudControl);

        }

        public override void Copy(CommentUserInfo lhs)

        {

            if (lhs is CloudControl item)

            {

                this.LineSize = item.LineSize;

                this.Toler = item.Toler;

                this.PointSet = item.PointSet.ConvertAll(x => new Point(x.X, x.Y));

                this.ArcLength = item.ArcLength;

                this.Paint = item.Paint;

                this.Opacity = item.Opacity;

                this.StrokeColor = item.StrokeColor;

                this.isTransOn = item.isTransOn;

                this.isChain = item.isChain;

                this.DashSize = item.DashSize;

                this.UserID = item.UserID;

                this.StartPoint = new Point(item.StartPoint.X, item.StartPoint.Y);

                this.EndPoint = new Point(item.EndPoint.X, item.EndPoint.Y);

                this.Memo = item.Memo;

                this.ZIndex = item.ZIndex;

            }

        }

        public override CommentUserInfo Clone()

        {

            var clone = new CloudControl();

            clone.Copy(this);

            return clone;

        }

        #region Dependency Properties

        public static readonly DependencyProperty UserIDProperty = DependencyProperty.Register(

                "UserID", typeof(string), typeof(CloudControl), new PropertyMetadata(null));

        public static readonly DependencyProperty LineSizeProperty = DependencyProperty.Register(

                "LineSize", typeof(double), typeof(CloudControl), new PropertyMetadata((Double)3));

        //강인구 추가

        public static readonly DependencyProperty DashSizeProperty = DependencyProperty.Register(

                 "DashSize", typeof(DoubleCollection), typeof(CloudControl), new PropertyMetadata(new DoubleCollection { 99999999 }, PointValueChanged));

        public static readonly DependencyProperty FillColorProperty = DependencyProperty.Register(

                "FillColor", typeof(SolidColorBrush), typeof(CloudControl), new PropertyMetadata(new SolidColorBrush(Colors.Red)));

        public static readonly DependencyProperty IsCompletedProperty = DependencyProperty.Register(

                "IsCompleted", typeof(bool), typeof(CloudControl), null);

        //강인구

        public static readonly DependencyProperty PaintProperty = DependencyProperty.Register(

                "Paint", typeof(PaintSet), typeof(CloudControl), new PropertyMetadata(PaintSet.None, PointValueChanged));

        public static readonly DependencyProperty StrokeColorProperty = DependencyProperty.Register(

                "StrokeColor", typeof(SolidColorBrush), typeof(CloudControl), new PropertyMetadata(new SolidColorBrush(Colors.Red)));

        public static readonly DependencyProperty ArcLengthProperty = DependencyProperty.Register(

                "ArcLength", typeof(double), typeof(CloudControl), new PropertyMetadata((Double)10, PointValueChanged));

        public static readonly DependencyProperty PathDataProperty = DependencyProperty.Register(

                "PathData", typeof(Geometry), typeof(CloudControl), null);

        public static readonly DependencyProperty PathSubDataProperty = DependencyProperty.Register(

                "PathSubData", typeof(Geometry), typeof(CloudControl), null);

        public static readonly DependencyProperty EndPointProperty = DependencyProperty.Register(

                "EndPoint", typeof(Point), typeof(CloudControl), new PropertyMetadata(new Point(0, 0), PointValueChanged));

        public static readonly DependencyProperty StartPointProperty = DependencyProperty.Register(

                "StartPoint", typeof(Point), typeof(CloudControl), new PropertyMetadata(new Point(0, 0), PointValueChanged));

        public static readonly DependencyProperty PointSetProperty = DependencyProperty.Register(

                "PointSet", typeof(List<Point>), typeof(CloudControl), new PropertyMetadata(new List<Point>(), PointValueChanged));

        public static readonly DependencyProperty isTransOnProperty = DependencyProperty.Register(

                "isTransOn", typeof(bool), typeof(CloudControl), new PropertyMetadata(false));

        public static readonly DependencyProperty isChainProperty = DependencyProperty.Register(

                "isChain", typeof(bool), typeof(CloudControl), new PropertyMetadata(false));

        /// <summary>

        /// StylusPointSet을 List<Point>로 대체하면 PointValueChanged가 작동안한다.

        /// </summary>

        public static readonly DependencyProperty StylusPointSetProperty = DependencyProperty.Register(

               "PointC", typeof(StylusPointSet), typeof(CloudControl), new PropertyMetadata(new StylusPointSet(), PointValueChanged));

        public static readonly DependencyProperty AngleProperty = DependencyProperty.Register("AngleValue", typeof(double), typeof(CloudControl),

            new PropertyMetadata((double)0.0, new PropertyChangedCallback(AngleValueChanged)));

        public static readonly DependencyProperty CenterXProperty = DependencyProperty.Register("CenterX", typeof(double), typeof(CloudControl),

            new PropertyMetadata((double)0, OnCenterXYChanged));

        public static readonly DependencyProperty CenterYProperty = DependencyProperty.Register("CenterY", typeof(double), typeof(CloudControl),

            new PropertyMetadata((double)0, OnCenterXYChanged));

        public static readonly DependencyProperty IsSelectedProperty =

    DependencyProperty.Register("IsSelected", typeof(bool), typeof(CloudControl), new FrameworkPropertyMetadata(false, IsSelectedChanged));

        public static readonly DependencyProperty ControlTypeProperty =

            DependencyProperty.Register("ControlType", typeof(ControlType), typeof(CloudControl), new FrameworkPropertyMetadata(ControlType.PolygonCloud));

        public static readonly DependencyProperty OverViewPathDataProperty = DependencyProperty.Register(

        "OverViewPathData", typeof(Geometry), typeof(ControlType), null);

        public static readonly DependencyProperty CanvasXProperty = DependencyProperty.Register(

                "CanvasX", typeof(double), typeof(CloudControl), new PropertyMetadata((double)0, OnSetCansvasChanged));

        public static readonly DependencyProperty CanvasYProperty = DependencyProperty.Register(

                "CanvasY", typeof(double), typeof(CloudControl), new PropertyMetadata((double)0, OnSetCansvasChanged));

        #endregion

        #region PropertyChanged Method

        public static void OnSetCansvasChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (CloudControl)sender;

            if (e.OldValue != e.NewValue && instance != null)

            {

                instance.SetValue(e.Property, e.NewValue);

            }

        }

        public static void PointValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (CloudControl)sender;

            if (e.OldValue != e.NewValue && instance.Base_CloudPath != null)

            {

                instance.SetValue(e.Property, e.NewValue);

                //강인구 추가

                instance.SetCloud();

                //주석처리

            }

        }

        public static void IsSelectedChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            //var instance = (CloudControl)sender;

            //if (e.OldValue != e.NewValue && instance.Base_CloudPath != null)

            //{

            //    instance.SetValue(e.Property, e.NewValue);

            //    if (instance.IsSelected)

            //    {

            //        instance.Base_CloudPath.Stroke = new SolidColorBrush(Colors.Blue);

            //    }

            //    else

            //    {

            //        instance.Base_CloudPath.Stroke = new SolidColorBrush(Colors.Red);

            //    }

            //}

        }

        public static void OnCenterXYChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (CloudControl)sender;

            if (e.OldValue != e.NewValue && instance.Base_CloudPath != null)

            {

                instance.SetValue(e.Property, e.NewValue);

                instance.DrawingCloud();

            }

        }

        public static void AngleValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

        {

            var instance = (CloudControl)sender;

            if (e.OldValue != e.NewValue && instance.Base_CloudPath != null)

            {

                instance.SetValue(e.Property, e.NewValue);

                instance.DrawingCloud();

            }

        }

        #endregion

        #region Properties

        public bool IsCompleted

        {

            get { return (bool)GetValue(IsCompletedProperty); }

            set

            {

                SetValue(IsCompletedProperty, value);

            }

        }

        public Geometry OverViewPathData

        {

            get { return (Geometry)GetValue(OverViewPathDataProperty); }

            set

            {

                SetValue(OverViewPathDataProperty, value);

                OnPropertyChanged("OverViewPathData");

            }

        }

        public double CanvasX

        {

            get { return (double)GetValue(CanvasXProperty); }

            set

            {

                if (this.CanvasX != value)

                {

                    SetValue(CanvasXProperty, value);

                }

            }

        }

        public double CanvasY

        {

            get { return (double)GetValue(CanvasYProperty); }

            set

            {

                if (this.CanvasY != value)

                {

                    SetValue(CanvasYProperty, value);

                }

            }

        }

        public override bool IsSelected

        {

            get

            {

                return (bool)GetValue(IsSelectedProperty);

            }

            set

            {

                SetValue(IsSelectedProperty, value);

            }

        }

        public override ControlType ControlType

        {

            set

            {

                SetValue(ControlTypeProperty, value);

            }

            get

            {

                return (ControlType)GetValue(ControlTypeProperty);

            }

        }

        public Double LineSize

        {

            get { return (Double)GetValue(LineSizeProperty); }

            set

            {

                if (this.LineSize != value)

                {

                    SetValue(LineSizeProperty, value);

                }

            }

        }

        public bool isChain

        {

            get { return (bool)GetValue(isChainProperty); }

            set

            {

                SetValue(isChainProperty, value);

                OnPropertyChanged("isChain");

            }

        }

        public bool isTransOn

        {

            get { return (bool)GetValue(isTransOnProperty); }

            set

            {

                SetValue(isTransOnProperty, value);

                OnPropertyChanged("isTransOn");

            }

        }

        public DoubleCollection DashSize

        {

            get { return (DoubleCollection)GetValue(DashSizeProperty); }

            set

            {

                if (this.DashSize != value)

                {

                    SetValue(DashSizeProperty, value);

                    OnPropertyChanged("DashSize");

                }

            }

        }

        public string UserID

        {

            get { return (string)GetValue(UserIDProperty); }

            set

            {

                if (this.UserID != value)

                {

                    SetValue(UserIDProperty, value);

                    OnPropertyChanged("UserID");

                }

            }

        }

        public PaintSet Paint

        {

            get { return (PaintSet)GetValue(PaintProperty); }

            set

            {

                if (this.Paint != value)

                {

                    SetValue(PaintProperty, value);

                    OnPropertyChanged("Paint");

                }

            }

        }

        public SolidColorBrush FillColor

        {

            get { return (SolidColorBrush)GetValue(FillColorProperty); }

            set

            {

                if (this.FillColor != value)

                {

                    SetValue(FillColorProperty, value);

                    OnPropertyChanged("FillColor");

                }

            }

        }

        public override SolidColorBrush StrokeColor

        {

            get { return (SolidColorBrush)GetValue(StrokeColorProperty); }

            set

            {

                if (this.StrokeColor != value)

                {

                    SetValue(StrokeColorProperty, value);

                    OnPropertyChanged("StrokeColor");

                }

            }

        }

        public Geometry PathData

        {

            get 

            {

                return (Geometry)GetValue(PathDataProperty); 

            }

            set 

            {

                SetValue(PathDataProperty, value);

                OnPropertyChanged("PathData");

            }

        }

        public Geometry PathSubData

        {

            get 

            {

                return (Geometry)GetValue(PathSubDataProperty); 

            }

            set

            {

                SetValue(PathSubDataProperty, value);

                OnPropertyChanged("PathSubData");

            }

        }

        public Point EndPoint

        {

            get 

            {

                return (Point)GetValue(EndPointProperty); 

            }

            set

            {

                SetValue(EndPointProperty, value);

                OnPropertyChanged("EndPoint");

            }

        }

        public Point StartPoint

        {

            get 

            {

                return (Point)GetValue(StartPointProperty); 

            }

            set

            {

                SetValue(StartPointProperty, value);

                OnPropertyChanged("StartPoint");

            }

        }

        public List<Point> _pointSet;

        public List<Point> PointSet

        {

            get 

            {

                return (List<Point>)GetValue(PointSetProperty);

            }

            set 

            {

                SetValue(PointSetProperty, value);

                OnPropertyChanged("PointSet");

            }

        }

        public List<Point> pointSet

        {

            get

            {

                return _pointSet;

            }

            set

            {

                _pointSet = value;

                OnPropertyChanged("pointSet");

            }

        }

        public Double ArcLength

        {

            get { return (Double)GetValue(ArcLengthProperty); }

            set

            {

                if (this.ArcLength != value)

                {

                    SetValue(ArcLengthProperty, value);

                    OnPropertyChanged("ArcLength");

                }

            }

        }

        private double _toler = 1;

        public double Toler

        {

            get { return _toler; }

            set { _toler = value; }

        }

        //강인구 수정 클라우드 사이즈

        //private double _arcLength;

        ////private double _arcLength = 30;

        //public double ArcLength

        //{

        //    get { return _arcLength; }

        //    set { _arcLength = value; }

        //}

        private bool _fill = false;

        public bool Fill

        {

            get { return _fill; }

            set { _fill = value; }

        }

        //public double Angle

        //{

        //    get { return (double)GetValue(AngleProperty); }

        //    set

        //    {

        //        if (this.Angle != value)

        //        {

        //            SetValue(AngleProperty, value);

        //            OnPropertyChanged("Angle");

        //        }

        //    }

        //}

        public StylusPointSet PointC

        {

            get { return (StylusPointSet)GetValue(StylusPointSetProperty); }

            set

            {

                SetValue(StylusPointSetProperty, value);

                OnPropertyChanged("PointC");

            }

        }

        public double CenterX

        {

            get

            {

                return (double)GetValue(CenterXProperty); 

            }

            set

            {

                SetValue(CenterXProperty, value);

                OnPropertyChanged("CenterX");

            }

        }

        public double CenterY

        {

            get

            { 

                return (double)GetValue(CenterYProperty); 

            }

            set

            {

                SetValue(CenterYProperty, value);

                OnPropertyChanged("CenterY");

            }

        }

        public double AngleValue

        {

            get 

            {

                return (double)GetValue(AngleProperty); 

            }

            set

            {

                SetValue(AngleProperty, value);

                OnPropertyChanged("AngleValue");

            }

        }

        #endregion

        #region Data

        private PathGeometry _pathGeometry = new PathGeometry();

        private PathGeometry _pathSubGeometry = new PathGeometry();

        #endregion

        public override void OnApplyTemplate()

        {

            base.OnApplyTemplate();

            Base_CloudPath = GetTemplateChild(PART_CloudPath) as Path;

            Base_CloudSubPath = GetTemplateChild(PART_CloudSubPath) as Path;

            SetCloud();

        }

        public void SetCloud()

        {

            //this.Width = this.Base_CloudPath.Width;

            //this.Height = this.Base_CloudPath.Height;

            this.ApplyTemplate();

            Generate();

            if (!isChain)

            {

                //ClosePath();

            }

        }

        public int Generate()

        {

            this._pathGeometry = null;

            this._pathSubGeometry = null;

            switch (this.Paint)

            {

                case PaintSet.None:

                    this.FillColor = null;

                    if (Base_CloudSubPath != null)

                    {

                        Base_CloudPath.Fill = null;

                        Base_CloudSubPath.Fill = null;

                        Base_CloudSubPath.Stroke = new SolidColorBrush(Colors.Transparent);

                        //Base_CloudSubPath.StrokeThickness = 3;

                    }                    

                    break;

                case PaintSet.Fill:

                    this.FillColor = this.StrokeColor;

                    if (Base_CloudSubPath != null)

                    {

                        if (isChain)

                        {

                            Base_CloudPath.Fill = null;

                            Base_CloudSubPath.Fill = null;

                            Base_CloudSubPath.Stroke = new SolidColorBrush(Colors.Transparent);

                            //Base_CloudSubPath.StrokeThickness = 3;

                        }

                        else

                        {

                            Base_CloudSubPath.Stroke = this.StrokeColor;

                            //Base_CloudSubPath.Stroke = new SolidColorBrush(Colors.Transparent);

                            Base_CloudSubPath.StrokeThickness = 0.5;

                            Base_CloudPath.Stroke = this.StrokeColor;

                            //Base_CloudPath.StrokeThickness = 3;

                            Base_CloudPath.Fill = this.FillColor;

                            Base_CloudSubPath.Fill = this.FillColor;

                        }

                    }                   

                    break;

                case PaintSet.Hatch:

                    if (Base_CloudSubPath != null && !isChain)

                    {

                        if (isChain)

                        {

                            Base_CloudPath.Fill = null;

                            Base_CloudSubPath.Fill = null;

                            Base_CloudSubPath.Stroke = new SolidColorBrush(Colors.Transparent);

                            //Base_CloudSubPath.StrokeThickness = 3;

                        }

                        else

                        {

                            var size = this.LineSize > 5 ? 5 : this.LineSize;

                            Base_CloudPath.Fill = HatchMake.CreateHatchBrush(this.StrokeColor, size * 0.1);

                            Base_CloudSubPath.Fill = HatchMake.CreateHatchBrush(this.StrokeColor, size * 0.1);

                            Base_CloudSubPath.Stroke = new SolidColorBrush(Colors.Transparent);

                        }

                    }

                    break;

                default:

                    break;

            }

            //강인구 추가

            if (Base_CloudPath != null)

            {

                Base_CloudPath.StrokeDashArray.Clear();

                Base_CloudSubPath.StrokeDashArray.Clear();

                foreach (var item in this.DashSize)

                {

                    Base_CloudPath.StrokeDashArray.Add(item);

                    Base_CloudSubPath.StrokeDashArray.Add(item);

                }

            }

            /// set reverse if area is greater 0 - 2012.07.04 added by humkyung

            double area = MathSet.AreaOf(this.PointSet);

            bool reverse = (area > 0);

            /// up to here

            this._pathGeometry = new PathGeometry { FillRule = FillRule.Nonzero};

            this._pathSubGeometry = new PathGeometry { FillRule = FillRule.Nonzero };

            if (isTransOn) // true라면 클라우드 컨트롤

            {

                //PathFigure pathFigure = CloudControl.GeneratePolyWithCloud(this.PointSet, this.ArcLength, reverse);

                //_pathGeometry.Figures.Add(pathFigure);

                for (int i = 0; i < this.PointSet.Count - 1; i++)

                {

                    var stPoint = this.PointSet[i];

                    Point edPoint = this.PointSet[i + 1];

                    //if (i < this.PointSet.Count() - 1)

                    //{

                    //    edPoint = this.PointSet[i + 1];

                    //}

                    //else

                    //{

                    //    edPoint = this.PointSet[0];

                    //}

                    PathFigure pathFigure = CloudControl.GenerateLineWithCloud(stPoint, edPoint, this.ArcLength, reverse);

                    _pathGeometry.Figures.Add(pathFigure);

                }

            }

            else

            {

                PathFigure fm = new PathFigure();

                fm.StartPoint = this.PointSet[0];

                for (int i = 0; i < this.PointSet.Count() - 2; i++)

                {

                    fm.Segments.Add(new LineSegment { Point = this.PointSet[i] });

                }

                _pathGeometry.Figures.Add(fm);

            }

            if (this.Paint == PaintSet.Fill || this.Paint == PaintSet.Hatch)

            {

                PointCollection pd = new PointCollection();

                foreach (var item in this.PointSet)

                {

                    pd.Add(item);

                }

                _pathSubGeometry.Figures.Add(new PathFigure()

                {

                    Segments = new PathSegmentCollection()

                    {

                        new PolyLineSegment()

                        {

                              Points = pd

                        },

                    },

                    StartPoint = this.PointSet[0]

                });

                this.PathSubData = _pathSubGeometry;

            }

            StartPoint = PointSet[0];

            this.PathData = this._pathGeometry;

            this.OverViewPathData = PathData;

            this.StrokeColor = StrokeColor;

            this.LineSize = LineSize;

            EndPoint = PointSet[PointSet.Count - 1];

            return 0;

        }

        /// <summary>

        /// draw arcs between p1 and p2

        /// </summary>

        /// <author>humkyung</author>

        /// <param name="p1"></param>

        /// <param name="p2"></param>

        /// <param name="reverse"></param>

        /// <returns></returns>

        public static PathFigure GenerateLineWithCloud(Point p1, Point p2, double arcLength_, bool reverse, double linesize_ = -20)

        {

            PathFigure pathFigure = new PathFigure();

            //if (linesize_ == -20)

            //    linesize_ = arcLength_;

            var radius = arcLength_;

            double overlap =  5.5D / 6D;

            double delta = 2 * radius * overlap;

            pathFigure.IsClosed = false;

            pathFigure.IsFilled = false;

            var curr = p1;

            var prev = p2;         

            var dx = curr.X - prev.X;

            var dy = curr.Y - prev.Y;

             pathFigure.StartPoint =  p1; //new Point(p1.X + (40 * dx), p1.Y + (40 * dy));//

            var len = Math.Sqrt(dx * dx + dy * dy);

            dx = dx / len;

            dy = dy / len;

            var length = 0D;

            for (int a = 0; a <= Math.Round(len / delta); a++)

            {

                if (length > len)

                {

                    length = len;

                }

                ArcSegment arcSeg = new ArcSegment();

                var x = prev.X + length * dx;

                var y = prev.Y + length * dy;

                if(!double.IsNaN(x) && !double.IsNaN(y))

                {

                    arcSeg.Point = new Point(x, y); // (x + (40 * dx), y + (40 * dy));

                    arcSeg.Size = new Size(radius, radius);

                    arcSeg.IsLargeArc = true;

                    if(reverse)

                    {

                       arcSeg.SweepDirection = SweepDirection.Counterclockwise;

                    }

                    else

                    {

                        arcSeg.SweepDirection = SweepDirection.Clockwise;

                    }

                    if (length == 0)

                    {

                        pathFigure.StartPoint = arcSeg.Point;

                    }

                    pathFigure.Segments.Add(arcSeg);

                }

                length += delta;

            }

            pathFigure.IsFilled = false;

            return pathFigure;

        }

        /// <summary>

        /// draw arcs between p1 and p2

        /// </summary>

        /// <author>humkyung</author>

        /// <param name="p1"></param>

        /// <param name="p2"></param>

        /// <param name="reverse"></param>

        /// <returns></returns>

        public static PathFigure GeneratePolyWithCloud(List<Point> points,double arcLength_, bool reverse)

        {

            PathFigure pathFigure = new PathFigure();

            var radius = arcLength_;

            double overlap = 5.5D / 6D;

            double delta = 2 * radius * overlap;

            if(points.Count() > 1)

            {

                pathFigure.StartPoint = points[0];

                pathFigure.IsClosed = false;

                pathFigure.IsFilled = false;

                Point prevArcPoint = points[0];

                for (int i = 0; i < points.Count -1; i++)

                {

                    Point curr = points[i];

                    Point prev = points[i + 1];

                    var dx = curr.X - prev.X;

                    var dy = curr.Y - prev.Y;

                    var len = Math.Sqrt(dx * dx + dy * dy);

                    dx = dx / len;

                    dy = dy / len;

                    var length = 0D;

                    for (int a = 0; a <= Math.Round(len / delta); a++)

                    {

                        if (length > len)

                        {

                            length = len;

                        }

                        ArcSegment arcSeg = new ArcSegment();

                        var x = prev.X + length * dx;

                        var y = prev.Y + length * dy;

                        if (!double.IsNaN(x) && !double.IsNaN(y))

                        {

                            arcSeg.Point = new Point(x, y);

                            arcSeg.Size = new Size(radius, radius);

                            arcSeg.IsLargeArc = true;

                            if (reverse)

                            {

                                arcSeg.SweepDirection = SweepDirection.Counterclockwise;

                            }

                            else

                            {

                                arcSeg.SweepDirection = SweepDirection.Clockwise;

                            }

                            //if (length == 0)

                            //{

                            //    pathFigure.StartPoint = arcSeg.Point;

                            //}

                            pathFigure.Segments.Add(arcSeg);

                            System.Diagnostics.Debug.WriteLine($"{prevArcPoint} { arcSeg.Point}");

                            prevArcPoint = arcSeg.Point;

                        }

                        length += delta;

                    }

                }

            }

            pathFigure.IsFilled = false;

            return pathFigure;

        }

        /// <summary>

        /// draw arcs between p1 and p2

        /// </summary>

        /// <author>humkyung</author>

        /// <param name="p1"></param>

        /// <param name="p2"></param>

        /// <param name="reverse"></param>

        /// <returns></returns>

        public static PathFigure GenerateLineWithCloudOld(Point p1, Point p2, double arcLength_, bool reverse)

        {

            PathFigure pathFigure = new PathFigure();

            pathFigure.StartPoint = p1;

            double arcLength = arcLength_;

            /// draw arcs which has arcLength between p1 and p2 - 2012.06.21 added by humkyung 

            double dx = p2.X - p1.X;

            double dy = p2.Y - p1.Y;

            double l = MathSet.DistanceTo(p1, p2); /// distance between p1 and p2

            double theta = Math.Atan2(Math.Abs(dy), Math.Abs(dx)) * 180 / Math.PI;

            Point lastPt = new Point(p1.X, p1.Y);

            double count = l / arcLength;

            /// normalize

            dx /= l;

            dy /= l;

            Double j = 1;

            for (j = 1; j < (count - 1); j++)

            {

                ArcSegment arcSeg = new ArcSegment();

                arcSeg.Size = new Size(arcLength * CloudControl._CloudArcDepth, arcLength * CloudControl._CloudArcDepth);						/// x size and y size of arc

                arcSeg.Point = new Point(p1.X + j * dx * arcLength, p1.Y + j * dy * arcLength);	/// end point of arc

                lastPt = arcSeg.Point;  /// save last point

                //arcSeg.RotationAngle = theta + 90;

                if (true == reverse) arcSeg.SweepDirection = SweepDirection.Clockwise;

                pathFigure.Segments.Add(arcSeg);

            }

            /// draw arc between last point and end point

            if ((count > j) || (count > 0))

            {

                arcLength = MathSet.DistanceTo(lastPt, p2);

                ArcSegment arcSeg = new ArcSegment();

                arcSeg.Size = new Size(arcLength * CloudControl._CloudArcDepth, arcLength * CloudControl._CloudArcDepth);	/// x size and y size of arc

                arcSeg.Point = new Point(p2.X, p2.Y);/// end point of arc

                //arcSeg.RotationAngle = theta;

                if (true == reverse) arcSeg.SweepDirection = SweepDirection.Clockwise;

                pathFigure.Segments.Add(arcSeg);

            }

            pathFigure.IsFilled = true;

            return pathFigure;

        }

        /// <summary>

        /// close path if it's open

        /// </summary>

        /// <author>humkyung</author>

        /// <returns></returns>

        public int ClosePath()

        {

            if (this.PointSet.Count > 1)

            {

                double d = MathSet.DistanceTo(this.PointSet[0], this.PointSet[this.PointSet.Count - 1]);

                if (d > _toler)

                {

                    /// set reverse if area is greater 0 - 2012.07.04 added by humkyung

                    double area = MathSet.AreaOf(this.PointSet);

                    bool reverse = (area > 0);

                    /// up to here

                    int count = this.PointSet.Count;

                    if (isTransOn) // true라면 클라우드 컨트롤

                    {

                        ArcLength = ArcLength == 0 ? 10 : ArcLength;

                        PathFigure pathFigure = CloudControl.GenerateLineWithCloud(this.PointSet[count - 1], this.PointSet[0], this.ArcLength - 5, reverse);

                        if (this.Paint == PaintSet.Fill)

                        {

                            pathFigure.IsClosed = true;

                        }

                        _pathGeometry.Figures.Add(pathFigure);                        

                    }

                    else

                    {

                        PathFigure fm = new PathFigure();

                        fm.StartPoint = this.PointSet[count - 1];

                        //for (int i = 0; i < (count - 1); i++)

                        //{

                            _pathGeometry.Figures[_pathGeometry.Figures.Count - 1].Segments.Add(new LineSegment { Point = this.PointSet[0] });

                            _pathGeometry.Figures[_pathGeometry.Figures.Count - 1].Segments.Add(new LineSegment { Point = this.PointSet[1] });

                            //fm.Segments.Add(new LineSegment { Point = this.PointSet[0] });

                        //}

                    }                 

                }

            }

            return 0;

        }

        public void DrawingCloud()

        {

            AnotherSetCloud();

            if (!isChain)

            {

                //ClosePath();

            }

        }

        public void AnotherSetCloud()

        {

            this.StrokeColor = StrokeColor;

            this.LineSize = LineSize;

            this.SetCloud();

            //Generate();

            this.Width = this.Base_CloudPath.Width;

            this.Height = this.Base_CloudPath.Height;

        }

        public void Dispose()

        {

            //GC.Collect();

            ////GC.SuppressFinalize(this);

            this.Base_CloudPath = null;

            this.Base_CloudSubPath = null;

        }

        public event PropertyChangedEventHandler PropertyChanged;

        protected void OnPropertyChanged(string propName)

        {

            if (PropertyChanged != null)

                PropertyChanged(this, new PropertyChangedEventArgs(propName));

        }

        public override void UpdateControl()

        {

            var lastIndex = this.PointSet.Count - 1;

            //this.StartPoint = this.PointSet[0];

            //this.EndPoint = this.PointSet[lastIndex];

            CenterX = MathSet.getMiddlePoint(this.PointSet[0], this.PointSet[lastIndex]).X;

            CenterY = MathSet.getMiddlePoint(this.PointSet[0], this.PointSet[lastIndex]).Y;

        }

        public void ChangePaint(PaintSet state)

        {

            this.Paint = state;

            this.SetCloud();

        }

        /// <summary>

        /// call when mouse is moving while drawing control

        /// </summary>

        /// <param name="pt"></param>

        /// <param name="bAxisLocked"></param>

        public override void OnCreatingMouseMove(Point pt, bool bAxisLocked)

        {

            this.isTransOn = true;

            this.PointSet.RemoveAt(this.PointSet.Count - 1);

            Point tmp = pt;

            if (bAxisLocked)

            {

                CommentAngle = MathSet.returnAngle(this.StartPoint, ref tmp, bAxisLocked);

            }

            if (this.PointSet.Count > 2 && StartPoint == tmp)

            {

                this.IsCompleted = true;

                //var firstPoint = this.PointSet.First();

                //this.PointSet.Add(firstPoint);

                //this.ApplyOverViewData();

                this.SetCloud();

            }

            else

            {

                this.PointSet.Add(tmp);

                this.SetCloud();

            }

        }

        /// <summary>

        /// move control point has same location of given pt along given delta

        /// </summary>

        /// <author>humkyung</author>

        /// <date>2019.06.20</date>

        /// <param name="pt"></param>

        /// <param name="dx"></param>

        /// <param name="dy"></param>

        public override void OnMoveCtrlPoint(Point pt, double dx, double dy, bool bAxisLocked = false)

        {

            Point selected = MathSet.getNearPoint((this as IPath).PointSet, pt);

            selected.X += dx;

            selected.Y += dy;

            for (int i = 0; i < (this as IPath).PointSet.Count; i++)

            {

                if (pt.Equals((this as IPath).PointSet[i]))

                {

                    (this as IPath).PointSet[i] = selected;

                    break;

                }

            }

            this.UpdateControl();

            this.DrawingCloud();

        }

        /// <summary>

        /// return Cloud's area

        /// </summary>

        /// <author>humkyung</author>

        /// <date>2019.06.13</date>

        public override Rect ItemRect

        {

            get

            {

                double dMinX = double.MaxValue;

                double dMinY = double.MaxValue;

                double dMaxX = double.MinValue;

                double dMaxY = double.MinValue;

                foreach (Point pt in this.PointSet)

                {

                    dMinX = Math.Min(dMinX, pt.X);

                    dMinY = Math.Min(dMinY, pt.Y);

                    dMaxX = Math.Max(dMaxX, pt.X);

                    dMaxY = Math.Max(dMaxY, pt.Y);

                }

                return new Rect(new Point(dMinX, dMinY), new Point(dMaxX, dMaxY));

            }

        }

        /// <summary>

        /// Serialize this

        /// </summary>

        /// <param name="sUserId"></param>

        /// <returns></returns>

        public override string Serialize()

        {

            using (S_CloudControl ctrl = new S_CloudControl())

            {

                ctrl.TransformPoint = "0|0";

                ctrl.SizeSet = String.Format("{0}", this.LineSize);

                //ctrl.StrokeColor = "#FF000FFF";

                ctrl.StrokeColor = this.StrokeColor.Color.ToString();

                ctrl.Name = this.GetType().Name.ToString();

                ctrl.Toler = this.Toler;

                ctrl.PaintState = this.Paint;

                ctrl.Opac = this.Opacity;

                ctrl.UserID = this.UserID;

                ctrl.IsTrans = this.isTransOn;

                ctrl.IsChain = this.isChain;

                ctrl.PointSet = new List<Point>();

                ctrl.DashSize = this.DashSize;

                ctrl.StartPoint = this.StartPoint;

                ctrl.EndPoint = this.EndPoint;

                ctrl.ArcLength = this.ArcLength;

                foreach (var point in this.PointSet)

                {

                    ctrl.PointSet.Add(point);

                }

                //ctrl.CloudFill = this.Fill;

                ctrl.ArcLength = this.ArcLength;

                ///강인구 추가(2017.11.02)

                ///Memo 추가

                ctrl.Memo = this.Memo;

                ctrl.ZIndex = this.ZIndex;

                return "|DZ|" + JsonSerializerHelper.CompressString((ctrl.JsonSerialize()));

            }

        }

        /// <summary>

        /// create a cloudcontrol from given string

        /// </summary>

        /// <param name="str"></param>

        /// <returns></returns>

        public static CloudControl FromString(string str, SolidColorBrush brush, string sProjectNo)

        {

            CloudControl instance = null;

            using (S_CloudControl s = JsonSerializerHelper.JsonDeserialize<S_CloudControl>(str))

            {

                string[] data2 = s.SizeSet.Split(delimiterChars2, StringSplitOptions.RemoveEmptyEntries);

                instance = new CloudControl

                {

                    LineSize = Convert.ToDouble(data2.First()),

                    Toler = s.Toler,

                    PointSet = s.PointSet,

                    ArcLength = s.ArcLength,

                    Paint = s.PaintState,

                    Opacity = s.Opac,

                    StrokeColor = brush,

                    isTransOn = s.IsTrans,

                    isChain = s.IsChain,

                    DashSize = s.DashSize,

                    UserID = s.UserID,

                    StartPoint = s.StartPoint,

                    EndPoint = s.EndPoint,

                    Memo = s.Memo,

                    ZIndex = s.ZIndex

                    //Fill = s.CloudFill,

                };

            }

            return instance;

        }

        #region Method

        public override void ApplyOverViewData()

        {

            this.OverViewPathData = this.PathData;

        }

        #endregion

    }

}