HYTOS

        /// 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();

            }));

        }