Tools/加密后软件工具/CAD插件工具/CutDGX/CutDGX/Dgxthrorvrd.cs

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Geometry;
using Autodesk.AutoCAD.Runtime;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CutDGX
{
    public struct colorgb
    {
        public byte red;
        public byte green;
        public byte blue;

        public colorgb(byte r, byte g, byte b)
        {
            this.red = r;
            this.green = g;
            this.blue = b;
        }
    }
    class Dgxthrorvrd
    {
        public static List<string> dgxlist;
        public static List<string> rvrdlist;
        public static List<string> kzlist;
        public static int blc;

        
        public void Dgxbreak()
        {
            string dgxname = "";
            Editor ed = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument.Editor;

            for (int i = 0; i < dgxlist.Count; i++)
            {
                if (i == 0)
                    dgxname = dgxlist[i];
                else
                    dgxname = dgxname + "," + dgxlist[i];
            }
            TypedValue[] value = new TypedValue[]
            {
                    new TypedValue((int)DxfCode.LayerName,dgxname)
            };
            SelectionFilter filter = new SelectionFilter(value);
            //dynamic acadApp = AutoCAD.ApplicationServices.Application.AcadApplication;
            //acadApp.ZoomExtents();
            PromptSelectionResult psr = ed.SelectAll(filter);
            if (psr.Status == PromptStatus.OK)
            {
                SelectionSet ss = psr.Value;
                ObjectIdCollection idcoll = new ObjectIdCollection(ss.GetObjectIds());
                for (int ii = 0; ii < idcoll.Count; ii++)
                {
                    //using (Transaction trans = db.TransactionManager.StartTransaction())
                    //{
                        Intersectcheck(idcoll[ii], ed);
                        //trans.Commit();
                    //}
                }
            }
            dgxlist.Clear();
            if (rvrdlist != null)
                rvrdlist.Clear();
            if (kzlist != null)
                kzlist.Clear();
        }

        private void Intersectcheck(ObjectId id, Editor ed)
        {
            var plane = new Plane(Point3d.Origin, Vector3d.ZAxis);
            Point3dCollection pts = new Point3dCollection();
            Point3dCollection pts1 = new Point3dCollection();
            Point3dCollection kz_pts = new Point3dCollection();
            string rvrdname = "";
            string kzname = "";
            //为坎子让出的长度
            double cut_dist = 0.5;
            if (blc == 1000)
                cut_dist = cut_dist * 2;
            if (blc == 2000)
                cut_dist = cut_dist * 4;
            if (blc == 5000)
                cut_dist = cut_dist * 10;
            if (blc == 10000)
                cut_dist = cut_dist * 20;

            Database db = Autodesk.AutoCAD.DatabaseServices.HostApplicationServices.WorkingDatabase;
            DocumentLock doclock = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument.LockDocument();
            using (Transaction trans = db.TransactionManager.StartTransaction())
            {
                Entity ent = trans.GetObject(id, OpenMode.ForWrite) as Entity;
                Polyline pll = new Polyline();
                if (ent is Polyline)
                    pll = (Polyline)ent;
                else
                    return;
                //添加道路河流房屋的图层名并搜索相应图层上的实体
                if (rvrdlist != null)
                {
                    //if (kzlist != null)
                    //{
                    //    rvrdlist.AddRange(kzlist);
                    //}
                    Point3dCollection ptcoll = new Point3dCollection();
                    for (int i = 0; i < pll.NumberOfVertices; i++)
                    {
                        ptcoll.Add(pll.GetPoint3dAt(i));
                    }
                    List<string> lyrname = rvrdlist;
                    for (int i = 0; i < lyrname.Count; i++)
                    {
                        if (i == 0)
                            rvrdname = lyrname[i];
                        else
                            rvrdname = rvrdname + "," + lyrname[i];
                    }
                    TypedValue[] value = new TypedValue[]
                    {
                        new TypedValue((int)DxfCode.LayerName,rvrdname)
                    };
                    SelectionFilter filter = new SelectionFilter(value);
                    ZoomView(ed, pll.Bounds.Value.MinPoint, pll.Bounds.Value.MaxPoint);
                    PromptSelectionResult psr = ed.SelectFence(ptcoll,filter);
                    if (psr.Status == PromptStatus.OK)
                    {
                        SelectionSet ss = psr.Value;
                        ObjectIdCollection idcoll = new ObjectIdCollection(ss.GetObjectIds());
                        for (int i = 0; i < idcoll.Count; i++)
                        {
                            Entity ent1 = trans.GetObject(idcoll[i], OpenMode.ForWrite) as Entity;
                            Polyline pll_rvrd = new Polyline();
                            if (ent1 is Polyline)
                                pll_rvrd = (Polyline)ent1;
                            else
                                continue;
                            Point3dCollection intersectionPoints = new Point3dCollection();
                            intersectionPoints = GetIntersections(pll, pll_rvrd);
                            //pll.IntersectWith(pll_rvrd, Intersect.OnBothOperands, plane, intersectionPoints, IntPtr.Zero, IntPtr.Zero);
                            if (intersectionPoints.Count > 0)
                            {
                                foreach (Point3d pt in intersectionPoints)
                                {
                                    if (pts.Contains(pll.GetClosestPointTo(pt, false)))
                                        continue;
                                    else
                                        pts.Add(pll.GetClosestPointTo(pt, false));
                                }
                            }
                        }
                    }
                }



                //添加坎子图层名并搜索相应图层上的实体
                if (kzlist != null)
                {
                    for (int i = 0; i < kzlist.Count; i++)
                    {
                        if (i == 0)
                            kzname = kzlist[i];
                        else
                            kzname = kzname + "," + kzlist[i];
                    }
                    TypedValue[] value_kz = new TypedValue[]
                    {
                    new TypedValue((int)DxfCode.LayerName,kzname)
                    };
                    SelectionFilter filter_kz = new SelectionFilter(value_kz);
                    PromptSelectionResult psr_kz = ed.SelectAll(filter_kz);
                    if (psr_kz.Status == PromptStatus.OK)
                    {
                        SelectionSet ss = psr_kz.Value;
                        ObjectIdCollection idcoll = new ObjectIdCollection(ss.GetObjectIds());
                        List<Point3d> ptlist = new List<Point3d>();
                        for (int i = 0; i < idcoll.Count; i++)
                        {
                            Entity ent1 = trans.GetObject(idcoll[i], OpenMode.ForWrite) as Entity;
                            Polyline pll_rvrd = new Polyline();
                            if (ent1 is Polyline)
                                pll_rvrd = (Polyline)ent1;
                            else
                                continue;
                            Point3dCollection intersectionPoints = new Point3dCollection();
                            intersectionPoints = GetIntersections(pll, pll_rvrd);
                            //pll.IntersectWith(pll_rvrd, Intersect.OnBothOperands, plane, intersectionPoints, IntPtr.Zero, IntPtr.Zero);

                            foreach (var item in intersectionPoints)
                            {
                                ptlist.Add((Point3d)item);
                            }
                        }
                        if (ptlist.Count > 0)
                        {
                            var sortedlist = ptlist.OrderBy(x => pll.GetParameterAtPoint(x)).ToList();
                            for (int j = 0; j < sortedlist.Count; j++)
                            {
                                Point3d pt;
                                Point3d bkpt = pll.GetClosestPointTo(sortedlist[j], false);
                                if (j % 2 == 0 || j == 0)
                                {
                                    pt = pll.GetPointAtDist(pll.GetDistAtPoint(bkpt) - cut_dist);
                                }
                                else
                                    pt = pll.GetPointAtDist(pll.GetDistAtPoint(bkpt) + cut_dist);
                                //foreach (Point3d pt in intersectionPoints)
                                //{
                                //    pts1.Add(pt);
                                //}
                                pts.Add(pt);
                            }
                        }

                        #region
                        //if (pts.Count > 0)
                        //{
                        //    //按参数值排序交点
                        //    List<double> paramList = new List<double>();
                        //    foreach (Point3d breakPoint in pts)
                        //    {
                        //        double param = pll.GetParameterAtPoint(breakPoint);
                        //        paramList.Add(param);
                        //    }
                        //    paramList.Sort();

                        //    //存储分割后的多段线
                        //    List<Polyline> newPlls = new List<Polyline>();

                        //    // 初始化第一条多段线
                        //    Polyline currentPline = new Polyline();
                        //    currentPline.SetDatabaseDefaults();
                        //    currentPline.Layer = pll.Layer;
                        //    currentPline.Color = pll.Color;

                        //    // 遍历多段线的节点
                        //    for (int i = 0; i < pll.NumberOfVertices; i++)
                        //    {
                        //        Point2d point = pll.GetPoint2dAt(i);
                        //        double bulge = pll.GetBulgeAt(i);

                        //        // 添加节点到当前多段线
                        //        currentPline.AddVertexAt(currentPline.NumberOfVertices, point, bulge, 0, 0);

                        //        // 检查是否需要分割
                        //        if (paramList.Count > 0 && i == (int)paramList[0])
                        //        {
                        //            // 检查当前节点和下一个节点之间是否有交点
                        //            while (paramList.Count > 0 && paramList[0] >= i && paramList[0] < i + 1)
                        //            {
                        //                // 计算交点处的精确位置
                        //                double param = paramList[0];
                        //                double dist = pll.GetDistanceAtParameter(param)- cut_dist;
                        //                Point3d splitPoint3d = pll.GetPointAtDist(dist);
                        //                Point2d splitPoint = new Point2d(splitPoint3d.X, splitPoint3d.Y);
                        //                kz_pts.Add(splitPoint3d);

                        //                // 添加当前多段线到结果列表
                        //                currentPline.AddVertexAt(currentPline.NumberOfVertices, splitPoint, 0, 0, 0);
                        //                BlockTable bt = (BlockTable)(trans.GetObject(db.BlockTableId, OpenMode.ForRead));
                        //                BlockTableRecord btr = (BlockTableRecord)trans.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite);
                        //                btr.AppendEntity(currentPline);
                        //                trans.AddNewlyCreatedDBObject(currentPline, true);
                        //                newPlls.Add(currentPline);

                        //                // 初始化下一条多段线
                        //                currentPline = new Polyline();
                        //                currentPline.SetDatabaseDefaults();
                        //                currentPline.Layer = pll.Layer;
                        //                currentPline.Color = pll.Color;

                        //                // 添加分割点作为下一条多段线的起点
                        //                double dist1 = pll.GetDistanceAtParameter(param) + cut_dist;
                        //                Point3d splitPoint3d1 = pll.GetPointAtDist(dist1);
                        //                Point2d splitPoint1 = new Point2d(splitPoint3d1.X, splitPoint3d1.Y);
                        //                kz_pts.Add(splitPoint3d1);
                        //                currentPline.AddVertexAt(0, splitPoint1, 0, 0, 0);

                        //                // 移除已处理的交点
                        //                paramList.RemoveAt(0);
                        //            }
                        //        }
                        //    }

                        //    if (currentPline.NumberOfVertices > 0)
                        //    {
                        //        BlockTable bt = (BlockTable)(trans.GetObject(db.BlockTableId, OpenMode.ForRead));
                        //        BlockTableRecord btr = (BlockTableRecord)trans.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite);
                        //        btr.AppendEntity(currentPline);
                        //        trans.AddNewlyCreatedDBObject(currentPline, true);
                        //        newPlls.Add(currentPline);
                        //    }
                        //    pll.Erase();


                        //    for (int i = 0; i < newPlls.Count; i++)
                        //    {
                        //        if (kz_pts.Contains(newPlls[i].StartPoint) &&
                        //            kz_pts.Contains(newPlls[i].EndPoint) &&
                        //            i % 2 == 1)
                        //            newPlls[i].Layer = "待删除等高线";
                        //        else if (newPlls.Count == 2)
                        //        {
                        //            if (newPlls[0].Length < newPlls[1].Length)
                        //                newPlls[0].Layer = "待删除等高线";
                        //            else
                        //                newPlls[1].Layer = "待删除等高线";
                        //        }
                        //    }
                        //}
                        #endregion
                    }
                }



                if (pts.Count > 0)
                {
                    //创建新图层
                    string layname = "待删除等高线";
                    if (!haslayername(layname))
                    {
                        colorgb col = new colorgb(255, 0, 255);
                        creatlayer(layname, col);
                        movelayertofront(layname);
                    }
                    else
                        movelayertofront(layname);


                    //按参数值排序交点
                    List<double> paramList = new List<double>();
                    List<double> kzparam = new List<double>();
                    foreach (Point3d breakPoint in pts)
                    {
                        double param = pll.GetParameterAtPoint(breakPoint);
                        if (pts1.Contains(breakPoint))
                            kzparam.Add(param);
                        paramList.Add(param);
                    }
                    paramList.Sort();

                    //存储分割后的多段线
                    List<Polyline> newPlls = new List<Polyline>();

                    // 初始化第一条多段线
                    Polyline currentPline = new Polyline();
                    currentPline.SetDatabaseDefaults();
                    currentPline.Layer = pll.Layer;
                    currentPline.Color = pll.Color;

                    // 遍历多段线的节点
                    //for (int i = 0; i < pll.NumberOfVertices; i++)
                    //{
                    //    Point2d point = pll.GetPoint2dAt(i);
                    //    double bulge = pll.GetBulgeAt(i);

                    //    // 添加节点到当前多段线
                    //    currentPline.AddVertexAt(currentPline.NumberOfVertices, point, bulge, 0, 0);

                    //    // 检查是否需要分割
                    //    if (paramList.Count > 0 && i == (int)paramList[0])
                    //    {
                    //        // 检查当前节点和下一个节点之间是否有交点
                    //        while (paramList.Count > 0 && paramList[0] >= i && paramList[0] < i + 1)
                    //        {
                    //            // 计算交点处的精确位置
                    //            double param = paramList[0];
                    //            double dist;
                    //            if (kzparam.Contains(param))
                    //            {
                    //                dist = pll.GetDistanceAtParameter(param) - cut_dist;
                    //                kz_pts.Add(pll.GetPointAtDist(dist));
                    //            }
                    //            else
                    //                dist = pll.GetDistanceAtParameter(param);
                    //            Point3d splitPoint3d = pll.GetPointAtDist(dist);
                    //            Point2d splitPoint = new Point2d(splitPoint3d.X, splitPoint3d.Y);

                    //            // 添加当前多段线到结果列表
                    //            currentPline.AddVertexAt(currentPline.NumberOfVertices, splitPoint, 0, 0, 0);
                    //            BlockTable bt = (BlockTable)(trans.GetObject(db.BlockTableId, OpenMode.ForRead));
                    //            BlockTableRecord btr = (BlockTableRecord)trans.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite);
                    //            btr.AppendEntity(currentPline);
                    //            trans.AddNewlyCreatedDBObject(currentPline, true);
                    //            newPlls.Add(currentPline);

                    //            // 初始化下一条多段线
                    //            currentPline = new Polyline();
                    //            currentPline.SetDatabaseDefaults();
                    //            currentPline.Layer = pll.Layer;
                    //            currentPline.Color = pll.Color;

                    //            // 添加分割点作为下一条多段线的起点
                    //            if (kzparam.Contains(param))
                    //            {
                    //                double dist1 = pll.GetDistanceAtParameter(param) + cut_dist;
                    //                Point3d splitPoint3d1 = pll.GetPointAtDist(dist1);
                    //                Point2d splitPoint1 = new Point2d(splitPoint3d1.X, splitPoint3d1.Y);
                    //                kz_pts.Add(splitPoint3d1);
                    //                currentPline.AddVertexAt(0, splitPoint1, 0, 0, 0);
                    //            }
                    //            else
                    //                currentPline.AddVertexAt(0, splitPoint, 0, 0, 0);

                    //            // 移除已处理的交点
                    //            paramList.RemoveAt(0);
                    //        }
                    //    }
                    //}

                    //if (currentPline.NumberOfVertices > 0)
                    //{
                    //    BlockTable bt = (BlockTable)(trans.GetObject(db.BlockTableId, OpenMode.ForRead));
                    //    BlockTableRecord btr = (BlockTableRecord)trans.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite);
                    //    btr.AppendEntity(currentPline);
                    //    trans.AddNewlyCreatedDBObject(currentPline, true);
                    //    newPlls.Add(currentPline);
                    //}
                    List<Point3d> pts_list = new List<Point3d>();
                    foreach (var item in pts)
                    {
                        pts_list.Add((Point3d)item);
                    }
                    var pts_sorted = pts_list.OrderBy(x => pll.GetParameterAtPoint(x));
                    pts.Clear();
                    foreach (var item in pts_sorted)
                    {
                        pts.Add(item);
                    }
                    foreach (var item in pll.GetSplitCurves(pts))
                    {
                        BlockTable bt = (BlockTable)(trans.GetObject(db.BlockTableId, OpenMode.ForRead));
                        BlockTableRecord btr = (BlockTableRecord)trans.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite);
                        btr.AppendEntity((Polyline)item);
                        trans.AddNewlyCreatedDBObject((Polyline)item, true);
                        newPlls.Add((Polyline)item);
                    }
                    pll.Erase();


                    for (int i = 0; i < newPlls.Count; i++)
                    {
                        if (newPlls.Count == 2)
                        {
                            if (newPlls[0].Length < newPlls[1].Length)
                                newPlls[0].Layer = "待删除等高线";
                            else
                                newPlls[1].Layer = "待删除等高线";
                        }
                        else if (pts.Contains(newPlls[i].StartPoint) &&
                            pts.Contains(newPlls[i].EndPoint) &&
                            i % 2 == 1)
                            newPlls[i].Layer = "待删除等高线";
                        else if (kz_pts.Contains(newPlls[i].StartPoint) &&
                            kz_pts.Contains(newPlls[i].EndPoint) &&
                            i % 2 == 1)
                            newPlls[i].Layer = "待删除等高线";
                    }
                }

                trans.Commit();
            }
            doclock.Dispose();
        }

        /// <summary>
        /// 缩放视图以便搜索
        /// </summary>
        private void ZoomView(Editor edit, Point3d pt1, Point3d pt2)
        {
            var x_min = Math.Min(pt1.X, pt2.X);
            var y_min = Math.Min(pt1.Y, pt2.Y);
            using (ViewTableRecord currview1 = edit.GetCurrentView())
            {
                currview1.CenterPoint = new Point2d(Math.Abs((pt2.X - pt1.X) / 2) + x_min,
                                                    Math.Abs((pt2.Y - pt1.Y) / 2) + y_min);
                currview1.Width = Math.Abs(pt2.X - pt1.X + 1);
                currview1.Height = Math.Abs(pt2.Y - pt1.Y + 1);
                edit.SetCurrentView(currview1);
            }
        }



        /// <summary>
        /// 创建高程点错误标记层
        /// </summary>
        /// <param name="layername">要创建的图层的名字</param>
        /// <param name="colo">RGB三原色</param>
        public void creatlayer(string layername, colorgb colo)
        {
            Database database = Autodesk.AutoCAD.DatabaseServices.HostApplicationServices.WorkingDatabase;
            DocumentLock doclock = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument.LockDocument();
            Transaction traction = database.TransactionManager.StartTransaction();
            LayerTable lt = traction.GetObject(database.LayerTableId, OpenMode.ForWrite) as LayerTable;
            try
            {
                LayerTableRecord layertablerecord = new LayerTableRecord();
                layertablerecord.Name = layername;//设置层表记录的名字
                layertablerecord.Color = Autodesk.AutoCAD.Colors.Color.FromRgb(colo.red, colo.green, colo.blue);//为层表记录赋颜色紫色
                //layertablerecord.Color = GrxCAD.Colors.Color.FromColor(System.Drawing.Color.Magenta);


                lt.Add(layertablerecord);
                traction.AddNewlyCreatedDBObject(layertablerecord, true);
                traction.Commit();
            }
            catch (Autodesk.AutoCAD.Runtime.Exception)
            {
                traction.Abort();
            }
            finally
            {
                traction.Dispose();
                doclock.Dispose();
            }
        }


        /// <summary>
        /// 将指定图层设置为当前图层
        /// </summary>
        /// <param name="layername">要设置为当前图层的图层名字</param>
        public void movelayertofront(string layername)
        {
            Database database = Autodesk.AutoCAD.DatabaseServices.HostApplicationServices.WorkingDatabase;
            DocumentLock doclock = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument.LockDocument();
            Transaction traction = database.TransactionManager.StartTransaction();
            try
            {
                LayerTable layertable = traction.GetObject(database.LayerTableId, OpenMode.ForRead) as LayerTable;
                database.Clayer = layertable[layername];//把图层选为当前图层
                traction.Commit();
            }
            catch (Autodesk.AutoCAD.Runtime.Exception)
            {
                traction.Abort();
            }
            finally
            {
                traction.Dispose();
                doclock.Dispose();
            }
        }
        /// <summary>
        /// 判断所命图层名是否已经存在
        /// </summary>
        /// <param name="layername">要判断的图层名字</param>
        /// <returns>返回true表示在层表中存在要判断的图层名，
        /// 返回false表示层表中不存在判断的图层名</returns>
        public bool haslayername(string layername)
        {
            Database database = Autodesk.AutoCAD.DatabaseServices.HostApplicationServices.WorkingDatabase;
            using (Transaction traction = database.TransactionManager.StartTransaction())
            {
                LayerTable lt = traction.GetObject(database.LayerTableId, OpenMode.ForRead) as LayerTable;

                if (lt.Has(layername))
                {
                    traction.Commit();
                    return true;
                }
                else
                {
                    traction.Commit();
                    return false;
                }
            }



        }

        private static Point3dCollection GetIntersections(Polyline pll1, Polyline pll2)
        {
            List<Point3d> sort = new List<Point3d>();
            Point3dCollection result = new Point3dCollection();

            // 创建临时副本
            Polyline tempLine1 = (Polyline)pll1.Clone();
            Polyline tempLine2 = (Polyline)pll2.Clone();

            // 计算平移向量（以线1起点为基准，移动至原点）
            Vector3d translation = -tempLine1.StartPoint.GetAsVector();
            Matrix3d translateMatrix = Matrix3d.Displacement(translation);

            // 应用平移变换
            tempLine1.TransformBy(translateMatrix);
            tempLine2.TransformBy(translateMatrix);

            Point3dCollection translatedPoints = new Point3dCollection();
            var plane = new Plane(Point3d.Origin, Vector3d.ZAxis);
            tempLine1.IntersectWith(tempLine2, Intersect.OnBothOperands, plane, translatedPoints, IntPtr.Zero, IntPtr.Zero);

            // 计算逆平移矩阵
            Matrix3d inverseMatrix = Matrix3d.Displacement(-translation);
            if (translatedPoints.Count > 0)
            {
                // 获取平移后的交点
                foreach (Point3d item in translatedPoints)
                {
                    // 恢复交点坐标
                    var pt = item.TransformBy(inverseMatrix);
                    sort.Add(pt);
                }
            }
            var sorted = sort.OrderBy(x => pll1.GetParameterAtPoint(x));
            foreach (var item in sorted)
            {
                result.Add(item);
            }
            return result;
        }
    }
}