CAD二次开发（4）-编辑图形

于 2024-05-26 08:18:13 发布
阅读量372 收藏 3
点赞数 3
分类专栏： 后台 文章标签： CAD二次开发 c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wu2374633583/article/details/139203097
版权

工具类：EditEntityTool.cs

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.Geometry;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using AcDotNetTool;
namespace _03编辑图形
{
    public static  partial class EditEntityTool
    {
        /// <summary>
        /// 改变图形颜色
        /// </summary>
        /// <param name="c1Id">图形的ObjectId</param>
        /// <param name="colorIndex">颜色索引</param>
        public  static void ChangeEntityColor(this ObjectId c1Id, short colorIndex)
        {
            //图形数据库
            Database db = HostApplicationServices.WorkingDatabase;
            using (Transaction trans = db.TransactionManager.StartTransaction())
            {
                //打开块表
                BlockTable bt = (BlockTable)trans.GetObject(db.BlockTableId, OpenMode.ForRead);
                //打开块表记录
                BlockTableRecord btr = (BlockTableRecord)trans.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForRead);
                //获取图形对象
                Entity ent1 = (Entity)c1Id.GetObject(OpenMode.ForWrite);
                ent1.ColorIndex = colorIndex;
                trans.Commit();
            }
        }
        /// <summary>
        /// 改变图形颜色
        /// </summary>
        /// <param name="ent">图形对象</param>
        /// <param name="colorIndex">颜色索引</param>
        public static void ChangeEntityColor(this Entity ent, short colorIndex)
        {
            //判断图形的IsNewlyObject
            if (ent.IsNewObject)
            {
                ent.ColorIndex = colorIndex;
            }
            else
            {
                ent.ObjectId.ChangeEntityColor(colorIndex);
            }
        }
        /// <summary>
        /// 移动图形
        /// </summary>
        /// <param name="entId">图形对象的ObjectId</param>
        /// <param name="sorucePoint">参考原点</param>
        /// <param name="targetPoint">参考目标点</param>
        public static void MoveEntity(this ObjectId entId, Point3d sourcePoint, Point3d targetPoint)
        {
            //当前图形数据库
            Database db = HostApplicationServices.WorkingDatabase;
            using (Transaction trans = db.TransactionManager.StartTransaction())
            {
                //打开块表
                BlockTable bt = (BlockTable)trans.GetObject(db.BlockTableId, OpenMode.ForRead);
                //打开块表记录
                BlockTableRecord btr = (BlockTableRecord)trans.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForRead);
                //打开图形
                //Entity ent = (Entity)trans.GetObject(entId, OpenMode.ForWrite);
                Entity ent = (Entity)entId.GetObject(OpenMode.ForWrite);
                //计算变换矩阵
                Vector3d vector = sourcePoint.GetVectorTo(targetPoint);
                Matrix3d mt = Matrix3d.Displacement(vector);
                ent.TransformBy(mt);
                //提交事务处理
                trans.Commit();
            }
        }
        /// <summary>
        /// 移动图形
        /// </summary>
        /// <param name="entId">图形对象</param>
        /// <param name="sorucePoint">参考原点</param>
        /// <param name="targetPoint">参考目标点</param>
        public static void MoveEntity(this Entity ent, Point3d sourcePoint, Point3d targetPoint)
        {
            //判断图形对象的IsNewlyObejct属性
            if (ent.IsNewObject)
            {
                //计算变换矩阵
                Vector3d vector = sourcePoint.GetVectorTo(targetPoint);
                Matrix3d mt = Matrix3d.Displacement(vector);
                ent.TransformBy(mt);
            }
            else
            {
                ent.ObjectId.MoveEntity(sourcePoint, targetPoint);
            }
        }
        /// <summary>
        /// 复制图形
        /// </summary>
        /// <param name="entId">图形的半ObjectId</param>
        /// <param name="sourcePoint">参考起点</param>
        /// <param name="targetPoint">参考终点</param>
        /// <returns>图形对象,没有加入图形数据库</returns>
        public static Entity CopyEntity(this ObjectId entId, Point3d sourcePoint, Point3d targetPoint)
        {
            //声明一个图形对象
            Entity entR;
            //当前图形数据库
            Database db = HostApplicationServices.WorkingDatabase;
            using (Transaction trans = db.TransactionManager.StartTransaction())
            {
                //打开块表
                BlockTable bt = (BlockTable)trans.GetObject(db.BlockTableId, OpenMode.ForRead);
                //打开块表记录
                BlockTableRecord btr = (BlockTableRecord)trans.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForRead);
                //打开图形
                //Entity ent = (Entity)trans.GetObject(entId, OpenMode.ForWrite);
                Entity ent = (Entity)entId.GetObject(OpenMode.ForWrite);
                
                //计算变换矩阵
                Vector3d vector = sourcePoint.GetVectorTo(targetPoint);
                Matrix3d mt = Matrix3d.Displacement(vector);
                entR =  ent.GetTransformedCopy(mt);
                //提交事务处理
                trans.Commit();
            }

            return entR;
        }
        /// <summary>
        /// 复制图形
        /// </summary>
        /// <param name="entId">图形对象ram>
        /// <param name="sourcePoint">参考起点</param>
        /// <param name="targetPoint">参考终点</param>
        /// <returns>图形对象,没有加入图形数据库</returns>
        public static Entity CopyEntity(this Entity ent, Point3d sourcePoint, Point3d targetPoint)
        {
            //声明一个图形对象
            Entity entR;
            //判断图形对象的IsNewlyObejct属性
            if (ent.IsNewObject)
            {
                //计算变换矩阵
                Vector3d vector = sourcePoint.GetVectorTo(targetPoint);
                Matrix3d mt = Matrix3d.Displacement(vector);
                entR =  ent.GetTransformedCopy(mt);
            }
            else
            {
                entR =  ent.ObjectId.CopyEntity(sourcePoint, targetPoint);
            }
            return entR;
        }
        /// <summary>
        /// 旋转图形
        /// </summary>
        /// <param name="ent">图形对象的ObjectId</param>
        /// <param name="center">旋转中点</param>
        /// <param name="degree">旋转的角度</param>
        public static void  RotateEntity(this ObjectId entId, Point3d center,double degree)
        {
            
            //当前图形数据库
            Database db = HostApplicationServices.WorkingDatabase;
            using (Transaction trans = db.TransactionManager.StartTransaction())
            {
                //打开块表
                BlockTable bt = (BlockTable)trans.GetObject(db.BlockTableId, OpenMode.ForRead);
                //打开块表记录
                BlockTableRecord btr = (BlockTableRecord)trans.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForRead);
                //打开图形
                //Entity ent = (Entity)trans.GetObject(entId, OpenMode.ForWrite);
                Entity ent = (Entity)entId.GetObject(OpenMode.ForWrite);

                //计算变换矩阵
                Matrix3d mt = Matrix3d.Rotation(degree.DegreeToAngle(), Vector3d.ZAxis, center);
                ent.TransformBy(mt);
                //提交事务处理
                trans.Commit();
            }
        }
        /// <summary>
        /// 旋转图形
        /// </summary>
        /// <param name="ent">图形对象</param>
        /// <param name="center">旋转中点</param>
        /// <param name="degree">旋转的角度</param>
        public static void RotateEntity(this Entity ent, Point3d center, double degree)
        {
            //判断图形对象的IsNewlyObejct属性
            if (ent.IsNewObject)
            {
                //计算变换矩阵

                Matrix3d mt = Matrix3d.Rotation(degree.DegreeToAngle(), Vector3d.ZAxis, center);
                ent.TransformBy(mt);
            }
            else
            {
                ent.ObjectId.RotateEntity(center, degree);
            }
        }
        /// <summary>
        /// 镜像图形
        /// </summary>
        /// <param name="entId">图形对象的ObjectId</param>
        /// <param name="point1">第一个镜像点</param>
        /// <param name="point2">第二个镜像点</param>
        /// <param name="isEraseSoruce">是否删除原图</param>
        /// <returns>返回新的图形对象，没有加入图形数据库</returns>
        public static Entity MirrorEntity(this ObjectId entId, Point3d point1, Point3d point2, bool isEraseSoruce)
        {
            //声明一个图形对象,用于返回
            Entity entR;
            //计算镜像的变换矩阵
            Matrix3d mt = Matrix3d.Mirroring(new Line3d(point1, point2));
            //打开事务处理
            using (Transaction trans = entId.Database.TransactionManager.StartTransaction())
            {
                //打开原对象
                Entity ent = (Entity)trans.GetObject(entId, OpenMode.ForWrite);
                //这里得到的图形的IsNewlyObject = true
                entR = ent.GetTransformedCopy(mt);
                //判断是否删除对象
                if (isEraseSoruce)
                {
                    ent.Erase();
                }
                trans.Commit();
            }
            return entR;
        }
        /// <summary>
        /// 镜像图形
        /// </summary>
        /// <param name="entId">图形对象</param>
        /// <param name="point1">第一个镜像点</param>
        /// <param name="point2">第二个镜像点</param>
        /// <param name="isEraseSoruce">是否删除原图</param>
        /// <returns>返回新的图形对象，没有加入图形数据库</returns>
        public static Entity MirrorEntity(this Entity ent, Point3d point1, Point3d point2, bool isEraseSoruce)
        {
            //声明一个图形对象,用于返回
            Entity entR;
            if (ent.IsNewObject == true)
            {
                //计算镜像的变换矩阵
                Matrix3d mt = Matrix3d.Mirroring(new Line3d(point1, point2));
                entR = ent.GetTransformedCopy(mt);
            }
            else
            {
                
                entR  = ent.ObjectId.MirrorEntity(point1, point2, isEraseSoruce);
            }
            return entR;
        }
        /// <summary>
        /// 缩放图形
        /// </summary>
        /// <param name="entId">图形对象的ObjectId</param>
        /// <param name="basePoint">缩放的基点</param>
        /// <param name="facter">缩放比例</param>
        public static void ScaleEntity(this ObjectId entId, Point3d basePoint, double facter)
        {
            //计算缩放矩阵
            Matrix3d mt = Matrix3d.Scaling(facter, basePoint);
            //启动事务处理
            using (Transaction trans = entId.Database.TransactionManager.StartTransaction())
            {
                //打开要缩放的图形对象
                Entity ent = (Entity)entId.GetObject(OpenMode.ForWrite);
                ent.TransformBy(mt);
                trans.Commit();
            }
        }
        /// <summary>
        /// 缩放图形
        /// </summary>
        /// <param name="entId">图形对象的</param>
        /// <param name="basePoint">缩放的基点</param>
        /// <param name="facter">缩放比例</param>
        public static void ScaleEntity(this Entity ent, Point3d basePoint, double facter)
        {
            //判断图形对象的IsNewlyObject属性
            if (ent.IsNewObject == true)
            {
                //计算缩放矩阵
                Matrix3d mt = Matrix3d.Scaling(facter, basePoint);
                ent.TransformBy(mt);
            }
            else
            {
                ent.ObjectId.ScaleEntity(basePoint, facter);
            }
        }
        /// <summary>
        /// 删除图形对象
        /// </summary>
        /// <param name="entId">图形对象的ObjectId</param>
        public static void EraseEntity(this ObjectId entId)
        {
            //打开事务处理
            using (Transaction trans = entId.Database.TransactionManager.StartTransaction())
            {
                //打开要缩放的图形对象
                Entity ent = (Entity)entId.GetObject(OpenMode.ForWrite);
                ent.Erase();
                trans.Commit();
            }
        }
        /// <summary>
        /// 巨型阵列
        /// </summary>
        /// <param name="entId">图形对象的ObjectId</param>
        /// <param name="rowNum">行数</param>
        /// <param name="columnNum">列数</param>
        /// <param name="disRow">行距</param>
        /// <param name="disColumn">列距</param>
        /// <returns>List<Entity> 已加入图形数据库</returns>
        public static List<Entity> ArrayRectEntity(this ObjectId entId,int rowNum,int columnNum,double disRow,double disColumn)
        {
            //声明一个Enity类型的集合
            List<Entity> entList = new List<Entity>();
            //当前图形数据库
            Database db = HostApplicationServices.WorkingDatabase;
            using (Transaction trans = db.TransactionManager.StartTransaction())
            {
                //打开块表
                BlockTable bt = (BlockTable)trans.GetObject(db.BlockTableId, OpenMode.ForRead);
                //打开块表记录
                BlockTableRecord btr = (BlockTableRecord)trans.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite);
                //打开图形
                //Entity ent = (Entity)trans.GetObject(entId, OpenMode.ForWrite);
                Entity ent = (Entity)entId.GetObject(OpenMode.ForWrite);
                //计算变换矩阵
                for (int i = 0; i < rowNum; i++)
                {
                    for (int j = 0; j < columnNum; j++)
                    {
                        Matrix3d mt = Matrix3d.Displacement(new Vector3d(j * disColumn, i * disRow, 0));
                        Entity entA = ent.GetTransformedCopy(mt);
                        btr.AppendEntity(entA);
                        trans.AddNewlyCreatedDBObject(entA,true);
                        entList.Add(entA);
                    }
                }
                ent.Erase();
                //提交事务处理
                trans.Commit();

            }
            return entList;
        }
        /// <summary>
        /// 巨型阵列
        /// </summary>
        /// <param name="entId">图形对象</param>
        /// <param name="rowNum">行数</param>
        /// <param name="columnNum">列数</param>
        /// <param name="disRow">行距</param>
        /// <param name="disColumn">列距</param>
        /// <returns>List<Entity> 已加入图形数据库</returns>
        public static List<Entity> ArrayRectEntity(this Entity entS, int rowNum, int columnNum, double disRow, double disColumn)
        {
            if (entS.IsNewObject == true)
            {
                //声明一个Enity类型的集合
                List<Entity> entList = new List<Entity>();
                Database db = HostApplicationServices.WorkingDatabase;
                using (Transaction trans = db.TransactionManager.StartTransaction())
                {
                    //打开块表
                    BlockTable bt = (BlockTable)trans.GetObject(db.BlockTableId, OpenMode.ForRead);
                    //打开块表记录
                    BlockTableRecord btr = (BlockTableRecord)trans.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite);
                    for (int i = 0; i < rowNum; i++)
                    {
                        for (int j = 0; j < columnNum; j++)
                        {
                            Matrix3d mt = Matrix3d.Displacement(new Vector3d(j * disColumn, i * disRow, 0));
                            Entity entA = entS.GetTransformedCopy(mt);
                            btr.AppendEntity(entA);
                            trans.AddNewlyCreatedDBObject(entA, true);
                            entList.Add(entA);
                        }
                    }
                    trans.Commit();
                }
                return entList; 
            }
            else
            {
               return entS.ArrayRectEntity(rowNum, columnNum, disRow, disColumn);
            }
        }

        public static List<Entity> ArrayPolarEntity(this ObjectId entId, int num, double degree,Point3d center)
        {
            //声明一个List集合,用于返回
            List<Entity> entList = new List<Entity>();
            //打开事务处理
            using (Transaction trans = entId.Database.TransactionManager.StartTransaction())
            {
                //打开块表
                BlockTable bt = (BlockTable)trans.GetObject(entId.Database.BlockTableId, OpenMode.ForRead);
                //打开块表记录
                BlockTableRecord btr = (BlockTableRecord)trans.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite);
                Entity ent = (Entity)entId.GetObject(OpenMode.ForWrite);
                //限定阵列角度的大小
                degree = degree > 360 ? 360 : degree;
                degree = degree < -360 ? -360 : degree;
                int divAngNum = num-1;
                if (degree == 360 || degree == -360)
                {
                    divAngNum = num;
                }
                for (int i = 0; i < num; i++)
                {
                    Matrix3d mt = Matrix3d.Rotation((i * degree / divAngNum).DegreeToAngle(), Vector3d.ZAxis, center);
                    Entity entA = ent.GetTransformedCopy(mt);
                    btr.AppendEntity(entA);
                    trans.AddNewlyCreatedDBObject(entA, true);
                    entList.Add(entA);
                }
                ent.Erase();
                trans.Commit();
            }
            return entList;
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="ent"></param>
        /// <param name="num"></param>
        /// <param name="degree"></param>
        /// <param name="center"></param>
        /// <returns></returns>
        public static List<Entity> ArrayPolarEntity(this Entity ent, int num, double degree, Point3d center)
        {
            if (ent.IsNewObject == true)
            {
                //声明一个List集合,用于返回
                List<Entity> entList = new List<Entity>();
                Database db = HostApplicationServices.WorkingDatabase;
                using (Transaction trans = db.TransactionManager.StartTransaction())
                {
                    //打开块表
                    BlockTable bt = (BlockTable)trans.GetObject(db.BlockTableId, OpenMode.ForRead);
                    //打开块表记录
                    BlockTableRecord btr = (BlockTableRecord)trans.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite);
                    degree = degree > 360 ? 360 : degree;
                    degree = degree < -360 ? -360 : degree;
                    int divAngNum = num - 1;
                    if (degree == 360 || degree == -360)
                    {
                        divAngNum = num;
                    }
                    for (int i = 0; i < num; i++)
                    {
                        Matrix3d mt = Matrix3d.Rotation((i * degree / divAngNum).DegreeToAngle(), Vector3d.ZAxis, center);
                        Entity entA = ent.GetTransformedCopy(mt);
                        btr.AppendEntity(entA);
                        trans.AddNewlyCreatedDBObject(entA, true);
                        entList.Add(entA);
                    }
                    trans.Commit();
                }
                return entList;
            }
            else
            {
               return ent.ObjectId.ArrayPolarEntity(num, degree, center);
            }
        }
    }
}

