MARKUS

            List<Point> point = new List<Point>();

            point.Add(rect.TopLeft);

            point.Add(rect.BottomLeft);

            point.Add(rect.BottomRight);

            point.Add(rect.TopRight);

            var calRect = MathSet.GetPointsToRectX(point);

            lineSize = lineSize * 72 / 96*0.5;

                DrawSet_Cloud.DrawCloud(point, lineSize, ArcLength, contentByte, new DoubleCollection(99999), color, (PaintStyle & ~PaintSet.Hatch), opac);

                PdfGState gs1 = new PdfGState();

                gs1.FillOpacity = 0.7f;

                gs1.StrokeOpacity = (float)opac;

                if ((PaintStyle & PaintSet.Highlight) == PaintSet.Highlight)

                {

                    contentByte.SetColorFill(BaseColor.YELLOW);

                }

                else

                    contentByte.SetColorFill(BaseColor.WHITE);

                contentByte.SetColorStroke(bs);

                contentByte.SetGState(gs1);

                contentByte.Rectangle((float)calRect.Left, (float)calRect.Bottom, (float)calRect.Width, (float)calRect.Height);

                System.Drawing.Drawing2D.Matrix mat2 = new System.Drawing.Drawing2D.Matrix();

                mat2.RotateAt((float)Angle * -1, new System.Drawing.PointF((float)sp.X, (float)sp.Y));

                contentByte.Transform(mat2);

                contentByte.Fill();

                contentByte.RestoreState();

                contentByte.SaveState();

            //string ARIALUNI_TFF = System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Fonts), "Arial Unicode MS.TTF");

            //string ARIALUNI_TFF = @"‪C:\Windows\Fonts\ARIALUNI.TTF";

            //string ARIALUNI_TFF = System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Fonts), fontFamilly + ".ttf");

            //Font itextFont = FontFactory.GetFont("Arial", (float)FontSize / (float)3.0, BaseColor.GRAY);

            //BaseFont bf = BaseFont.CreateFont("HYGoThic-Medium", "UniKS-UCS2-H", false); 

            //BaseFont bf = BaseFont.CreateFont("HYGoThic-Medium", "UniKS-UCS2-H", BaseFont.NOT_EMBEDDED);

            //itextFont.SetStyle(Font.UNDERLINE | Font.BOLDITALIC);

            //contentByte.SetWordSpacing((float)0);

            //contentByte.SetCharacterSpacing((float)-0.05);

            //contentByte.SetCharacterSpacing((float)0.05);

            //contentByte.SetFontAndSize(bf, (float)FontSize / (float)3.0);

            //contentByte.BeginText();

            //Point rx = new Point(0, 0);

            //Point ry = new Point(0, 0);

            //if (PaintStyle == MarkupEditToolKit.Common.PaintSet.Hatch)

            //{

            //    contentByte.MoveText((float)sp.X + (float)1.5, (float)sp.Y - (float)font.Height / (float)2.5 - (float)font.Height / (float)2.5);

            //}

            //else

            //{

            //    contentByte.MoveText((float)sp.X, (float)sp.Y - (float)font.Height / (float)2.25 - (float)font.Height / (float)2.25);

            //}

            //contentByte.SetTextMatrix(300, 300);

            //contentByte.ShowText(text);

            //contentByte.EndText();

            //ct.Canvas.Transform(new System.Drawing.Drawing2D.Matrix(0,1,-1,0,100,200));

            //Matrix mat = new Matrix();

            //mat.RotateAt(90,

            //ct.Canvas.Transform(mat);

            //text = text.Replace("\r", "\r ");

            //var ts = new Rectangle(calRect.Left + (float)1.5, calRect.Bottom , calRect.Right, calRect.Top+ (float)1.5);

            var ts = new Rectangle(calRect.Left + (float)1.5, calRect.Bottom, calRect.Right, calRect.Top + (float)1.5);

            ct.SetSimpleColumn(ts);

            //lineSize = 1;

            var calRect = MathSet.GetPointsToRectX(points);

            //Font itextFont = FontFactory.GetFont("Arial", (float)FontSize / (float)3.0, BaseColor.GRAY);

            //BaseFont bf = BaseFont.CreateFont("HYGoThic-Medium", "UniKS-UCS2-H", false); 

            //BaseFont bf = BaseFont.CreateFont("HYGoThic-Medium", "UniKS-UCS2-H", BaseFont.NOT_EMBEDDED);

            //itextFont.SetStyle(Font.UNDERLINE | Font.BOLDITALIC);

            //contentByte.SetWordSpacing((float)0);

            //contentByte.SetCharacterSpacing((float)-0.05);

            //contentByte.SetCharacterSpacing((float)0.05);

            //contentByte.SetFontAndSize(bf, (float)FontSize / (float)3.0);

            //contentByte.BeginText();

            //Point rx = new Point(0, 0);

            //Point ry = new Point(0, 0);

            //if (PaintStyle == MarkupEditToolKit.Common.PaintSet.Hatch)

            //{

            //    contentByte.MoveText((float)sp.X + (float)1.5, (float)sp.Y - (float)font.Height / (float)2.5 - (float)font.Height / (float)2.5);

            //}

            //else

            //{

            //    contentByte.MoveText((float)sp.X, (float)sp.Y - (float)font.Height / (float)2.25 - (float)font.Height / (float)2.25);

            //}

            //contentByte.SetTextMatrix(300, 300);

            //contentByte.ShowText(text);

            //contentByte.EndText();

            //text = text.Replace("\r", "\r ");

                var ts = new Rectangle(calRect.Left + (float)1.5, calRect.Bottom, calRect.Right, calRect.Top + (float)1.5);

                ct.SetSimpleColumn(ts);

                var ts = new Rectangle(calRect.Left + (float)1.5, calRect.Bottom, calRect.Right, calRect.Top + (float)1.5);

                ct.SetSimpleColumn(ts);

                var ts = new Rectangle(calRect.Left + (float)1.5, calRect.Bottom, calRect.Right, calRect.Top + (float)1.5);

                ct.SetSimpleColumn(ts);

        public string replaceXY(string text)

        {

            return text.Replace(@"_x", @"X").Replace(@"_y", @"Y");

        }

                                                string Text = " " + replaceXY(control.Text);

                                                    Text = replaceXY(control.ArrowText);

                                                    Text = " " + replaceXY(control.ArrowText);

            //pathGeometry = new PathGeometry();

                //new Point(0, 0),

                //new Point(0, 0 + BoxHeight + 2),

                //new Point(0 + BoxWidth + 4, 0 + BoxHeight + 2),

                //new Point(0 + BoxWidth + 4 ,0),

                //new Point(0, 0)

                new Point(0, 0)

                                //new Point(0, 0),

                                //new Point(0, 0 + BoxHeight + 2),

                                //new Point(0 + BoxWidth + 4, 0 + BoxHeight + 2),

                                //new Point(0 + BoxWidth + 4 ,0),

                                //new Point(0, 0)

                                new Point(0, 0)

            //this.StartPoint;

            LineSegment lineSegment0 = new LineSegment();

            lineSegment0.Point = pData[0];

            pathFigure.Segments.Add(lineSegment0);

            LineSegment lineSegment1 = new LineSegment();

            lineSegment1.Point = pData[1];

            pathFigure.Segments.Add(lineSegment1);

            LineSegment lineSegment2 = new LineSegment();

            lineSegment2.Point = pData[2];

            pathFigure.Segments.Add(lineSegment2);

            LineSegment lineSegment3 = new LineSegment();

            lineSegment3.Point = pData[3];

            pathFigure.Segments.Add(lineSegment3);

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

                PathFigure pathFigure = GenerateLineWithCloud(pData[i], pData[i + 1], 20, reverse);

            //    PathFigure pathFigur2= new PathFigure();

            //pathFigur2.StartPoint = pData[0];

            //    LineSegment lineSegment0 = new LineSegment();

            //    lineSegment0.Point = pData[0];

            //pathFigur2.Segments.Add(lineSegment0);

            //    LineSegment lineSegment1 = new LineSegment();

            //    lineSegment1.Point = pData[1];

            //pathFigur2.Segments.Add(lineSegment1);

            //    LineSegment lineSegment2 = new LineSegment();

            //    lineSegment2.Point = pData[2];

            //pathFigur2.Segments.Add(lineSegment2);

            //    LineSegment lineSegment3 = new LineSegment();

            //    lineSegment3.Point = pData[3];

            //pathFigur2.Segments.Add(lineSegment3);

            //pathFigur2.IsClosed = true;

            //pathFigur2.IsFilled = true;

            //_pathGeometry.Figures.Add(pathFigur2);

            LineSegment lineSegment0 = new LineSegment();

            lineSegment0.Point = pData[0];

            pathFigur2.Segments.Add(lineSegment0);

            LineSegment lineSegment1 = new LineSegment();

            lineSegment1.Point = pData[1];

            pathFigur2.Segments.Add(lineSegment1);

            LineSegment lineSegment2 = new LineSegment();

            lineSegment2.Point = pData[2];

            pathFigur2.Segments.Add(lineSegment2);

            LineSegment lineSegment3 = new LineSegment();

            lineSegment3.Point = pData[3];

            pathFigur2.Segments.Add(lineSegment3);

