CAD二次开发（3）-图形绘制

技术闲聊DD

于 2024-05-25 18:29:02 发布

阅读量147

点赞数 3

分类专栏：后台文章标签： oracle 数据库

本文链接：https://blog.csdn.net/wu2374633583/article/details/139198080

版权

后台专栏收录该内容

87 篇文章 3 订阅

订阅专栏

1. 圆弧绘制

工具类：AddEntityTool

/// <summary>
/// 绘制圆弧
/// </summary>
/// <param name="db">图形数据库</param>
/// <param name="center">圆弧所在圆的圆心点</param>
/// <param name="radius">圆弧的半径</param>
/// <param name="startDegree">圆弧的起始角度</param>
/// <param name="endDegree">圆弧的终止角度</param>
/// <returns>ObjectId</returns>
public static ObjectId AddArcToModelSpace(this Database db, Point3d center, double radius, double startDegree, double endDegree)
{
    return db.AddEntityToModelSpace(new Arc(center, radius, startDegree.DegreeToAngle(), endDegree.DegreeToAngle()));
}

/// <summary>
/// 通过三点创建圆弧
/// </summary>
/// <param name="db">图形数据库</param>
/// <param name="startPoint">起点</param>
/// <param name="pointOnArc">圆弧上的点</param>
/// <param name="endPoint">终点</param>
/// <returns></returns>
public static ObjectId AddArcToModelSpace(this Database db, Point3d startPoint, Point3d pointOnArc, Point3d endPoint)
{
    //先判断三点是否在同一条直线上
    if (startPoint.IsOnOneLine(pointOnArc, endPoint))
    {
        return ObjectId.Null;
    }

    //创建几何类对象
    CircularArc3d cArc = new CircularArc3d(startPoint, pointOnArc, endPoint);
    //通过几何类对象获取其属性
    //double radius = cArc.Radius; //半径
    //Point3d center = cArc.Center; //所在圆的圆心
    //Vector3d cs = center.GetVectorTo(startPoint); //圆心到起点的向量
    //Vector3d ce = center.GetVectorTo(endPoint);   //圆心到终点的向量
    //Vector3d xVector = new Vector3d(1, 0, 0); //X正方向的向量
    圆弧的起始角度
    //double startAngle = cs.Y > 0 ? xVector.GetAngleTo(cs) : -xVector.GetAngleTo(cs);
    圆弧的终止角度
    //double endAngle = ce.Y > 0 ? xVector.GetAngleTo(ce) : -xVector.GetAngleTo(ce);

    //创建圆弧对象
    Arc arc = new Arc(cArc.Center, cArc.Radius, cArc.Center.GetAngleToXAxis(startPoint), cArc.Center.GetAngleToXAxis(endPoint));
    //加入图形数据库
    return db.AddEntityToModelSpace(arc);
}
/// <summary>
/// 通过圆心、起点，夹角绘制圆弧
/// </summary>
/// <param name="db">图形数据库</param>
/// <param name="center">圆心</param>
/// <param name="startPoint">起点</param>
/// <param name="degree">夹角,角度值</param>
/// <returns>ObjectId</returns>
public static ObjectId AddArcToModelSpace(this Database db, Point3d center, Point3d startPoint, double degree)
{
    //获取半径
    double radius = center.GetDistanceBetweenTwoPoint(startPoint);
    //获取起点角度
    double startAngle = center.GetAngleToXAxis(startPoint);
    //声明圆弧对象
    Arc arc = new Arc(center, radius, startAngle, startAngle + degree.DegreeToAngle());
    return db.AddEntityToModelSpace(arc);

}

