HYTOS

      <setting name="TcpServerPort" serializeAs="String">

        <value>3030</value>

      </setting>

using devDept.Eyeshot;

using System;

using System.Collections.Generic;

using System.Linq;

using System.Net;

using System.Net.Sockets;

using System.Text;

using System.Threading;

using System.Threading.Tasks;

using Telerik.WinControls;

namespace ID2.Manager.Classes

{

    public class TcpServer

    {

        private static readonly Lazy<TcpServer> lazy = new Lazy<TcpServer>(() => new TcpServer());

        public static TcpServer Instance

        {

            get { return lazy.Value; }

        }

        private readonly TcpListener tcp_Listener;  // TCP 통신 Listener 

        private Thread listenThread;                // Listener Thread 객체

        List<TcpClient> connectedClients = new List<TcpClient>();

        public delegate void ZoomEvent(string DwgName, double x, double y, double sizex, double sizey);

        public ZoomEvent OnZoomEvent;

        private TcpServer()

        {

            this.tcp_Listener = new TcpListener(IPAddress.Any, Properties.Settings.Default.TcpServerPort);                                   // TCP Listener Thread 정의

            this.listenThread = new Thread(new ThreadStart(ListenerThread)) { IsBackground = true };    // Listen Thread 생성(폼 종료시 쓰레드를 종료하기 위해 IsBackGround 속성을 true로 설정

            this.listenThread.Start();                                                                  // Thread 시작.

        }

        public void Close()

        {

            this.listenThread.Abort();

            foreach (TcpClient client in connectedClients)

            {

                client.Close();

                client.Dispose();

            }

            connectedClients.Clear();

            tcp_Listener.Stop();

        }

        /// <summary>

        /// // Listener Thread 정의

        /// </summary>

        private void ListenerThread()

        {

            try

            {

                tcp_Listener.Start(); // tcpListener 시작.

                while (true)

                {

                    TcpClient client = this.tcp_Listener.AcceptTcpClient();  /// 클라이언트 접속

                    connectedClients.Add(client);

                    {

                        Thread startClientThread = new Thread(new ParameterizedThreadStart(HandleClientComm)); // Client로 부터 접속

                        startClientThread.Start(client); // 시작.

                    }

                }

            }

            catch (Exception ex)

            {

                Console.WriteLine(ex.ToString());

            }

        }

        /// <summary>

        /// 클라이언트 요청 처리

        /// </summary>

        /// <param name="client"></param>

        private void HandleClientComm(object client)