<UserControl x:Class="MarkupToPDF.Adorner.AdornerControl"

             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 

             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 

             mc:Ignorable="d" 

             d:DesignHeight="300" d:DesignWidth="300">

    <Grid>

    </Grid>

</UserControl>

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

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;

namespace MarkupToPDF.Adorner

{

    /// <summary>

    /// Interaction logic for AdornerControl.xaml

    /// </summary>

    public partial class AdornerControl : UserControl

    {

        public AdornerControl()

        {

            InitializeComponent();

        }

    }

}

using MarkupToPDF.Controls.Common;

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows;

using System.Windows.Controls.Primitives;

namespace MarkupToPDF.Adorner.Classes

{

    public class AdornerMember

    {

        public UIElement DrawingData { get; set; }

        public double DrawingAngle { get; set; }

        public List<Thumb> Thumbs { get; set; }

        public ControlType DrawingType { get; set; }

    }

}

<?xml version="1.0" encoding="utf-8"?>

<configuration>

  <configSections>

    <!-- For more information on Entity Framework configuration, visit http://go.microsoft.com/fwlink/?LinkID=237468 -->

    <section name="entityFramework" type="System.Data.Entity.Internal.ConfigFile.EntityFrameworkSection, EntityFramework, Version=5.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" requirePermission="false"/>

  </configSections>

  <connectionStrings>

    <add name="Entity" connectionString="metadata=res://*/Database.Entity.csdl|res://*/Database.Entity.ssdl|res://*/Database.Entity.msl;provider=System.Data.SqlClient;provider connection string=&quot;data source=honeyhead.net,7777;initial catalog=DeepView;user id=honeyhead;password=dof1073#;MultipleActiveResultSets=True;App=EntityFramework&quot;" providerName="System.Data.EntityClient"/>

    <add name="Kcom_entity" connectionString="metadata=res://*/Database.Kcom_Entity.csdl|res://*/Database.Kcom_Entity.ssdl|res://*/Database.Kcom_Entity.msl;provider=System.Data.SqlClient;provider connection string=&quot;data source=honeyhead.net,7777;initial catalog=DeepView;user id=honeyhead;password=dof1073#;MultipleActiveResultSets=True;App=EntityFramework&quot;" providerName="System.Data.EntityClient"/>

    <add name="Kcom_Entity" connectionString="metadata=res://*/Database.Kcom_Entity.csdl|res://*/Database.Kcom_Entity.ssdl|res://*/Database.Kcom_Entity.msl;provider=System.Data.SqlClient;provider connection string=&quot;data source=honeyhead.net,7777;initial catalog=DeepView;user id=honeyhead;password=dof1073#;multipleactiveresultsets=True;application name=EntityFramework&quot;" providerName="System.Data.EntityClient"/>

  </connectionStrings>

  <entityFramework>

    <defaultConnectionFactory type="System.Data.Entity.Infrastructure.SqlConnectionFactory, EntityFramework"/>

  </entityFramework>