工具类：BaseTool

 /// <summary>
 /// 判断三点是否在同一条直线上
 /// </summary>
 /// <param name="firstPoint">第一个点</param>
 /// <param name="secondPoint">第二个点</param>
 /// <param name="thirdPoint">第三个点</param>
 /// <returns></returns>
 public static bool IsOnOneLine(this Point3d firstPoint, Point3d secondPoint, Point3d thirdPoint)
 {
     Vector3d v21 = secondPoint.GetVectorTo(firstPoint);
     Vector3d v23 = secondPoint.GetVectorTo(thirdPoint);
     if (v21.GetAngleTo(v23) == 0 || v21.GetAngleTo(v23) == Math.PI)
     {
         return true;
     }
     else
     {
         return false;
     }
 }

 public static double GetAngleToXAxis(this Point3d startPoint, Point3d endPoint)
 {
     //声明一个与X轴平行的向量
     Vector3d temp = new Vector3d(1, 0, 0);
     //获取起点到终点的向量
     Vector3d VsToe = startPoint.GetVectorTo(endPoint);
     return VsToe.Y > 0 ? temp.GetAngleTo(VsToe) : -temp.GetAngleTo(VsToe);
 }
 /// <summary>
 /// 获取两点之间的距离
 /// </summary>
 /// <param name="point1"></param>
 /// <param name="point2"></param>
 /// <returns></returns>
 public static double GetDistanceBetweenTwoPoint(this Point3d point1, Point3d point2)
 {
     return Math.Sqrt((point1.X - point2.X) * (point1.X - point2.X) + (point1.Y - point2.Y) * (point1.Y - point2.Y) + (point1.Z - point2.Z) * (point1.Z - point2.Z));

 }
 /// <summary>
 /// 获取两点的中心点
 /// </summary>
 /// <param name="Point1">第一个点</param>
 /// <param name="point2">第二个点</param>
 /// <returns>中心点</returns>
 public static Point3d GetCenterPointBetweenTwoPoint(this Point3d Point1, Point3d point2)
 {
     return new Point3d((Point1.X + point2.X) / 2, (Point1.Y + point2.Y) / 2, (Point1.Z + point2.Z) / 2);
 }

测试

        /// <summary>
        /// 圆弧的画法
        /// </summary>
        [CommandMethod("ArcDemo")]
        public void ArcDemo()
        {
            /// 圆心 角度 半径画圆弧法
            Arc arc1 = new Arc();
            //设置圆弧圆心
            arc1.Center = new Point3d(300, 300, 300);
            //设置起始角度
            arc1.StartAngle = -Math.PI / 4;
            //设置结束角度
            arc1.EndAngle = Math.PI / 4;
            //设置半径
            arc1.Radius = 100;
            double startAngle = 45;
            Arc arc2 = new Arc(new Point3d(500, 500, 500), 200, startAngle.AngleToDegree(), 900);
            Arc arc3 = new Arc(new Point3d(700, 700, 0), new Vector3d(0, 0, 1), 20, Math.PI / 4, Math.PI / 2);
            Database db = HostApplicationServices.WorkingDatabase;
            db.AddEntityToModelSpace(arc1, arc2, arc3);
            db.AddArcToModelSpace(new Point3d(800, 800, 0), 500, 300, 270);

            ///三点画弧法
            //起始点
            Point3d startPoint = new Point3d(100, 100, 0);
            //结束点
            Point3d endPoint = new Point3d(200, 200, 0);
            //圆心
            Point3d pointOnArc = new Point3d(150, 100, 0);
            CircularArc3d cArc = new CircularArc3d(startPoint,pointOnArc,endPoint);

/*            double radius = cArc.Radius;
            Point3d center = cArc.Center;
            Vector3d cs = center.GetVectorTo(startPoint);
            Vector3d ce = center.GetVectorTo(endPoint);
            Vector3d xvector = new Vector3d(1,0,0);

            double startAngle = cs.Y > 0 ? xvector.GetAngleTo(cs) : -xvector.GetAngleTo(cs);
            double endAngle = ce.Y > 0 ? xvector.GetAngleTo(ce) : -xvector.GetAngleTo(ce);
            Arc arc = new Arc(center, radius, startAngle, endAngle);
            db.AddEntityToModelSpace(arc);
            Point3d startPoint = new Point3d(100, 100, 0);
            Point3d endPoint = new Point3d(200, 200, 0);
            Point3d pointOnArc = new Point3d(150, 100, 0);
            db.AddArcToModelSpace(startPoint, pointOnArc, endPoint);

            startPoint = new Point3d(100, 100, 0);
            endPoint = new Point3d(200, 200, 0);
            pointOnArc = new Point3d(150, 150, 0);
            db.AddArcToModelSpace(startPoint, pointOnArc, endPoint);
            Point3d center = new Point3d(125, 175, 0);
            Point3d startPoint = new Point3d(100, 100, 0);
            db.AddArcToModelSpace(center, startPoint, 135);
            Point3d point = new Point3d(200, 400, 0);
            double sAngle = center.GetAngleToXAxis(startPoint);
            double eAngle = center.GetAngleToXAxis(point);
            double r = startPoint.GetDistanceBetweenTwoPoint(center);
            Arc arc = new Arc(center, r, sAngle, eAngle);
            db.AddEntityToModelSpace(arc);*/

        }