        {

            try

            {

                TcpClient tcpClient = client as TcpClient;  // tcp Client 생성

                if (tcpClient == null) return;

                NetworkStream clientStream = tcpClient.GetStream();

                while (tcpClient.Connected)  // 클라이언트가 연결되어 있는 동안

                {

                    var reader = new System.IO.StreamReader(clientStream);  // 읽기 스트림 연결

                    string data = reader.ReadLine();

                    if (!string.IsNullOrEmpty(data))

                    {

                        var tokens = data.Split(',');

                        string UID = tokens[0];

                        double x = Convert.ToDouble(tokens[1]);

                        double y = Convert.ToDouble(tokens[2]);

                        double sizex = Convert.ToDouble(tokens[3]);

                        double sizey = Convert.ToDouble(tokens[4]);

                        string DwgName = tokens[5];

                        if (OnZoomEvent != null) OnZoomEvent(DwgName, x, y, sizex, sizey);

                    }

                }

            }

            catch (Exception ex)

            {

                Console.WriteLine(ex.ToString());

            }

        }

    }

}

        /// AutoCAD P&ID 파일을 화면에 표시한다.

        private void ShowAutoCADFile(string FilePath, Design design, bool clear = true)

            if (clear) design.Clear();

            var AddEntities = new List<Entity>();

            if (System.IO.File.Exists(FilePath))

            {

                try

                    #region 다른 프로세스에서 파일을 열고 있는 경우 처리

                    using (var fs = File.Open(FilePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))

                    #endregion

                    {

                        devDept.Eyeshot.Translators.ReadAutodesk ra = new devDept.Eyeshot.Translators.ReadAutodesk(fs);

                        ra.DoWork();

                        var min = ra.Min;

                        if (!ra.Layers.Contains(Verification.AutoCADLayer)) ra.Layers.Add(Verification.AutoCADLayer, Verification.AutoCADColor);

                        if (!ra.Layers.Contains(Verification.AutoCADDiffLayer)) ra.Layers.Add(Verification.AutoCADDiffLayer, Verification.DiffColor);

                        if (!ra.Layers.Contains(Verification.AutoCADExceptLayer)) ra.Layers.Add(Verification.AutoCADExceptLayer, Verification.AutoCADColor);

                        foreach (var ent in ra.Entities)

                            /// 도면을 원점으로 맞춘다.

                            if (min.X != 0 && min.Y != 0) ent.Translate(-min.X, -min.Y);

                            if (ent is BlockReference blkref)

                            {

                                AddEntities.AddRange(ExplodeBlockReference(ra.Blocks, blkref, Verification.AutoCADLayer, Verification.AutoCADColor));

                        ra.AddToScene(design);

                        (design as MyModel).FilePath = FilePath;

                }

                catch (Exception ex)

                {

                    RadMessageBox.Show(ex.Message, Application.ProductName, MessageBoxButtons.OK, RadMessageIcon.Error);

                    return;

                }

                #region LinearPath를 Line으로 분할한다.

                design.Entities.ForEach(x =>

                {

                    if (x is LinearPath lp)

                        #region 정점 수가 2이고 LineWeight이 0 초과이고 길이가 ArrowMaxLength보다 작을때 화살표를 그려준다.

                        if (lp.Vertices.Count() == 2 && lp.LineWeight > 0 && lp.Length() < Forms.ExceptLayer.ArrowMaxLength)

                            double weight = lp.LineWeight;

                            var dir = new devDept.Geometry.Vector3D(lp.Vertices[0], lp.Vertices[1]);

                            dir.Normalize();

                            var cross = devDept.Geometry.Vector3D.Cross(devDept.Geometry.Vector3D.AxisZ, dir);

                            var pts = new devDept.Geometry.Point3D[]

                            };

                            var hatch = new Hatch("SOLID", new List<ICurve>() { new LinearPath(pts) });

                            AddEntities.Add(hatch);

                        }

                        #endregion

                        else

                        {

                            int count = Convert.ToInt32(lp.Vertices.Length);

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

                                AddEntities.Add(new devDept.Eyeshot.Entities.Line(lp.Vertices[i], lp.Vertices[i + 1])

                                    LayerName = lp.LayerName,

                                    LineWeight = lp.LineWeight,

                                    LineTypeMethod = colorMethodType.byEntity

                                });

                    }

                });

                design.Entities.RemoveAll(x => (x is LinearPath));

                #endregion

                design.Entities.AddRange(AddEntities);

                #region 브랜치가 생성되는 부분에서 파이프 라인을 분할

                var queue = design.Entities.Where(x => x is Line &&

                Forms.ExceptLayer.LineLayers.Exists(y => y.Name.ToUpper() == x.LayerName.ToUpper())).ToList();

                while (queue.Any())

                {

                    var line1 = queue.First() as Line;

                    var dir1 = line1.Direction;

                    dir1.Normalize();

                    queue.Remove(line1);

                    for (int i = 0; i < queue.Count; ++i)

                        var line2 = queue.ElementAt(i) as Line;

                        var dir2 = line2.Direction;

                        dir2.Normalize();

                        if (devDept.Geometry.Vector3D.AreOrthogonal(dir1, dir2))

                            var intersects = line1.IntersectWith(line2);

                            if (intersects.Count() == 1)

                                if (line1.StartPoint.DistanceTo(intersects[0]) > 0.1 && line1.EndPoint.DistanceTo(intersects[0]) > 0.1)

                                    var split1 = new devDept.Eyeshot.Entities.Line(line1.StartPoint, intersects[0])

                                        LayerName = line1.LayerName,

                                        LineWeight = line1.LineWeight,

                                        LineTypeMethod = colorMethodType.byEntity

                                    };

                                    var split2 = new devDept.Eyeshot.Entities.Line(intersects[0], line1.EndPoint)

                                    {

                                        LayerName = line1.LayerName,

                                        LineWeight = line1.LineWeight,

                                        LineTypeMethod = colorMethodType.byEntity

                                    };

                                    design.Entities.Add(split1);

                                    design.Entities.Add(split2);

                                    design.Entities.Remove(line1);

                                    queue.Add(split1);

                                    queue.Add(split2);

                                    break;

                                }

                                if (line2.StartPoint.DistanceTo(intersects[0]) > 0.1 && line2.EndPoint.DistanceTo(intersects[0]) > 0.1)

                                {

                                    var split1 = new devDept.Eyeshot.Entities.Line(line2.StartPoint, intersects[0])

                                        LayerName = line2.LayerName,

                                        LineWeight = line2.LineWeight,

                                        LineTypeMethod = colorMethodType.byEntity

                                    };

                                    var split2 = new devDept.Eyeshot.Entities.Line(intersects[0], line2.EndPoint)

                                    {

                                        LayerName = line2.LayerName,

                                        LineWeight = line2.LineWeight,

                                        LineTypeMethod = colorMethodType.byEntity

                                    };

                                    design.Entities.Add(split1);

                                    design.Entities.Add(split2);

                                    design.Entities.Remove(line2);

                                    queue.Remove(line2);

                                    queue.Add(split1);

                                    queue.Add(split2);

                }

                #endregion

                #region 레이어 변경

                foreach (var ent in design.Entities)

                {

                    ent.Color = Verification.AutoCADColor;

                    ent.ColorMethod = colorMethodType.byEntity;

                    if (!Forms.ExceptLayer.ExceptLayers.Exists(x => x.Name.ToUpper() == ent.LayerName.ToUpper()))

                        ent.LayerName = Verification.AutoCADLayer;

                    else

                    {

                        ent.LayerName = Verification.AutoCADExceptLayer;

                    }

                }

                #endregion

                #region 블럭이거나 제외 레이어에 속한 항목은 제거

                design.Entities.RemoveAll(x => (x is BlockReference) || Forms.ExceptLayer.ExceptLayers.Exists(y => y.Name.ToUpper() == x.LayerName.ToUpper() && !y.Visible));

                #endregion

                #region 눈에 보이지 않는 라인은 제거

                design.Entities.RemoveAll(x => x is Line line && line.Length() < 0.001);

                #endregion

                ColorEntities(design, design.Entities, Verification.AutoCADColor);

                // Sets the view as Top

                design.SetView(viewType.Top);

                design.ZoomFit();

                design.Invalidate();

        }

        /// AVEVA P&ID 파일을 화면에 표시한다.

        void ShowAVEVAPIDFile(string FilePath, Design design, bool clear = true)

        {

            if (clear) design.Clear();

            if (System.IO.File.Exists(FilePath))

                var AddEntities = new List<Entity>();

                #region 다른 프로세스에서 파일을 열고 있는 경우 처리

                using (var fs = File.Open(FilePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))

                #endregion

                {

                    devDept.Eyeshot.Translators.ReadAutodesk ra = new devDept.Eyeshot.Translators.ReadAutodesk(fs);

                    ra.DoWork();

                    if (!ra.Layers.Contains(Verification.AVEVALayer)) ra.Layers.Add(Verification.AVEVALayer, Verification.AVEVAColor);

                    if (!ra.Layers.Contains(Verification.AVEVADiffLayer)) ra.Layers.Add(Verification.AVEVADiffLayer, Verification.DiffColor);

                    if (!ra.Layers.Contains(Verification.AVEVAExceptLayer)) ra.Layers.Add(Verification.AVEVAExceptLayer, Verification.AVEVAColor);

                    var min = ra.Min;

                    foreach (var ent in ra.Entities)

                        /// 도면을 원점으로 맞춘다.

                        if (min.X != 0 && min.Y != 0) ent.Translate(-min.X, -min.Y);

                        #region 멀티 라인들을 분할하여 추가한다.

                        if (ent is Mesh mesh && (mesh.LayerName == "AS_PIPE" || mesh.LayerName == "AS_INST"))

                            int count = Convert.ToInt32(mesh.Vertices.Length * 0.5);

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

                                AddEntities.Add(new devDept.Eyeshot.Entities.Line(mesh.Vertices[i], mesh.Vertices[i + 1])

                                    LayerName = Verification.AVEVALayer,

                                    LineWeight = 3.0f,

                                    LineTypeMethod = colorMethodType.byEntity,

                                    Color = Verification.AVEVAColor,

                                    ColorMethod = colorMethodType.byEntity

                                });

                            }

                        }

                        else if (ent is TabulatedSurface tf && (tf.LayerName == "AS_PIPE" || tf.LayerName == "AS_INST"))

                        {

                            int count = Convert.ToInt32(tf.ControlPoints.Length * 0.5);

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

                            {

                                AddEntities.Add(

                                    new devDept.Eyeshot.Entities.Line(

                                    new devDept.Geometry.Point3D(tf.ControlPoints[i, 0].X, tf.ControlPoints[i, 0].Y, 0),

                                    new devDept.Geometry.Point3D(tf.ControlPoints[i + 1, 0].X, tf.ControlPoints[i + 1, 0].Y, 0))

                                    }

                                );

                        }

                        else if (ent is LinearPath lp)

                        {

                            string LayerName = Forms.ExceptLayer.ExceptLayers.Exists(x => x.Name.ToUpper() == lp.LayerName.ToUpper()) ?

                                Verification.AVEVAExceptLayer : Verification.AVEVALayer;

                            int count = Convert.ToInt32(lp.Vertices.Length);

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

                                AddEntities.Add(new devDept.Eyeshot.Entities.Line(lp.Vertices[i], lp.Vertices[i + 1])

                                    LayerName = LayerName,

                                    LineWeight = lp.LineWeight,

                                    Color = Verification.AVEVAColor,

                                    LineTypeMethod = colorMethodType.byEntity

                                });

                            #region 밑에서 제거하기 위해 레이어를 AVEVALayer로 바꿔준다.

                            lp.LayerName = Verification.AVEVALayer;

                        }

                        #endregion

                        else if (ent is BlockReference blkref)

                        {

                            if (blkref.BlockName != "LBRK" && blkref.BlockName != "PSNODE" && blkref.BlockName != "PENODE")

                                AddEntities.AddRange(ExplodeBlockReference(ra.Blocks, blkref, Verification.AVEVALayer, Verification.AVEVAColor));

                        }

                        ent.Color = Verification.AVEVAColor;

                        ent.ColorMethod = colorMethodType.byEntity;

                        if (!Forms.ExceptLayer.ExceptLayers.Exists(x => x.Name.ToUpper() == ent.LayerName.ToUpper()))

                        {

                            ent.LayerName = Verification.AVEVALayer;

                        }

                        else

                        {

                            ent.LayerName = Verification.AVEVAExceptLayer;

                    ra.AddToScene(design);

                }

                #region 불필요한 블럭들은 제거

                design.Entities.RemoveAll(x => x is BlockReference);

                #endregion

                #region 블럭을 깸

                design.Entities.Where(x => x.LayerName == Verification.AVEVALayer).ToList().ForEach(x =>

                {

                    if (x is BlockReference blkref)

                        AddEntities.AddRange(ExplodeBlockReference(design.Blocks, blkref, Verification.AVEVALayer, Verification.AVEVAColor));

                    }

                });

                design.Entities.RemoveAll(x =>

                ((x is Mesh || x is TabulatedSurface) && (x.LayerName == Verification.AVEVALayer)) ||

                (x is LinearPath && x.LayerName == Verification.AVEVALayer) || (x is BlockReference) ||

                Forms.ExceptLayer.ExceptLayers.Exists(y => y.Name.ToUpper() == x.LayerName.ToUpper() && !y.Visible));

                design.Entities.AddRange(AddEntities);

                #endregion

                #region 눈에 보이지 않는 라인은 제거

                design.Entities.RemoveAll(x => x is Line line && line.Length() < 0.001);

                #endregion

                ColorEntities(design, design.Entities.Where(x => x.LayerName == Verification.AVEVALayer).ToList(), Verification.AVEVAColor);

                design.SetView(viewType.Top);

                design.ZoomFit();

                design.Invalidate();

        }

        /// <summary>

        /// 주어진 도면의 원본과 AVEVA를 비교한다.

        /// </summary>

        private void CompareDrawing(Document doc, bool ResultOnly = false)

        {

        /// <summary>

        /// BoxMin, BoxMax로 ZoomFit합니다.

        /// </summary>

        /// <param name="BoxMin"></param>

        /// <param name="BoxMax"></param>

        private void CustomZoomFit(Workspace workspace, devDept.Geometry.Point3D BoxMin, devDept.Geometry.Point3D BoxMax)

        {

            #region point must be added to desgin

            var EntMin = new devDept.Eyeshot.Entities.Point(BoxMin);

            workspace.Entities.Add(EntMin);

            var EntMax = new devDept.Eyeshot.Entities.Point(BoxMax);

            workspace.Entities.Add(EntMax);

            #endregion

            List<Entity> entList = new List<Entity>() { EntMin, EntMax };

            workspace.ZoomFit(entList, false);

            #region delete points

            workspace.Entities.Remove(EntMin);

            workspace.Entities.Remove(EntMax);

            #endregion

        }

        /// <summary>

        /// ID2에서 넘어온 영역을 Zoom한다.

        /// </summary>

        /// <param name="list"></param>

        public void ZoomEventHandler(string DwgName, double x, double y, double sizex, double sizey)

        {

            string dwgExtension = ".dwg";

            string ID2DrawingFolder = Program.AutoCADFolder;

            string dwgFilePath = System.IO.Path.Combine(ID2DrawingFolder, $"{DwgName}{dwgExtension}");

            this.Invoke(new Action(() =>

            {

                var ID2DefaultSize = new Size(9600, 6787);

                double margin = 5;

                if (!dwgFilePath.Equals(this.designCompare.FilePath)) ShowAutoCADFile(dwgFilePath, this.designCompare);

                double ScaleX = this.designCompare.Entities.BoxSize.X / ID2DefaultSize.Width;

                double ScaleY = this.designCompare.Entities.BoxSize.Y / ID2DefaultSize.Height;

                x *= ScaleX;

                y *= ScaleY;

                y = this.designCompare.Entities.BoxSize.Y - y;

                sizex *= ScaleX;

                sizey *= ScaleY;

                x -= sizex * 0.5;

                y -= sizey * 0.5;

                var ItemRect = new OrientedBoundingRect(new devDept.Geometry.Point2D(x, y), sizex, sizey);

                CustomZoomFit(this.designCompare, 

                    new devDept.Geometry.Point3D(x - sizex * margin, y - sizey * margin), 

                    new devDept.Geometry.Point3D(x + sizex * margin * 2, y + sizey * margin * 2));

                this.designCompare.Entities.ClearSelection();

                this.designCompare.Entities.ForEach(param => 

                {

                    var obr = new OrientedBoundingRect(param.BoxMin, param.BoxSize.X, param.BoxSize.Y);

                    if(OrientedBoundingRect.DoOverlap(ItemRect, obr)) param.Selected = true;

                });

                this.designCompare.Invalidate();

            }));

        }

    <Compile Include="Classes\TcpServer.cs" />

        private TcpServer _TcpServer { get; } = TcpServer.Instance;

            this.FormClosing += Main_FormClosing;

        }

        /// <summary>

        /// TcpServer를 종료한다.

        /// </summary>

        /// <param name="sender"></param>

        /// <param name="e"></param>

        private void Main_FormClosing(object sender, FormClosingEventArgs e)

        {

            this._TcpServer.Close();

            finally

            {

                var verification = this.LayoutValidation.Controls[0] as Controls.Verification;

                _TcpServer.OnZoomEvent += verification.ZoomEventHandler;

            }

[assembly: AssemblyVersion("20.24.5.2")]

[assembly: AssemblyFileVersion("20.24.5.2")]

    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "17.9.0.0")]

        [global::System.Configuration.ApplicationScopedSettingAttribute()]

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

        [global::System.Configuration.DefaultSettingValueAttribute("3030")]

        public int TcpServerPort {

            get {

                return ((int)(this["TcpServerPort"]));

            }

        }

    <Setting Name="TcpServerPort" Type="System.Int32" Scope="Application">

      <Value Profile="(Default)">3030</Value>

    </Setting>