改变图形颜色

       [CommandMethod("EditDemo")]
       public void EditDemo()
       {
           Database db = HostApplicationServices.WorkingDatabase;
           //db.AddCircleModelSpace(new Point3d(100, 100, 0), 50);
           Circle c1 = new Circle(new Point3d(100, 100, 0), new Vector3d(0, 0, 1), 50);
           Circle c2 = new Circle(new Point3d(200, 100, 0), new Vector3d(0, 0, 1), 50);

           db.AddEntityToModelSpace(c1);

           c1.ChangeEntityColor(1);
           c2.ChangeEntityColor(6);

           db.AddEntityToModelSpace(c2);

       }

在这里插入图片描述

移动图形

 [CommandMethod("MoveDemo")]
 public void MoveDemo()
 {
     Database db = HostApplicationServices.WorkingDatabase;

     Circle c1 = new Circle(new Point3d(100, 100, 0), new Vector3d(0, 0, 1), 50);
     Circle c2 = new Circle(new Point3d(100, 100, 0), new Vector3d(0, 0, 1), 50);
     Circle c3 = new Circle(new Point3d(100, 100, 0), new Vector3d(0, 0, 1), 50);
     Point3d p1 = new Point3d(100, 100, 0);
     Point3d p2 = new Point3d(200, 300, 0);
     //c2.Center = new Point3d(c2.Center.X + p2.X - p1.X, c2.Center.Y + p2.Y - p1.Y, 0);
     //db.AddEnityToModelSpace(c1, c2);

     db.AddEnityToModelSpace(c1,c2);

     c2.MoveEntity(p1, p2);
     c3.MoveEntity(p2, p1);

     db.AddEnityToModelSpace(c3);
 }