2. 圆绘制

工具类：BaseTool

 /// <summary>
 /// 绘制圆
 /// </summary>
 /// <param name="db">图形据据库</param>
 /// <param name="center">圆心</param>
 /// <param name="radius">半径</param>
 /// <returns>ObjectId</returns>
 public static ObjectId AddCircleModelSpace(this Database db, Point3d center, double radius)
 {
     return db.AddEntityToModelSpace(new Circle(center, new Vector3d(0, 0, 1), radius));
 }
 /// <summary>
 /// 两点绘制圆
 /// </summary>
 /// <param name="db">图形数据库</param>
 /// <param name="point1">第一个点</param>
 /// <param name="point2">第二个点</param>
 /// <returns>ObjectId</returns>
 public static ObjectId AddCircleModelSpace(this Database db, Point3d point1, Point3d point2)
 {
     //获取中心点
     Point3d center = point1.GetCenterPointBetweenTwoPoint(point2);
     //获取半径
     double radius = point1.GetDistanceBetweenTwoPoint(center);
     return db.AddCircleModelSpace(center, radius);
 }
 /// <summary>
 /// 三点绘制圆
 /// </summary>
 ///<param name="db">图形数据库</param>
 /// <param name="point1">第一个点</param>
 /// <param name="point2">第二个点</param>
 /// <param name="point3">第三个点</param>
 /// <returns>ObjectId</returns>
 public static ObjectId AddCircleModelSpace(this Database db, Point3d point1, Point3d point2, Point3d point3)
 {
     //先判断三点是否在同一条直线上
     if (point1.IsOnOneLine(point2, point3))
     {
         return ObjectId.Null;
     }
     //声明几何类的CircularArc3d对象
     CircularArc3d cArc = new CircularArc3d(point1, point2, point3);
     return db.AddCircleModelSpace(cArc.Center, cArc.Radius);
 }

测试类

 [CommandMethod("CircleDemo")]
 public void CircleDemo()
 {
     //Circle c1 = new Circle();
     //c1.Center = new Point3d(50, 50, 0);
     //c1.Radius = 50;
     //Circle c2 = new Circle(new Point3d(100, 100, 0), new Vector3d(0, 0, 1), 50);
     Database db = HostApplicationServices.WorkingDatabase;
     //db.AddEnityToModelSpace(c1, c2);
     //圆心半径
     db.AddCircleModelSpace(new Point3d(100, 100, 0), 100);
     //两点
     db.AddCircleModelSpace(new Point3d(200, 100, 0), new Point3d(300, 100, 0));
     //三点
     db.AddCircleModelSpace(new Point3d(400, 100, 0), new Point3d(600, 100, 0), new Point3d(600, 200, 0));
 }

3. 多段线绘制

工具类：BaseTool

/// <summary>
/// 绘制折线多段线
/// </summary>
/// <param name="db">图形数据库</param>
/// <param name="isClosed">是否闭合</param>
/// <param name="constantWidth">线宽</param>
/// <param name="vertices">多段线的定点,可变参数</param>
/// <returns>ObjectId</returns>
public static ObjectId AddPolyLineToModelSpace(this Database db, bool isClosed, double constantWidth, params Point2d[] vertices)
{
    if (vertices.Length < 2)
    {
        return ObjectId.Null;
    }
    //声明一个多段线对象
    Polyline pLine = new Polyline();
    //添加多段线的顶点
    for (int i = 0; i < vertices.Length; i++)
    {
        pLine.AddVertexAt(i, vertices[i], 0, 0, 0);
    }
    //判断是否闭合
    if (isClosed)
    {
        pLine.Closed = true;
    }
    //设置多段线的线宽
    pLine.ConstantWidth = constantWidth;
    return db.AddEntityToModelSpace(pLine);
}