<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0"/></startup></configuration>

//using System;

//using System.Collections.Generic;

//using System.ComponentModel;

//using System.Linq;

//using System.Text;

//using System.Threading.Tasks;

//using System.Windows;

//using System.Windows.Controls;

//using System.Windows.Shapes;

//using System.Windows.Media;

//namespace MarkupToPDF.Controls.Common

//{

//    public class BaseShape : Control, IDisposable, INotifyPropertyChanged, IMarkupCommonData

//    {

//        public Path Base_BasePath { get; set; }

//        #region Property

//        public Point StartPoint

//        {

//            get

//            {

//                return (Point)GetValue(StartPointProperty);

//            }

//            set

//            {

//                SetValue(StartPointProperty, value);

//                OnPropertyChanged("StartPoint");

//            }

//        }

//        public Point EndPoint

//        {

//            get

//            {

//                return (Point)GetValue(EndPointProperty);

//            }

//            set

//            {

//                SetValue(EndPointProperty, value);

//                OnPropertyChanged("EndPoint");

//            }

//        }

//        public bool IsSelected

//        {

//            get

//            {

//                return (bool)GetValue(IsSelectedProperty);

//            }

//            set

//            {

//                SetValue(IsSelectedProperty, value);

//                OnPropertyChanged("IsSelected");