## 复制图形

```csharp
//复制图形
[CommandMethod("CopyDemo")]
public void CopyDemo()
{
    Database db = HostApplicationServices.WorkingDatabase;

    Circle c1 = new Circle(new Point3d(100, 100, 0), Vector3d.ZAxis, 100);
    Circle c2 = (Circle)c1.CopyEntity(new Point3d(100, 100, 0), new Point3d(100, 200, 0));
    db.AddEnityToModelSpace(c1,c2);
    Circle c3 = (Circle)c1.CopyEntity(new Point3d(0, 0, 0), new Point3d(-100, 0, 0));
    db.AddEnityToModelSpace(c3);
}

旋转图形

//旋转图形
[CommandMethod("RotateDemo")]
public void RotateDemo()
{
    Database db = HostApplicationServices.WorkingDatabase;

    Line l1 = new Line(new Point3d(100, 100, 0), new Point3d(300, 100, 0));
    Line l2 = new Line(new Point3d(100, 100, 0), new Point3d(300, 100, 0));
    Line l3 = new Line(new Point3d(100, 100, 0), new Point3d(300, 100, 0));
    
    l1.RotateEntity(new Point3d(100, 100, 0), 30);
    db.AddEnityToModelSpace(l1,l2,l3);
    l2.RotateEntity(new Point3d(0, 0, 0), 60);

    l3.RotateEntity(new Point3d(200, 500, 0), 90);
}

镜像图形

[CommandMethod("MirrorDemo1")]
public void MirrorDemo1()
{
    Database db = HostApplicationServices.WorkingDatabase;
    Circle c1 = new Circle(new Point3d(100, 100, 0), Vector3d.ZAxis, 50);
    ObjectId cId =  db.AddEnityToModelSpace(c1);

    Entity Ent = cId.MirrorEntity(new Point3d(200, 100, 0), new Point3d(200, 300, 0), true);
    db.AddEnityToModelSpace(Ent);

    Circle c2 = new Circle(new Point3d(100, 200, 0), Vector3d.ZAxis, 50);
    Entity ent2 = c2.MirrorEntity(new Point3d(200, 100, 0), new Point3d(200, 300, 0), true);
    //Entity ent3 = c2.MirrorEntity(new Point3d(200, 100, 0), new Point3d(200, 300, 0), false);
    db.AddEnityToModelSpace(c2,ent2);
}

缩放图形

        [CommandMethod("ScaleDemo")]
        public void ScaleDemo()
        {
            Database db = HostApplicationServices.WorkingDatabase;
            Circle c1 = new Circle(new Point3d(100, 100, 0), Vector3d.ZAxis, 50);
            db.AddEnityToModelSpace(c1);
            Circle c2 = new Circle(new Point3d(200, 100, 0), Vector3d.ZAxis, 50);
            c2.ScaleEntity(new Point3d(200, 100, 0), 0.5);
            db.AddEnityToModelSpace(c2);
            Circle c3 = new Circle(new Point3d(300, 100, 0), Vector3d.ZAxis, 50);
            db.AddEnityToModelSpace(c3);
            c3.ScaleEntity(new Point3d(0, 0, 0), 2);
        }

删除图形对象

[CommandMethod("EraseDemo")]
public void EraseDemo()
{
    Database db = HostApplicationServices.WorkingDatabase;
    Circle c1 = new Circle(new Point3d(100, 100, 0), Vector3d.ZAxis, 50);
    Circle c2 = new Circle(new Point3d(200, 100, 0), Vector3d.ZAxis, 50);
    db.AddEnityToModelSpace(c1, c2);
    c2.ObjectId.EraseEntity();
}

矩形阵列图形

        [CommandMethod("ArrayRectDemo1")]
        public void ArrayRectDemo1()
        {
            Database db = HostApplicationServices.WorkingDatabase;
            //ObjectId cirId = db.AddCircleModelSpace(new Point3d(100, 100, 0), 20);

            //cirId.ArrayRectEntity(5, 6, -50, -50);

            Circle c = new Circle(new Point3d(100, 100, 0), Vector3d.ZAxis, 10);

            c.ArrayRectEntity(5, 6, -50, 50);
        }

环形阵列图形

[CommandMethod("ArrayPolarDemo")]
public void ArrayPolarDemo()
{
    Database db = HostApplicationServices.WorkingDatabase;
    //ObjectId lineId = db.AddLineToModelSpace(new Point3d(100, 100, 0), new Point3d(120, 100, 0));
    //lineId.ArrayPolarEntity(6, 360, new Point3d(100, 200, 0));

    //ObjectId lineId2 = db.AddLineToModelSpace(new Point3d(500, 100, 0), new Point3d(520, 100, 0));
    //lineId2.ArrayPolarEntity(6, 350, new Point3d(500, 200, 0));

    //ObjectId lineId3 = db.AddLineToModelSpace(new Point3d(1000, 100, 0), new Point3d(1020, 100, 0));
    //lineId3.ArrayPolarEntity(6, -350, new Point3d(1000, 200, 0));
    Line l = new Line(new Point3d(100, 100, 0), new Point3d(120, 120, 0));
    l.ArrayPolarEntity(7, -270, new Point3d(110, 300, 0));
}
技术闲聊DD
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C#之CAD二次开发(7) 图形编辑
yzk1062913581的博客
03-24 2203
# 0. 引言 学习了如何创建图形后，需要分析如何对图形进一步操作，如：颜色改变、移动、复制、旋转、镜像、删除等，这些都是一些基本操作。 还是同样的配方，我们将这些操作都封装成一个一个的方法，以后需要的时候调用即可！ # 1. 封装 这里需要说明的是，对图形操作如改变颜色、移动、复制等这些操作需要分为图形是否已经添加到图形数据库中，也就是图形是不是新创建的。 用代码说话...
cad二次开发 java_应用Java语言进行AutoCAD2000二次开发.PDF
weixin_28736335的博客
02-13 1034
应用Java语言进行AutoCAD2000二次开发实用第一 智慧密集刘良华袁英战朱东海摘 要介绍了应用Java语言进行AutoCAD二次开发的方法和思路。关键字 二次开发，AutoCAD定制，COM，Java编程Mic Mod- ...
【CAD二次开发】-ObjectARX-双击实体的响应 (AcDbDoubleClickEdit)
渲染引擎开发
09-19 4514
思路： 一、基本双击响应实现 （1）在vs2015中使用ObjectARX创建一个新项目DoubleClick,并选择 MFC支持。 向工程中添加一个普通类CDoubleClickCircle，它的基类设置为AcDbDoubleClickEdit: 类的头文件为： class CDoubleClickCircle : public AcDbDoubleClick...
CAD二次开发-C#项目创建
qq_37120714的博客
10-11 985
对通用图形软件AutoCAD 的二次开发方法有一下四中： （1）通过数据文件共享开发。 （2）通过对CAD的用户化开发。 （3）通过对AutoCAD提供的嵌入式语言AutoCisp开发。 （4）通过AutoCAD提供的C语言开发系统进行ADS应用程序开发。 创建C#项目 引用的动态库 1.accoremgd.dll //没有找到 2.AcCui.dll 3.acdbmgd.dll 4.acmgd....
Python 二次开发 AutoCAD 简介
热门推荐
Hulunbuir
03-05 13万+
一、前沿 cad是 python是 Active X 是 pyautocad模块由俄罗斯工程师开发，因参考实例较少，工程需要，现将模块中一些基本的用法，做出简要说明，叙述力求简洁明了， 因个人水平有限，文中难免有所疏漏，还请各位大神不吝批评指正。 ...
AUTOCAD二次开发
最新发布
hohoyu的专栏
08-23 796
如果换成以下这样也不行。
C#之CAD二次开发(8) 图形阵列
yzk1062913581的博客
04-15 1554
0. 引言 我一直认为想要去深入了解一个东西，最好办法就行先去模仿他，然后再去改进！ 这就是为什么到目前一直在重复CAD里面的基础动作，如果连这些基础的都没有搞懂，就想着去改进他，那就显得过于急功近利了。 废话不说，Let's do it！ CAD里面的阵列分为三种： 矩形阵列 环形阵列 路径阵列 说到底阵列的实质就是复制和旋转图形，跟前面一样计算其变换矩阵，无非就是角度和距...
cad二次开发 java_基于.NET的CAD二次开发学习笔记一：CAD开发入门
weixin_42174098的博客
02-23 918
1、AutoCAD .NET API由不同的DLL文件组成，它们提供用于访问图形文件或AutoCAD应用程序的包含丰富的类、结构、方法和事件。每一个DLL文件都定义不同的使用基于功能的库组织组件的命名空间。下面是你将频繁地要使用的AutoCAD .NET API 的三个主要的DLL文件:AcDbMgd.dll. 当使用图形文件中的对象时使用这个DLL文件。AcMgd.dll. 当使用AutoCAD...
基于Python的FreeCAD二次开发
qq_27353621的博客
11-12 2458
基于Python的FreeCAD二次开发
objectARX二次开发：创建和编辑基本图形对象
07-21
objectARX二次开发采用VS2019+ arx2021搭建环境，编辑的arx文件用于AutoCAD2021使用；搭建好环境后源码用vs2019打开可直接运行，基本图形包括：直线、二点创建圆、三点创建圆、三种方法创建圆弧、创建正多边形、创建...
AutoCAD .NET二次开发基础-2012版（英文资料翻译）
12-18
Autocad 二次开发的书籍，基于C#语言非常好的一本Autocad 二次开发的书籍。主要内容包括AutoCAD.NET API 介绍、使用AutoCAD.NET API 控制AutoCAD工作环境、创建 及编辑AutoCAD实体、创建和编辑尺寸标注、3D 图形处理...
Cad二次开发图形小工具
03-26
Cad二次开发编辑图形小工具...
CAD-VBA开发人员手册.pdf
07-31
VBA 开发人员手册，作者：解祥成。 目 录 第 1 章、VBA入门.......................................... 3 1 、了解嵌入和全局VBA工程 2、用VBA管理器组织工程 3、处理宏 4、用VBA IDE编辑工程 5、更多的信息 6、...
Visual Basic与AutoCAD二次开发
03-20
这本教程基本可以解决大部分的开发问题，对cad软件的链接，选择集的创建及过滤机制写的很清楚，图形编辑非常方便，值得下载
利用java在excel中读取和写入数据
一个人的江湖
06-02 4万+
在处理excel数据时候有两种方式： 一种是首先依据excel中的数据创建一个相应的实体类，将每一条数据视为一个对象，然后将对excel中的数据处理转成对对象的处理。 一种是将每一条数据视为一个集合或者数组，然后再将整个数据视为一个整体。 这里推荐使用第一种方式 。但是我现在用第二种尝试一下。 这是要用的excel数据 要用到的jar包 首先说一下数据处理需求： ...
Spring Security的工作原理
一个人的江湖
08-24 1万+
1 结构总览 Spring Security所解决的问题就是安全访问控制，而安全访问控制功能其实就是对所有进入系统的请求进行拦截， 校验每个请求是否能够访问它所期望的资源。而Spring Security对Web资源的保护是靠Filter实现的。当初始化Spring Security时，会创建一个名为 springSecurityFilterChain 的Servlet过滤器，类型为org.springframework.security.web.FilterChainProxy，它实现了javax.ser
springboot的配置和SpringBoot+Jsp整合
一个人的江湖
10-25 9317
1 springboot的自动配置 springboot会通过maven依赖找到相对应的jar包和嵌入的服务器，然后使用默认的自动配置类来创建默认的开发环境。 2 springboot的自定义配置 3 开发自己的springboot项目 如果我们需要修改springmvc的视图解析器（viewResolver），springmvc的主要作用就是用来定位视图的，也就是说当控制器返回一个逻辑名称，然...
多线程之线程通信wait和notify的使用
一个人的江湖
06-20 8541
线程通信
cad二次开发人员手册
07-20
此外，手册还会详细介绍CAD二次开发中常用的功能模块，如图形处理、对象操作、数据管理等，并给出相应的开发实例和案例，帮助开发人员理解和掌握实际开发中的技术难点和解决方法。同时，手册还会介绍CAD二次开发中的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

技术闲聊DD

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值