测试

 [CommandMethod("PolyLineDemo")]
 public void PolyLineDemo()
 {

     //Polyline pl = new Polyline();
     三个点位置
     //Point2d p1 = new Point2d(100, 100);
     //Point2d p2 = new Point2d(200, 100);
     //Point2d p3 = new Point2d(200, 200);
     添加为顶点
     //pl.AddVertexAt(0, p1, 0, 0, 0);
     //pl.AddVertexAt(1, p2, 0, 0, 0);
     //pl.AddVertexAt(2, p3, 0, 0, 0);
     闭合 首尾相交
     //pl.Closed = true;
     线条宽度
     //pl.ConstantWidth = 50;
     //Database db = HostApplicationServices.WorkingDatabase;
     //db.AddEntityToModelSpace(pl);


     //Database db = HostApplicationServices.WorkingDatabase;
     //db.AddPolyLineToModelSpace(false, 0, new Point2d(10, 10), new Point2d(50, 10), new Point2d(100, 20));
     //db.AddPolyLineToModelSpace(true, 0, new Point2d(10, 50), new Point2d(50, 50), new Point2d(100, 70));


     //Polyline pLine = new Polyline();
     //Polyline pLine2 = new Polyline();
     //Polyline pLine3 = new Polyline();
     //Point2d p1 = new Point2d(100, 100);
     //Point2d p2 = new Point2d(100, 200);
     //pLine.AddVertexAt(0, p1, 1, 0, 0);
     //pLine.AddVertexAt(1, p2, 0, 0, 0);
     //pLine2.AddVertexAt(0, p1, 0.5, 0, 0);
     //pLine2.AddVertexAt(1, p2, 0, 0, 0);
     //pLine3.AddVertexAt(0, p1, 6, 0, 0);
     //pLine3.AddVertexAt(1, p2, 0, 0, 0);
     //Database db = HostApplicationServices.WorkingDatabase;
     //db.AddEntityToModelSpace(pLine,pLine2,pLine3);


     //Polyline pline = new Polyline();
     //Point2d p1 = new Point2d(100, 100);
     //Point2d p2 = new Point2d(500, 100);
     //Point2d p3 = new Point2d(500, 200);
     //Point2d p4 = new Point2d(100, 200);
     //pline.AddVertexAt(0, p1, 0, 0, 0);
     //pline.AddVertexAt(1, p2, 1, 0, 0);
     //pline.AddVertexAt(2, p3, 0, 0, 0);
     //pline.AddVertexAt(3, p4, 1, 0, 0);
     //pline.Closed = true;
     //Database db = HostApplicationServices.WorkingDatabase;
     //db.AddEntityToModelSpace(pline);

     Database db = HostApplicationServices.WorkingDatabase;
     db.AddRectToModelSpace(new Point2d(0, 0), new Point2d(100, 100));
     db.AddRectToModelSpace(new Point2d(200, 200), new Point2d(100, 100));
     db.AddRectToModelSpace(new Point2d(500, 500), new Point2d(100, 100));
     db.AddPolygonToModelSpace(new Point2d(100, 100), 50, 3, 90);
     db.AddPolygonToModelSpace(new Point2d(200, 100), 50, 4, 45);
     db.AddPolygonToModelSpace(new Point2d(300, 100), 50, 5, 90);
     db.AddPolygonToModelSpace(new Point2d(400, 100), 50, 6, 0);
     db.AddPolygonToModelSpace(new Point2d(500, 100), 50, 12, 0);

 }

4. 矩形-多边形绘制