//            }

//        }

//        public double CanvasX

//        {

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

//            set

//            {

//                if (this.CanvasX != value)

//                {

//                    SetValue(CanvasXProperty, value);

//                    OnPropertyChanged("CanvasX");

//                }

//            }

//        }

//        public double CanvasY

//        {

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

//            set

//            {

//                if (this.CanvasY != value)

//                {

//                    SetValue(CanvasYProperty, value);

//                    OnPropertyChanged("CanvasY");

//                }

//            }

//        }

//        public ControlType ControlType

//        {

//            set

//            {

//                SetValue(ControlTypeProperty, value);

//                OnPropertyChanged("ControlType");

//            }

//            get

//            {

//                return (ControlType)GetValue(ControlTypeProperty);

//            }

//        }

//        #endregion Property

//        #region Dependency Property

//        public static readonly DependencyProperty IsSelectedProperty =

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

//        public static readonly DependencyProperty CanvasXProperty = DependencyProperty.Register(

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

//        public static readonly DependencyProperty CanvasYProperty = DependencyProperty.Register(

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

//        public static readonly DependencyProperty StartPointProperty = DependencyProperty.Register(

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

//        public static readonly DependencyProperty SetPointProperty = DependencyProperty.Register(

//        "SetPoint", typeof(Point), typeof(BaseShape), new PropertyMetadata(new Point(0, 0), PointValueChanged));

//        public static readonly DependencyProperty OriginPointProperty = DependencyProperty.Register(

//        "OriginPoint", typeof(Point), typeof(BaseShape), new PropertyMetadata(new Point(0, 0), PointValueChanged));

//        public static readonly DependencyProperty EndPointProperty = DependencyProperty.Register(

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

//        public static readonly DependencyProperty PointSetProperty = DependencyProperty.Register(

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

//        public static readonly DependencyProperty StrokeColorProperty = DependencyProperty.Register(

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

//        public static readonly DependencyProperty ControlTypeProperty =

//                DependencyProperty.Register("ControlType", typeof(ControlType), typeof(BaseShape), new FrameworkPropertyMetadata(ControlType.Rectangle));

//        #endregion  Dependency Property

//        #region Dependency PropertyChanged

//        public static void OnSetCansvasChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

//        {

//            var instance = (BaseShape)sender;

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

//            {

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

//            }

//        }

//        public static void IsSelectedChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

//        {

//            var instance = (BaseShape)sender;

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

//            {

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

//                if (instance.IsSelected)

//                {

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

//                }

//                else

//                {

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

//                }

//            }

//        }

//        public static void PointValueChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)

//        {

//            var instance = (BaseShape)sender;

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

//            {

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

//                //instance.SetRectPath(instance);

//            }

//        }

//        #endregion Dependency PropertyChanged

//        #region Internal Method

//        private void OnPropertyChanged(string name)

//        {

//            if (PropertyChanged != null)

//            {

//                PropertyChanged(this, new PropertyChangedEventArgs(name));

//            }

//        }

//        public event PropertyChangedEventHandler PropertyChanged;

//        public void Dispose()

//        {

//            GC.Collect();

//            GC.SuppressFinalize(this);

//        }

//        #endregion Internal Method

//    }

//}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace MarkupToPDF.Controls.Common

{

    public enum ControlType

    {

        None,

        #region Line

        SingleLine,

        ArrowLine,

        CancelLine,

        TwinLine,

        DimLine,

        ChainLine,

        ArcLine,

        ArcArrow,

        ArrowMultiLine,

        #endregion

        #region Shape

        Rectangle, 

        RectCloud,

        Circle,

        Triangle,

        #endregion

        #region Text

        TextControl,

        TextBorder,

        TextCloud,

        #endregion

        #region ArrowText

        ArrowTextControl,

        ArrowTransTextControl,

        ArrowTextBorderControl,

        ArrowTransTextBorderControl,

        ArrowTextCloudControl,

        ArrowTransTextCloudControl,

        #endregion

        #region Polygone

        PolygonControl,

        PolygonCloud,

        #endregion

        #region Pen

        PenControl,

        #endregion

        #region Etc

        ImgControl,

        Date

        #endregion

    }

}

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;

namespace MarkupToPDF.Controls.Common

{

    public static class HatchMake

    {

        public static Brush CreateHatchBrush(SolidColorBrush color)

        {

            Color c = (color as SolidColorBrush).Color;

            LinearGradientBrush brush = new LinearGradientBrush();

            brush.MappingMode = BrushMappingMode.Absolute;

            brush.SpreadMethod = GradientSpreadMethod.Repeat;

            brush.StartPoint = new Point(0, 0);

            brush.EndPoint = new Point(8.0, 8.0);

            GradientStop gs = new GradientStop();

            gs.Color = c;

            brush.GradientStops.Add(gs);

            gs = new GradientStop();

            gs.Color = c;

            gs.Offset = 0.3;

            brush.GradientStops.Add(gs);

            gs = new GradientStop();

            gs.Color = Colors.Transparent;

            gs.Offset = 0.3;

            brush.GradientStops.Add(gs);

            gs = new GradientStop();

            gs.Color = Colors.Transparent;

            gs.Offset = 1;

            brush.GradientStops.Add(gs);

            return brush;

        }

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows;

using System.Windows.Media;

namespace MarkupToPDF.Controls.Common

{

    public interface IMarkupCommonData

    {

        bool IsSelected { get; set; }

        Point StartPoint { get; set; }

        Point EndPoint { get; set; }

        ControlType ControlType { get; set; }

        //MarkupWindow MarkupWindow { get; set; }

    }

    public interface IMarkupControlData : IMarkupCommonData

    {

        double CanvasX { get; set; }

        double CanvasY { get; set; }

    }

    public interface ITextControl : IPath

    {

        FontFamily TextFamily { get; set; }

        bool IsEditingMode { get; set; }

    }

    public interface IShapeControl : IPath

    {

        double Angle { get; set; }

        PaintSet Paint { get; set; }

        //void ChangePaint(PaintSet state);

    }

    public enum MarkupWindow

    {

        Main,

        OverView

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows;

using System.Windows.Media;

namespace MarkupToPDF.Controls.Common

{

    public interface IPath : IMarkupCommonData

    {

        List<Point> PointSet { get; set; }

        Double LineSize { get; set; }

        Geometry PathData { get; set; }

        double Width { get; set; }

        double Height { get; set; }

        string UserID { get; set; }

        void updateControl();

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows;

using System.Windows.Ink;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Shapes;

namespace MarkupToPDF.Controls.Common

{

    public class InkToPath

    {

        public double[,] StrokeGetPoints(Stroke oStroke)

        {

            int iRow = -1;

            System.Windows.Input.StylusPointCollection colStylusPoints =

                                                  oStroke.StylusPoints;

            double[,] AllPoints = new double[colStylusPoints.Count, 2];

            foreach (StylusPoint oPoint in colStylusPoints)

            {

                iRow += 1;

                AllPoints[iRow, 0] = oPoint.X;

                AllPoints[iRow, 1] = oPoint.Y;

            }

            return AllPoints;

        }

        public List<Point> StrokeGetPointsPlus(Stroke oStroke)

        {

            System.Windows.Input.StylusPointCollection colStylusPoints =

                                      oStroke.StylusPoints;

            List<Point> instance = new List<Point>();

            foreach (StylusPoint oPoint in colStylusPoints)

            {

                instance.Add(new Point(oPoint.X, oPoint.Y));

            }

            return instance;

        }