工具类：BaseTool

 /// <summary>
 /// 绘制矩形
 /// </summary>
 /// <param name="db">图形数据库</param>
 /// <param name="point1">第一个点</param>
 /// <param name="point2">对角点</param>
 /// <returns>ObjectId</returns>
 public static ObjectId AddRectToModelSpace(this Database db, Point2d point1, Point2d point2)
 {
     //声明多段线
     Polyline pLine = new Polyline();
     //计算矩形的四个顶点坐标
     Point2d p1 = new Point2d(Math.Min(point1.X, point2.X), Math.Min(point1.Y, point2.Y));
     Point2d p2 = new Point2d(Math.Max(point1.X, point2.X), Math.Min(point1.Y, point2.Y));
     Point2d p3 = new Point2d(Math.Max(point1.X, point2.X), Math.Max(point1.Y, point2.Y));
     Point2d p4 = new Point2d(Math.Min(point1.X, point2.X), Math.Max(point1.Y, point2.Y));
     //添加多段线的顶点
     pLine.AddVertexAt(0, p1, 0, 0, 0);
     pLine.AddVertexAt(0, p2, 0, 0, 0);
     pLine.AddVertexAt(0, p3, 0, 0, 0);
     pLine.AddVertexAt(0, p4, 0, 0, 0);
     //闭合多段线
     pLine.Closed = true;
     return db.AddEntityToModelSpace(pLine);
 }

 /// <summary>
 /// 绘制内接正多边形
 /// </summary>
 /// <param name="db">图形数据库</param>
 /// <param name="center">多边形所在圆的圆心</param>
 /// <param name="radius">所在圆的半径</param>
 /// <param name="sideNum">边数</param>
 /// <param name="startDegree">起始角度</param>
 /// <returns>ObjectId</returns>
 public static ObjectId AddPolygonToModelSpace(this Database db, Point2d center, double radius, int sideNum, double startDegree)
 {
     //声明多段线对象
     Polyline pLine = new Polyline();
     //判断边数是否符合要求
     if (sideNum < 3)
     {
         return ObjectId.Null;
     }
     Point2d[] point = new Point2d[sideNum];
     double angle = startDegree.DegreeToAngle();
     //计算每个顶点的坐标
     for (int i = 0; i < sideNum; i++)
     {
         point[i] = new Point2d(center.X + radius * Math.Cos(angle), center.Y + radius * Math.Sin(angle));
         pLine.AddVertexAt(i, point[i], 0, 0, 0);
         angle += Math.PI * 2 / sideNum;
     }
     //闭合多段线
     pLine.Closed = true;
     return db.AddEntityToModelSpace(pLine);
 }

5. 椭圆绘制

工具类：BaseTool

 /// <summary>
 /// 绘制椭圆
 /// </summary>
 /// <param name="db">图形数据库</param>
 /// <param name="center">椭圆中心</param>
 /// <param name="majorRadius">长轴长度</param>
 /// <param name="shortRadius">短轴长度</param>
 /// <param name="degere">长轴与X轴夹角,角度值</param>
 /// <param name="startDegree">起始角度</param>
 /// <param name="endDegree">终止角度</param>
 /// <returns>ObjectId</returns>
 public static ObjectId AddEllipseToModelSpace(this Database db, Point3d center, double majorRadius, double shortRadius, double degere, double startDegree, double endDegree)
 {
     //计算相关参数
     double ratio = shortRadius / majorRadius;
     Vector3d majorAxis = new Vector3d(majorRadius * Math.Cos(degere.DegreeToAngle()), majorRadius * Math.Sin(degere.DegreeToAngle()), 0);
     //(new Point3d(100, 100, 0), Vector3d.ZAxis, new Vector3d(100, 0, 0), 0.4, 0, 2*Math.PI);
     //声明椭圆对象
     Ellipse elli = new Ellipse(center, Vector3d.ZAxis, majorAxis, ratio, startDegree.DegreeToAngle(), endDegree.DegreeToAngle());
     return db.AddEntityToModelSpace(elli);
 }
 /// <summary>
 /// 绘制椭圆
 /// </summary>
 /// <param name="db">图形数据库</param>
 /// <param name="majorPoint1">长轴端点1</param>
 /// <param name="majorPoint2">长轴端点2</param>
 /// <param name="shortRadius">短轴的长度</param>
 /// <returns>ObjectId</returns>
 public static ObjectId AddEllipseToModelSpace(this Database db, Point3d majorPoint1, Point3d majorPoint2, double shortRadius)
 {
     //椭圆的圆心
     Point3d center = majorPoint1.GetCenterPointBetweenTwoPoint(majorPoint2);
     //短轴与长轴的比
     double ratio = 2 * shortRadius / majorPoint1.GetDistanceBetweenTwoPoint(majorPoint2);
     //长轴的向量
     Vector3d majorAxis = majorPoint2.GetVectorTo(center);
     Ellipse elli = new Ellipse(center, Vector3d.ZAxis, majorAxis, ratio, 0, 2 * Math.PI);

     return db.AddEntityToModelSpace(elli);
 }
 /// <summary>
 /// 绘制椭圆
 /// </summary>
 /// <param name="db">图形数据库</param>
 /// <param name="point1">所在矩形的顶点1</param>
 /// <param name="point2">所在矩形的顶点1</param>
 /// <returns>ObjectId</returns>
 public static ObjectId AddEllipseToModelSpace(this Database db, Point3d point1, Point3d point2)
 {
     //椭圆的圆心
     Point3d center = point1.GetCenterPointBetweenTwoPoint(point2);
     double ratio = Math.Abs((point1.Y - point2.Y) / (point1.X - point2.X));
     Vector3d majorVector = new Vector3d(Math.Abs((point1.X - point2.X)) / 2, 0, 0);
     //声明椭圆对象
     Ellipse elli = new Ellipse(center, Vector3d.ZAxis, majorVector, ratio, 0, 2 * Math.PI);
     return db.AddEntityToModelSpace(elli);
 }