        public StrokeCollection PointGetStroke(List<Point> lstPoint, double lineSize)

        {

            //foreach (var T in _InkBoard.Strokes[i].StylusPoints) 참고

            StrokeCollection strokeSet = new StrokeCollection();

#if SILVERLIGHT

                Stroke instance = new Stroke(); 

#endif

#if !SILVERLIGHT

            Stroke instance = new Stroke(null);

#endif

            instance.DrawingAttributes.Color = Colors.Red;

            instance.DrawingAttributes.Width = lineSize;

            instance.DrawingAttributes.Height = lineSize;

            foreach (var data in lstPoint)

            {

                instance.StylusPoints.Add(new StylusPoint { X = data.X, Y = data.Y, PressureFactor = 0.5F });

                strokeSet.Add(instance);

            }

            return strokeSet;

        }

        public Path StrokeToPath(Stroke oStroke)

        {

            PathFigure myPathFigure = null;

            LineSegment myLineSegment = null;

            PathFigureCollection myPathFigureCollection =

                new PathFigureCollection();

            PathSegmentCollection myPathSegmentCollection =

                new PathSegmentCollection();

            if (oStroke == null) return null;

            // Number of points.

            int n = oStroke.StylusPoints.Count;

            if (n == 0) return null;

            // Start point is first point from sytluspoints collection (M, item 0).

            myPathFigure = new PathFigure();

            myPathFigure.StartPoint =

                new Point(oStroke.StylusPoints[0].X, oStroke.StylusPoints[0].Y);

            myPathFigureCollection.Add(myPathFigure);

            // Make small line segment L if there is only one point in the Stroke.

            // Data with only M is not shown (workaround).

            if (n == 1)

            {

                myLineSegment = new LineSegment();

                myLineSegment.Point =

                    new Point(oStroke.StylusPoints[0].X + 1,

                              oStroke.StylusPoints[0].Y + 1);

                myPathSegmentCollection.Add(myLineSegment);

            }

            // The other points are line segments (L, items 1..n-1).

            for (int i = 1; i < n; i++)

            {

                myLineSegment = new LineSegment();

                myLineSegment.Point =

                    new Point(oStroke.StylusPoints[i].X,

                              oStroke.StylusPoints[i].Y);

                myPathSegmentCollection.Add(myLineSegment);

            }

            myPathFigure.Segments = myPathSegmentCollection;

            PathGeometry myPathGeometry = new PathGeometry();

            myPathGeometry.Figures = myPathFigureCollection;

            System.Windows.Shapes.Path oPath = new System.Windows.Shapes.Path();

            // Add the data to the Path.

            oPath.Data = myPathGeometry;

            return oPath;

        }

    }

}

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;

namespace MarkupToPDF.Controls.Common

{

    public interface INormal

    {

        List<Point> PointSet { get; set; }

        double Width { get; set; }

        double Height { get; set; }

        Point StartPoint { get; set; }

        Point EndPoint { get; set; }

        void updateControl();

    }

    public interface ICloudControl : IPath

    {

        double Toler { get; set; }

        double ArcLength { get; set; }

        void DrawingCloud();

    }

    public interface IDashControl : IPath

    {

        DoubleCollection DashSize { get; set; }

    }

    public interface IViewBox : IPath

    {

        double Angle { get; set; }

    }

    public interface ICircleControl : IShapeControl

    {