6. 图案填充

在这里插入图片描述

6.1 填充图案举例

        /// <summary>
        /// 图案填充
        /// </summary>
        [CommandMethod("HatchDemo")]
        public void HatchDemo()
        {

            //图案填充
            Database db = HostApplicationServices.WorkingDatabase;
            ObjectId cId = db.AddCircleModelSpace(new Point3d(100, 100, 0), 100);
            ObjectIdCollection obIds = new ObjectIdCollection();
            obIds.Add(cId);
            using (Transaction trans = db.TransactionManager.StartTransaction())
            {
                //声明图案填充对象
                Hatch hatch = new Hatch();
                //设置填充比例
                hatch.PatternScale = 5;
                //设置填充类型和图案名
                hatch.SetHatchPattern(HatchPatternType.PreDefined, "ANGLE");
                //加入图形数据库
                BlockTable bt = (BlockTable)trans.GetObject(db.BlockTableId, OpenMode.ForRead);
                BlockTableRecord btr = (BlockTableRecord)trans.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite);
                btr.AppendEntity(hatch);
                trans.AddNewlyCreatedDBObject(hatch, true);

                //设置填充角度
                hatch.PatternAngle = Math.PI / 4;
                //设置关联
                hatch.Associative = true;
                //设置边界图形和填充方式
                hatch.AppendLoop(HatchLoopTypes.Outermost, obIds);
                //计算填充并显示
                hatch.EvaluateHatch(true);
                //提交事务
                trans.Commit();
            }
        }

在这里插入图片描述

6.2 填充工具类

HatchTool.cs

using Autodesk.AutoCAD.Colors;
using Autodesk.AutoCAD.DatabaseServices;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _02创建图形
{
    public static partial class HatchTool
    {

        /// <summary>
        /// 填充图案名称
        /// </summary>
        public struct HatchPatternName
        {
            public static readonly string solid = "SOLID";
            public static readonly string angle = "ANGLE";
            public static readonly string ansi31 = "ANSI31";
            public static readonly string ansi32 = "ANSI32";
            public static readonly string ansi33 = "ANSI33";
            public static readonly string ansi34 = "ANSI34";
            public static readonly string ansi35 = "ANSI35";
            public static readonly string ansi36 = "ANSI36";
            public static readonly string ansi37 = "ANSI37";
            public static readonly string ansi38 = "ANSI37";
            public static readonly string arb816 = "AR-B816";
            public static readonly string arb816C = "AR-B816C";
            public static readonly string arb88 = "AR-B88";
            public static readonly string arbrelm = "AR-BRELM";
            public static readonly string arbrstd = "AR-BRSTD";
            public static readonly string arconc = "AR-CONC";

        }

        /// <summary>
        /// 渐变填充图案名称
        /// </summary>
        public struct HatchGradientName
        {
            public static readonly string gr_linear = "Linear";
            public static readonly string gr_cylinder = "Cylinder";
            public static readonly string gr_invcylinder = "Invcylinder";
            public static readonly string gr_spherical = "Spherical";
            public static readonly string gr_hemisperical = "Hemispherical";
            public static readonly string gr_curved = "Curved";
            public static readonly string gr_invsperical = "Invspherical";
            public static readonly string gr_invhemisperical = "Invhemispherical";
            public static readonly string gr_invcurved = "Invcurved";
        }
        /// 图案填充
        /// </summary>
        /// <param name="db">图形数据库</param>
        /// <param name="patternName">图案名称</param>
        /// <param name="scale">填充比例</param>
        /// <param name="degree">旋转角度</param>
        /// <param name="entid">边界图形的ObjectId</param>
        /// <returns>ObjectId</returns>
        public static ObjectId HatchEnity(this Database db,string patternName,double scale,double degree,ObjectId entid)
        {
            ObjectId hatchId = ObjectId.Null;
            using (Transaction trans = db.TransactionManager.StartTransaction())
            {
                //声明图案填充对象
                Hatch hatch = new Hatch();
                //设置填充比例
                hatch.PatternScale = scale;
                //设置填充类型和图案名
                hatch.SetHatchPattern(HatchPatternType.PreDefined, patternName);
                //加入图形数据库
                BlockTable bt = (BlockTable)trans.GetObject(db.BlockTableId, OpenMode.ForRead);
                BlockTableRecord btr = (BlockTableRecord)trans.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite);
                hatchId = btr.AppendEntity(hatch);
                trans.AddNewlyCreatedDBObject(hatch, true);

                //设置填充角度
                hatch.PatternAngle = degree.DegreeToAngle();
                //设置关联
                hatch.Associative = true;
                //设置边界图形和填充方式

                ObjectIdCollection obIds = new ObjectIdCollection();
                obIds.Add(entid);
                hatch.AppendLoop(HatchLoopTypes.Outermost, obIds);
                //计算填充并显示
                hatch.EvaluateHatch(true);
                //提交事务
                trans.Commit();
            }
            return hatchId;
        }
        /// <summary>
        /// 图案填充
        /// </summary>
        /// <param name="db">图形数据库</param>
        /// <param name="patternName">图案名称</param>
        /// <param name="scale">填充比例</param>
        /// <param name="degree">旋转角度</param>
        /// <param name="bkColor">背景色</param>
        /// <param name="hatchColorIndex">填充图案的颜色</param>
        /// <param name="entid">边界图形的ObjectId</param>
        /// <returns>ObjectId</returns>
        public static ObjectId HatchEnity(this Database db, string patternName, double scale, double degree,Color bkColor,int hatchColorIndex, ObjectId entid)
        {
            ObjectId hatchId = ObjectId.Null;
            using (Transaction trans = db.TransactionManager.StartTransaction())
            {
                //声明图案填充对象
                Hatch hatch = new Hatch();
                //设置填充比例
                hatch.PatternScale = scale;
                //设置背景色
                hatch.BackgroundColor = bkColor;
                //设置填充图案的颜色
                hatch.ColorIndex = hatchColorIndex;
                //设置填充类型和图案名
                hatch.SetHatchPattern(HatchPatternType.PreDefined, patternName);
                //加入图形数据库
                BlockTable bt = (BlockTable)trans.GetObject(db.BlockTableId, OpenMode.ForRead);
                BlockTableRecord btr = (BlockTableRecord)trans.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite);
                hatchId = btr.AppendEntity(hatch);
                trans.AddNewlyCreatedDBObject(hatch, true);

                //设置填充角度
                hatch.PatternAngle = degree.DegreeToAngle();
                //设置关联
                hatch.Associative = true;
                //设置边界图形和填充方式

                ObjectIdCollection obIds = new ObjectIdCollection();
                obIds.Add(entid);
                hatch.AppendLoop(HatchLoopTypes.Outermost, obIds);
                //计算填充并显示
                hatch.EvaluateHatch(true);
                //提交事务
                trans.Commit();
            }
            return hatchId;
        }

        /// <summary>
        /// 图案填充
        /// </summary>
        /// <param name="db">图形数据库</param>
        /// <param name="loopTypes">图案名称</param>
        /// <param name="scale">填充比例</param>
        /// <param name="degree">旋转角度</param>
        /// <param name="entid">边界图形的ObjectId</param>
        /// <returns>ObjectId</returns>
        public static ObjectId HatchEnity(this Database db, List<HatchLoopTypes> loopTypes, string patternName, double scale, double degree,params ObjectId[] entids)
        {
            ObjectId hatchId = ObjectId.Null;
            using (Transaction trans = db.TransactionManager.StartTransaction())
            {
                //声明图案填充对象
                Hatch hatch = new Hatch();
                //设置填充比例
                hatch.PatternScale = scale;
                //设置填充类型和图案名
                hatch.SetHatchPattern(HatchPatternType.PreDefined, patternName);
                //加入图形数据库
                BlockTable bt = (BlockTable)trans.GetObject(db.BlockTableId, OpenMode.ForRead);
                BlockTableRecord btr = (BlockTableRecord)trans.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite);
                hatchId = btr.AppendEntity(hatch);
                trans.AddNewlyCreatedDBObject(hatch, true);

                //设置填充角度
                hatch.PatternAngle = degree.DegreeToAngle();
                //设置关联
                hatch.Associative = true;
                //设置边界图形和填充方式

                ObjectIdCollection obIds = new ObjectIdCollection();
                for (int i = 0; i < entids.Length; i++)
                {
                    obIds.Clear();
                    obIds.Add(entids[i]);
                    hatch.AppendLoop(loopTypes[i], obIds);
                }
                //计算填充并显示
                hatch.EvaluateHatch(true);
                //提交事务
                trans.Commit();
            }
            return hatchId;
        }
        /// <summary>
        /// 渐变填充
        /// </summary>
        /// <param name="db">图形数据库</param>
        /// <param name="colorIndex1">颜色索引1</param>
        /// <param name="colorIndex2">颜色索引2</param>
        /// <param name="hatchGradientName">渐变图案</param>
        /// <param name="entId">边界图形的ObjectId</param>
        /// <returns>ObjectId</returns>
        public static ObjectId HatchGradient(this Database db, short colorIndex1, short colorIndex2, string hatchGradientName, ObjectId entId)
        {
            //声明ObjectId,用于返回
            ObjectId hatchId = ObjectId.Null;
            ObjectIdCollection objIds = new ObjectIdCollection();
            objIds.Add(entId);
            using (Transaction trans = db.TransactionManager.StartTransaction())
            {
                //声明填充对象
                Hatch hatch = new Hatch();
                //设置填充类型为渐变填充
                hatch.HatchObjectType = HatchObjectType.GradientObject;
                //设置渐变填充的类型和渐变填充的图案名称
                hatch.SetGradient(GradientPatternType.PreDefinedGradient,hatchGradientName);
                //设置填充颜色
                Color color1 = Color.FromColorIndex(ColorMethod.ByColor, colorIndex1);
                Color color2 = Color.FromColorIndex(ColorMethod.ByColor, colorIndex2);
                GradientColor gColor1 = new GradientColor(color1, 0);
                GradientColor gColor2 = new GradientColor(color2, 1);
                hatch.SetGradientColors(new GradientColor[] { gColor1, gColor2 });

                //将填充对象加入图形数据库
                BlockTable bt = (BlockTable)trans.GetObject(db.BlockTableId, OpenMode.ForRead);
                BlockTableRecord btr = (BlockTableRecord)trans.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite);
                hatchId = btr.AppendEntity(hatch);
                trans.AddNewlyCreatedDBObject(hatch,true);
                //添加关联
                hatch.Associative = true;
                hatch.AppendLoop(HatchLoopTypes.Outermost, objIds);
                //计算并显示填充
                hatch.EvaluateHatch(true);
                //提交事务处理
                trans.Commit();
            }
            return hatchId;
        }
    }
}