        void SetCenterXY();

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace MarkupToPDF.Controls.Common

{

    class MarkupToPDF

    {

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows;

namespace MarkupToPDF.Controls.Common

{

    public class MathSet

    {

        const double Rad2Deg = 180.0 / Math.PI;

        const double Deg2Rad = Math.PI / 180.0;

        const double UnitAngle = 15;

        public static List<double> angleSet = new List<double>();

        public static double getMultipleAngle(double increase, double YourAngle)

        {

            angleSet.Clear();

            for (double i = 0; i <= 360; i += increase)

            {

                angleSet.Add(i);

            }

            if (YourAngle < 0)

            {

                YourAngle += 360;

            }

            double TargetData = YourAngle;

            double NearAngle = 0;

            double k = 0;

            foreach (var item in angleSet)

            {

                double j = 0;

                j = TargetData - item;

                j = j < 0 ? -j : j;

                if (j < k)

                {

                    NearAngle = item;

                }

                k = j;

            }

            return NearAngle;

        }

        public static Point getNearPoint(List<Point> pointList, Point setPoint)

        {

            Point nearPoint = pointList.Select

            (n => new

                {

                    n, 

                    distance = Math.Sqrt

                    (

                        Math.Pow(

                                    (n.X - setPoint.X),2

                                )

                        + System.Math.Pow

                        (

                            (n.Y - setPoint.Y), 2

                        )

                    )

                }

            ).OrderBy(p => p.distance).First().n;

            return nearPoint;

        }

        public class ClipLine

        {

            public static int DONT_INTERSECT = -0x01;

            public static int COLLINEAR = 0x00;

            public static int INTERSECT = 0x01;

            public static double TOLER = 0.0;

            public Point _start;

            public Point _end;

            public ClipLine(Point start, Point end)

            {

                _start = start;

                _end = end;

            }

            public bool IsLeftSide(Point pt)

            {

                double dx1 = _end.X - _start.X;

                double dy1 = _end.Y - _start.Y;

                double dx2 = pt.X - _start.X;

                double dy2 = pt.Y - _start.Y;

                return ((dx1 * dy2 - dy1 * dx2) > 0.0);

            }

            public bool IsRightSide(Point pt)

            {

                double dx1 = _end.X - _start.X;

                double dy1 = _end.Y - _start.Y;

                double dx2 = pt.X - _start.X;

                double dy2 = pt.Y - _start.Y;

                return ((dx1 * dy2 - dy1 * dx2) < 0.0);

            }

            /// <summary>

            /// get intersection point betwwen this and line2d

            /// </summary>

            /// <author>humkyung</author>

            /// <date>2012.08.30</date>

            /// <param name="intsec"></param>

            /// <param name="line2d"></param>

            /// <returns></returns>

            public int IntersectWith(ref Point intsec, ClipLine line2d)

            {

                double Ax = 0.0, Bx = 0.0, Cx = 0.0, Ay = 0.0, By = 0.0, Cy = 0.0, d = 0.0, e = 0.0, f = 0.0;

                double x1lo = 0.0, x1hi = 0.0, y1lo = 0.0, y1hi = 0.0;

                Ax = _end.X - _start.X;

                Bx = line2d._start.X - line2d._end.X;

                // X bound box test

                if (Ax < 0.0)

                {

                    x1lo = _end.X;

                    x1hi = _start.X;

                }

                else

                {

                    x1hi = _end.X;

                    x1lo = _start.X;

                }

                if (Bx > 0.0)

                {

                    if ((x1hi < line2d._end.X) || (line2d._start.X < x1lo)) return ClipLine.DONT_INTERSECT;

                }

                else

                {

                    if ((x1hi < line2d._start.X) || (line2d._end.X < x1lo)) return ClipLine.DONT_INTERSECT;

                }

                Ay = _end.Y - _start.Y;

                By = line2d._start.Y - line2d._end.Y;

                /* Y bound box test*/

                if (Ay < 0)

                {

                    y1lo = _end.Y;

                    y1hi = _start.Y;

                }

                else

                {

                    y1hi = _end.Y;

                    y1lo = _start.Y;

                }

                if (By > 0)

                {

                    if ((y1hi < line2d._end.Y) || (line2d._start.Y < y1lo)) return ClipLine.DONT_INTERSECT;

                }

                else

                {

                    if ((y1hi < line2d._start.Y) || (line2d._end.Y < y1lo)) return ClipLine.DONT_INTERSECT;

                }

                Cx = _start.X - line2d._start.X;

                Cy = _start.Y - line2d._start.Y;

                f = Ay * Bx - Ax * By;	/* both denominator*/

                /// lines are collinear.

                if (0.0 == f) return ClipLine.COLLINEAR;

                d = By * Cx - Bx * Cy;	/* alpha numerator*/

                if (f > 0.0)

                {		/* alpha tests*/

                    if ((d < (0 + ClipLine.TOLER)) || (d > (f - ClipLine.TOLER))) return ClipLine.DONT_INTERSECT;

                }

                else

                {

                    if ((d > (0 - ClipLine.TOLER)) || (d < (f + ClipLine.TOLER))) return ClipLine.DONT_INTERSECT;

                }

                e = Ax * Cy - Ay * Cx;	/* beta numerator*/

                if (f > 0.0)

                {		/* beta tests*/

                    if ((e < (0 + ClipLine.TOLER)) || (e > (f - ClipLine.TOLER))) return ClipLine.DONT_INTERSECT;

                }

                else

                {

                    if ((e > (0 - ClipLine.TOLER)) || (e < (f + ClipLine.TOLER))) return ClipLine.DONT_INTERSECT;

                }

                /*compute intersection coordinates*/

                double alpha = d / f;

                if (_start.X == _end.X)

                    intsec.X = _start.X;

                else intsec.X = _start.X + alpha * Ax;

                if (_start.Y == _end.Y)

                    intsec.Y = _start.Y;

                else intsec.Y = _start.Y + alpha * Ay;

                return ClipLine.INTERSECT;

            }

        }

        public class ClipRect

        {

            public Point center;

            public double width, height, angle;	/// angle is degree

            public int IntersectWith(ref Point intsec, ClipLine line2d)

            {

                double radians = Math.PI * angle / 180.0;

                double cs = Math.Cos(radians), sn = Math.Sin(radians);

                Point[] corner = new Point[4];

                corner[0].X = center.X - width * 0.5;

                corner[0].Y = center.Y - height * 0.5;

                corner[1] = corner[0];

                corner[1].X += width;

                corner[2] = corner[1];

                corner[2].Y += height;

                corner[3] = corner[2];

                corner[3].X -= width;

                /// rotate 4 corners about angle

                for (int i = 0; i < corner.Length; ++i)

                {

                    double ptx = corner[i].X - center.X;

                    double pty = corner[i].Y - center.Y;

                    corner[i].X = center.X + ((cs * ptx) - (sn * pty));

                    corner[i].Y = center.Y + ((sn * ptx) + (cs * pty));

                }

                for (int i = 0; i < corner.Length; ++i)

                {

                    int si = i % corner.Length, ei = (i + 1) % corner.Length;

                    if (ClipLine.INTERSECT == line2d.IntersectWith(ref intsec, new ClipLine(corner[si], corner[ei])))

                    {

                        return ClipLine.INTERSECT;

                    }

                }

                return ClipLine.DONT_INTERSECT;

            }

        }

        public static double AngleMethod(Point StartPoint, Point EndPoint)

        {

            return Math.Abs(Math.Atan2(EndPoint.X - StartPoint.X, StartPoint.Y - EndPoint.Y) * Rad2Deg);

        }

        public static double DegreesToRadians(double angle)

        {

            return ((angle * Math.PI) / 180f);

        }

        //public static double AngleMethod(double px1, double py1, double px2, double py2)

        //{

        //    return Math.Abs(Math.Atan2(px2 - px1, py1 - py2) * Rad2Deg);

        //}

        public static double DistanceTo(Point p1, Point p2)

        {

            double dx = p2.X - p1.X;

            double dy = p2.Y - p1.Y;

            return Math.Sqrt(dx * dx + dy * dy);

        }

        public static Point getMiddlePoint(Point p1, Point p2)

        {

            return new Point { X = (p1.X + p2.X) / 2, Y = (p1.Y + p2.Y) / 2 };

        }

        /// <summary>

        /// return area of polygon

        /// </summary>

        /// <author>humkyung</author>

        /// <date>2012.07.04</date>

        /// <param name="points"></param>

        /// <returns></returns>

        public static double AreaOf(List<Point> points)

        {

            double res = 0;

            int p = 0, q = 0;

            for (p = points.Count - 1, q = 0; q < points.Count; p = q++)

            {

                res += points[p].X * points[q].Y - points[p].Y * points[q].X;

            }

            return res;

        }

        /// <summary>

        /// return normal vector from p1 to p2

        /// </summary>

        /// <author>humkyung</author>

        /// <date>2012.07.19</date>

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

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

        /// <returns></returns>

        public static Point GetNormVectorBetween(Point p1, Point p2)

        {

            Point res = new Point();

            double d = MathSet.DistanceTo(p1, p2);

            if (d > 0)

            {

                res.X = (p2.X - p1.X) / d;

                res.Y = (p2.Y - p1.Y) / d;

            }