(在线编辑DWG)网页CAD绘制焊接符号

本文涉及的产品
MSE Nacos/ZooKeeper 企业版试用,1600元额度,限量50份
函数计算FC,每月15万CU 3个月
服务治理 MSE Sentinel/OpenSergo,Agent数量 不受限
简介: 本文介绍了焊接符号的基本结构、特性及其实现方法。焊接符号是一种标准化图形语言,用于表示焊缝类型、尺寸、位置和工艺要求,在机械设计、钢结构等领域广泛应用。文中详细解析了焊接符号的组成(如参考线、箭头、基本符号等)及其附加元素(如现场焊缝、周围焊缝符号等)。基于这些特性,通过网页CAD实现了一个名为`McDbTestWeldingSymbol`的自定义实体类,支持绘制各种焊接符号并提供灵活的配置选项。

前言

在工程制图和制造领域,焊接符号(Welding Symbols)是用于表示焊缝类型、尺寸、位置以及工艺要求的标准化图形语言。广泛应用于机械设计、钢结构、船舶制造、压力容器等行业中,帮助技术人员理解焊接意图。
本文将介绍焊接符号的基本结构、符号、含义,并根据焊接符号的特性通过网页CAD实现焊接符号类,实现绘制焊接符号的功能。

image-20250530143231089.png

焊接符号特性分析

一、焊接符号的基本构成

焊接符号由以下几个基本部分组成:
1.参考线:焊接符号的核心部分,通常是一条水平线,所有其他符号都依附于这条线。参考线分为两部分,箭头上面就是上方区域,箭头下面就是下方区域,如下图:
9d2077076.png

2.箭头:箭头指向要焊接的位置,连接参考线和被焊件的具体部位。
3.基本焊接符号:表示焊缝的类型,如角焊缝、对接焊缝等,绘制在参考线的上方或下方。
4.尾部:可选部分,用于标注焊接方法、工艺编号或其他说明信息(如“GTAW”、“SMAW”等)。
5.补充符号:包括现场焊缝符号、周围焊缝符号、熔透深度符号等。
6.尺寸标注:表示焊缝的具体尺寸,如焊脚高度、坡口角度、根部间隙等。

二、焊接符号的附加元素

1.现场焊缝符号:一个小旗子标志,表示该焊缝需在现场施工时完成,而非在工厂内完成。
2.周围焊缝符号:一个圆圈,表示焊缝应围绕整个接合处进行。
3.熔透符号:表示焊接过程中需要完全熔透母材。
4.打底焊道符号:表示打底焊或衬垫焊。

三、焊接尺寸标注方法

焊接符号中常常包含尺寸信息,以指导焊工操作。以下是常见尺寸标注方式:
3.1.角焊缝尺寸标注

-焊脚尺寸(Leg Size):用数字标注在焊缝符号左侧。
-长度:标注在符号右侧。
-间距(Pitch):标注在长度之后,斜杠后加数字。例如:6/25 表示每25mm间距有一个6mm的角焊缝。

3.2.对接焊缝尺寸标注

-坡口角度:标注在符号旁边。
-根部间隙:标注在角度下方。
-钝边厚度:标注在角度另一侧

实现McDbTestWeldingSymbol焊接符号自定义实体

  1. 定义符号相关的枚举或接口

    // 符号位置
    enum symbolPos {
         
        top = 1,
        down
    }
    // 符号名
    enum symbolName {
         
        // 带垫板符号
        WithPadSymbol,
        // 周围焊接符
        SurroundingWeldSeamSymbol,
        // 现场符号
        OnSiteSymbol,
        // 三面焊缝符号
        ThreeSidedWeldSeamSymbol,
        // 尾部符号
        TailSymbol,
        // 交错断续焊接符号
        ZSymbol,
        // 卷边焊缝
        RolledEdge,
        // I型焊缝
        IWeldSeam,
        // V型焊缝
        VWeldSeam,
        // 单边V型焊缝
        SingleVWeldSeam,
        // 单边陡侧V型坡口堆焊
        SingleSteepVWeldSeam,
        // 倾斜焊缝
        InclinedWeldSeam,
        // 可移除衬垫
        RemovablePadding1,
        RemovablePadding2,
        // 持久衬垫
        DurableLiner,
        // 带顿边V型焊缝
        VFlangedEdgeSeam,
        // 带顿边U型焊缝
        UFlangedEdgeSeam,
        // 带顿边单边V型焊缝
        SingleVFlangedEdgeSeam,
        // 带顿边单边U型焊缝
        SingleUFlangedEdgeSeam,
        // 端接焊缝
        EndWeldSeam,
        // 堆焊接头
        SurfacingJoint,
        // 封底焊缝
        BottomSeamWeld,
        // 角焊缝
        FilletWeld,
        // 塞焊缝或槽焊缝
        GrooveWeldSeam,
        // 点焊缝
        SpotWeldSeam,
        // 折叠接口
        FoldingInterface,
        // 倾斜接口
        InclinedInterface,
        // 点焊缝(偏移中心)
        SpotWeldSeamOffset,
        // 缝焊缝
        SeamWeld,
        // 缝焊缝(偏离中心)
        SeamWeldOffset,
        // 陡侧V型坡口堆焊
        SteepVWeldSeam,
        // 喇叭形焊缝
        BellShapedWeldSeam,
        // 单边喇叭形焊缝
        SingleBellShapedWeldSeam,
        // 堆焊缝
        HeapWeldSeam,
        // 锁边焊缝
        SeamSeam,
        // 锁边坡口
        LockTheSlopeOpening,
        // 第一种平面符号
        FirstPlaneSymbol,
        // 第二种凹面符号
        SecondConcaveSymbol,
        // 第二种凸面符号
        SecondConvexeSymbol,
        // 第二种平面符号
        SecondPlaneSymbol,
        // 第三种平面符号
        ThirdPlaneSymbol,
        // 第一种凸面符号
        FirstConvexeSymbol,
        // 第一种凹面符号
        FirstConcaveSymbol,
        // 削平焊缝
        FlattenWeldSeam,
        // 趾部平滑过渡
        ToeAareaTranSmoothly,
        // 无
        none,
    }
    // 符号类型设置
    interface symbolType {
         
        typeName: symbolName,
        position?: symbolPos,
        rotation?: number,
        info?: string
    }
    // 符号标注设置
    interface symbolDim {
         
        position: symbolPos,
        content: string
    }
    
  2. 基本结构设置

    // 焊接符号自定义实体
    export class McDbTestWeldingSymbol extends McDbCustomEntity {
         
        // 定义McDbTestWeldingSymbol内部的点对象
        // 标记定位点
        private position: McGePoint3d;
        // 标记转折点
        private turningPt: McGePoint3d;
        // 标记定点
        private fixedPoint: McGePoint3d;
        // 箭头长度
        private size: number = 4;
        // 基本符号
        private baseSymbok: symbolType[] = [];
        // 辅助符号
        private auxiliarySymbol: symbolType[] = [];
        // 特殊符号
        private specialSymbol: symbolType[] = [];
        // 补充符号
        private suppleSymbol: symbolType[] = [];
        // 左尺寸
        private leftDim: symbolDim[] = [];
        // 上尺寸
        private topDim: symbolDim[] = [];
        // 右尺寸
        private rightDim: symbolDim[] = [];
        // 虚线位置:0:无虚线, 1:下虚线,2:上虚线
        private dottedPos: number = 0;
        // 标注内字高
        private height: number = this.size * (7 / 8);
        // 焊接说明
        private weldingInfo: string = '';
        // 交错焊缝
        private interlacedWeldSeam: symbolDim[] = [];
    
        /** 包围盒最大点 包围盒最小点 */
        private minPt: McGePoint3d = new McGePoint3d();
        private maxPt: McGePoint3d = new McGePoint3d();
    }
    
  3. 构造函数和创建方法

        // 构造函数
        constructor(imp?: any) {
         
            super(imp);
        }
        // 创建函数
        public create(imp: any) {
         
            return new McDbTestWeldingSymbol(imp)
        }
        // 获取类名
        public getTypeName(): string {
         
            return "McDbTestWeldingSymbol";
        }
    
  4. 数据持久化

    // 读取自定义实体数据pt1、pt2
        public dwgInFields(filter: IMcDbDwgFiler): boolean {
         
            this.position = filter.readPoint("position").val;
            this.turningPt = filter.readPoint("turningPt").val;
            this.fixedPoint = filter.readPoint("fixedPoint").val;
            this.size = filter.readDouble("size").val;
            this.dottedPos = filter.readLong("dottedPos").val;
            this.minPt = filter.readPoint("minPt").val;
            this.maxPt = filter.readPoint("maxPt").val;
            const _baseSymbok = filter.readString('baseSymbok').val;
            this.baseSymbok = JSON.parse(_baseSymbok)
            const _AuxiliarySymbol = filter.readString('AuxiliarySymbol').val;
            this.auxiliarySymbol = JSON.parse(_AuxiliarySymbol)
            const _specialSymbol = filter.readString('specialSymbol').val;
            this.specialSymbol = JSON.parse(_specialSymbol)
            const _suppleSymbol = filter.readString('suppleSymbol').val;
            this.suppleSymbol = JSON.parse(_suppleSymbol)
            const _leftDim = filter.readString('leftDim').val;
            this.leftDim = JSON.parse(_leftDim);
            const _topDim = filter.readString('topDim').val;
            this.topDim = JSON.parse(_topDim);
            const _rightDim = filter.readString('rightDim').val;
            this.rightDim = JSON.parse(_rightDim);
            const _interlacedWeldSeam = filter.readString('interlacedWeldSeam').val;
            this.interlacedWeldSeam = JSON.parse(_interlacedWeldSeam);
            this.weldingInfo = filter.readString('weldingInfo').val;
            return true;
        }
        // 写入自定义实体数据pt1、pt2
        public dwgOutFields(filter: IMcDbDwgFiler): boolean {
         
            filter.writePoint("turningPt", this.turningPt);
            filter.writePoint("position", this.position);
            filter.writePoint("fixedPoint", this.fixedPoint);
            filter.writeDouble("size", this.size);
            filter.writeLong("dottedPos", this.dottedPos);
            filter.writePoint("minPt", this.minPt);
            filter.writePoint("maxPt", this.maxPt);
            filter.writeString('baseSymbok', JSON.stringify(this.baseSymbok));
            filter.writeString('AuxiliarySymbol', JSON.stringify(this.auxiliarySymbol));
            filter.writeString('specialSymbol', JSON.stringify(this.specialSymbol));
            filter.writeString('suppleSymbol', JSON.stringify(this.suppleSymbol));
            filter.writeString('leftDim', JSON.stringify(this.leftDim));
            filter.writeString('topDim', JSON.stringify(this.topDim));
            filter.writeString('rightDim', JSON.stringify(this.rightDim));
            filter.writeString('interlacedWeldSeam', JSON.stringify(this.interlacedWeldSeam));
            filter.writeString('weldingInfo', this.weldingInfo);
            return true;
        }
    
  5. 设置标注夹点及夹点移动规则

    // 移动自定义对象的夹点
        public moveGripPointsAt(iIndex: number, dXOffset: number, dYOffset: number, dZOffset: number) {
         
            this.assertWrite();
            if (iIndex === 0) {
         
                this.position.x += dXOffset;
                this.position.y += dYOffset;
                this.position.z += dZOffset;
            } else if (iIndex === 1) {
         
                this.turningPt.x += dXOffset;
                this.turningPt.y += dYOffset;
                this.turningPt.z += dZOffset;
            } else if (iIndex === 2) {
         
                this.fixedPoint.x += dXOffset;
                this.fixedPoint.y += dYOffset;
                this.fixedPoint.z += dZOffset;
            }
        };
        // 获取自定义对象的夹点
        public getGripPoints(): McGePoint3dArray {
         
            let ret = new McGePoint3dArray()
            ret.append(this.position);
            ret.append(this.turningPt);
            ret.append(this.fixedPoint);
            return ret;
        };
    
  6. 绘制标注实体

    // 绘制实体
        public worldDraw(draw: MxCADWorldDraw): void {
         
            const allEntityArr = this.getAllEntity();
            allEntityArr.forEach((ent, index) => {
         
                if(index === allEntityArr.length-1) draw.setupForEntity(ent);
                draw.drawEntity(ent)
            });
        }
        private getAllEntity(): McDbEntity[] {
         
            const allEntityArr: McDbEntity[] = [];
            const noChangeEntityArr: McDbEntity[] = [];
            // 是否反向
            let isReverse = this.fixedPoint.x < this.position.x ? true : false;
            // 引线结束点
            let lastPt = this.fixedPoint.clone();
            lastPt.addvec(McGeVector3d.kXAxis.clone().mult(this.size * (1 / 8)));
            // 绘制标注线
            const pl = new McDbPolyline();
            pl.addVertexAt(this.position);
            pl.addVertexAt(this.turningPt);
            pl.addVertexAt(this.fixedPoint);
            noChangeEntityArr.push(pl);
            // 绘制标注箭头
            const v = this.turningPoint.sub(this.position).normalize();
            const midPt = this.position.clone().addvec(v.mult(this.size));
            const _v = v.clone().perpVector().mult(this.size * (1 / 8));
            const pt1 = midPt.clone().addvec(_v);
            const pt2 = midPt.clone().addvec(_v.clone().negate());
            const hatch = new McDbHatch();
            hatch.appendLoop(new McGePoint3dArray([pt1, pt2, this.position]));
            noChangeEntityArr.push(hatch);
            // 绘制补充符号
            if (this.suppleSymbol.length) {
         
                const {
          entityArr, noChangeArr, v } = this.drawSuppleSymbol(isReverse);
                lastPt.addvec(v);
                allEntityArr.push(...entityArr);
                noChangeEntityArr.push(...noChangeArr);
            }
            // 绘制左尺寸
            if (this.leftDim.length) {
         
                const {
          entityArr, v } = this.drawLeftDim(lastPt);
                lastPt.addvec(v);
                allEntityArr.push(...entityArr)
            }
            // 绘制特殊符号
            if (this.specialSymbol.length) {
         
                const {
          entityArr } = this.drawSpecialSymbol(lastPt);
                allEntityArr.push(...entityArr);
                   lastPt.addvec(McGeVector3d.kXAxis.clone().mult(this.size / 2))
            }
            if (this.suppleSymbol.length && this.suppleSymbol.filter(item => item.typeName === symbolName.WithPadSymbol).length) {
         
                const entityArr = this.drawWidth(lastPt);
                allEntityArr.push(...entityArr);
            }
            // 绘制基本符号
            if (this.baseSymbok.length) {
         
                const {
          entityArr } = this.drawBasicSymbol(lastPt);
                allEntityArr.push(...entityArr);
            }
            // 绘制辅助符号
            if (this.auxiliarySymbol.length) {
         
                const {
          entityArr } = this.drawAuxiliarySymbol(lastPt);
                allEntityArr.push(...entityArr);
            }
            // 绘制上尺寸
            if (this.topDim.length) {
         
                const {
          entityArr } = this.drawTopDim(lastPt);
                allEntityArr.push(...entityArr)
            }
            lastPt.addvec(McGeVector3d.kXAxis.clone().mult(this.size * (7 / 4)));
            // 绘制右尺寸
            if (this.rightDim.length) {
         
                const {
          entityArr, v } = this.drawRightDim(lastPt);
                lastPt.addvec(v);
                allEntityArr.push(...entityArr)
            }
            lastPt.addvec(McGeVector3d.kXAxis.clone().mult(this.size * (4 / 8)));
            // 绘制交错断续焊接符号
            if (this.suppleSymbol.length && this.suppleSymbol.filter(item => item.typeName === symbolName.ZSymbol).length) {
         
                if (this.baseSymbok.length || this.suppleSymbol.filter(item => item.typeName === symbolName.WithPadSymbol)) lastPt.addvec(McGeVector3d.kXAxis.clone().mult(this.size / 2));
                const distanceVec = McGeVector3d.kXAxis.clone().mult(this.size * (1 / 16));
                const v_y = McGeVector3d.kYAxis.clone().mult(this.size * (17 / 16));
                const v_x = McGeVector3d.kXAxis.clone().mult(this.height).negate();
                const pt2 = lastPt.clone().addvec(v_y);
                const pt4 = lastPt.clone().addvec(v_y.clone().negate());
                const pt1 = pt2.clone().addvec(v_x);
                const pt3 = pt4.clone().addvec(v_x);
                const pl = new McDbPolyline();
                pl.addVertexAt(pt1);
                pl.addVertexAt(pt2);
                pl.addVertexAt(pt3);
                pl.addVertexAt(pt4);
                allEntityArr.push(pl);
                if (this.interlacedWeldSeam.length) {
         
                    let maxPt_x = null;
                    this.interlacedWeldSeam.forEach(item => {
         
                        const text = new McDbMText();
                        text.contents = item.content;
                        text.textHeight = this.height;
                        text.attachment = McDb.AttachmentPoint.kTopLeft;
                        if (item.position === symbolPos.down) {
         
                            text.location = lastPt.clone().addvec(distanceVec)
                        } else if (item.position === symbolPos.top) {
         
                            text.location = lastPt.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.size)).addvec(distanceVec)
                        }
                        // 将ent的文字样式设置为当前文字样式
                        const textStyleId = MxCpp.getCurrentMxCAD().getDatabase().getCurrentlyTextStyleId();
                        text.textStyleId = textStyleId;
                        text.reCompute();
                        const {
          maxPt } = MxCADUtility.getTextEntityBox(text, false);
                        if (!maxPt_x || maxPt_x < maxPt.x) {
         
                            maxPt_x = maxPt.x;
                        }
                        allEntityArr.push(text);
                    });
                    lastPt.x = maxPt_x;
                }
            }
            // 绘制尾部符号(焊接说明)
            if (this.suppleSymbol.length && this.suppleSymbol.filter(item => item.typeName === symbolName.TailSymbol).length) {
         
                const vec = this.fixedPoint.sub(lastPt).mult(2);
                const v_y = McGeVector3d.kYAxis.clone().mult(this.height);
                const v_x = isReverse ? McGeVector3d.kXAxis.clone().negate().mult(this.height) : McGeVector3d.kXAxis.clone().mult(this.height);
                const pt1 = lastPt.clone().addvec(v_y).addvec(v_x);
                const pt2 = lastPt.clone().addvec(v_y.clone().negate()).addvec(v_x);
                const pl = new McDbPolyline();
                pl.addVertexAt(pt1)
                pl.addVertexAt(lastPt);
                pl.addVertexAt(pt2);
                if (isReverse) pl.move(lastPt, lastPt.clone().addvec(vec));
                noChangeEntityArr.push(pl)
    
                if (this.weldingInfo) {
         
                    const text = new McDbMText();
                    text.contents = this.weldingInfo;
                    const v = isReverse ? McGeVector3d.kXAxis.clone().mult(this.size * (5 / 4)).negate() : McGeVector3d.kXAxis.clone().mult(this.size * (5 / 4))
                    text.location = lastPt.clone().addvec(v);
                    text.attachment = isReverse ? McDb.AttachmentPoint.kMiddleRight : McDb.AttachmentPoint.kMiddleLeft;
                    text.textHeight = this.height;
                    if (isReverse) text.move(lastPt, lastPt.clone().addvec(vec));
                    noChangeEntityArr.push(text);
                }
            }
            // 绘制虚线
            const line = new McDbLine(lastPt, this.fixedPoint);
            if (isReverse) {
         
                line.move(lastPt, this.fixedPoint);
            }
            noChangeEntityArr.push(line);
            if (this.dottedPos && !this.suppleSymbol.filter(item => item.typeName === symbolName.ZSymbol).length) {
         
                const vec = McGeVector3d.kYAxis.clone().mult(this.size * (1 / 4))
                if (this.dottedPos === 2) vec.negate();
                const movePt = this.fixedPoint.clone().addvec(vec);
                const dottedLine = line.clone() as McDbLine;
                dottedLine.move(this.fixedPoint, movePt);
                const mxcad = MxCpp.getCurrentMxCAD();
                let dashline = this.dimSize / 8;
                let databse = mxcad.database;
                let lcale = mxcad.getSysVarDouble("LTSCALE");
                dashline = dashline / lcale;
                let lineTable = databse.getLinetypeTable();
                let lineTypeName = "weldingDottedLineType";
                let lineRecId = lineTable.get(lineTypeName);
                if (lineRecId.isNull()) {
         
                    let lineTypeRecord = new McDbLinetypeTableRecord();
                    lineTypeRecord.numDashes = 2;
                    lineTypeRecord.setDashLengthAt(0, dashline);
                    lineTypeRecord.setDashLengthAt(1, -dashline);
                    lineTypeRecord.name = lineTypeName;
                    lineRecId = lineTable.add(lineTypeRecord);
                }
                dottedLine.linetypeId = lineRecId;
                noChangeEntityArr.push(dottedLine);
            }
    
            // 是否反转
            if(isReverse){
         
                let endPt = this.fixedPoint.clone();
                if(this.suppleSymbol.filter(item=>item.typeName === symbolName.OnSiteSymbol).length){
         
                    endPt = this.fixedPoint.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size * (5 / 4)).negate())
                }
                allEntityArr.forEach(ent=>{
         
                    ent.move(lastPt, endPt);
                })
            }
    
            allEntityArr.push(...noChangeEntityArr);
    
            return allEntityArr;
        }
        // 绘制补充符号
        private drawSuppleSymbol(isReverse: boolean): {
          entityArr: McDbEntity[], noChangeArr: McDbEntity[], v: McGeVector3d } {
         
            const entityArr: McDbEntity[] = [];
            const noChangeArr: McDbEntity[] = [];
            let basePt = this.fixedPoint.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size * (1 / 8)));
            let lastPt = this.fixedPoint.clone();
            // 虚线间距
            let dottedPosVec = McGeVector3d.kYAxis.clone().mult(this.size * (1 / 4));
            if (this.suppleSymbol.filter(item => item.typeName === symbolName.SurroundingWeldSeamSymbol).length) {
         
                // 周围焊接符号
                const circle = new McDbCircle(this.fixedPoint.x, this.fixedPoint.y, 0, this.size * (3 / 8));
                // entityArr.push(circle);
                noChangeArr.push(circle);
    
                basePt.addvec(McGeVector3d.kXAxis.clone().mult(this.size * (3 / 8)));
                lastPt = new McGePoint3d(basePt.x, this.fixedPoint.y);
            }
            if (this.suppleSymbol.filter(item => item.typeName === symbolName.OnSiteSymbol).length) {
         
                // 现场符号
                const v = McGeVector3d.kYAxis.clone().mult(this.size * (3 / 8));
                const midPt = this.fixedPoint.clone().addvec(v);
    
                const topPt = midPt.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.size * (7 / 8)));
                const vec = McGeVector3d.kXAxis.clone().mult(this.size * (5 / 4))
                const endPt = midPt.clone().addvec(vec);
                const line = new McDbLine(this.fixedPoint, midPt);
                let hatch = new McDbHatch();
                hatch.appendLoop(new McGePoint3dArray([midPt, topPt, endPt]));
                const {
          maxPt } = hatch.getBoundingBox();
                lastPt = new McGePoint3d(maxPt.x, this.fixedPoint.y);
                if(isReverse){
         
                    hatch = new McDbHatch();
                    const endPt = midPt.clone().addvec(vec.clone().negate());
                    hatch.appendLoop(new McGePoint3dArray([midPt, topPt, endPt]));
                }
                noChangeArr.push(hatch);
                noChangeArr.push(line);
    
                basePt.addvec(McGeVector3d.kXAxis.clone().mult(this.size * (7 / 8)));
            }
            if (this.suppleSymbol.filter(item => item.typeName === symbolName.ThreeSidedWeldSeamSymbol).length) {
         
                const item = this.suppleSymbol.filter(item => item.typeName === symbolName.ThreeSidedWeldSeamSymbol)[0];
                // 三面焊缝符号
                const point = this.dottedPos === 1 ? basePt.clone().addvec(dottedPosVec) : basePt.clone();
                const v = McGeVector3d.kYAxis.clone();
                const pt2 = point.clone().addvec(v.clone().mult(this.size * (1 / 8)));
                const pt1 = pt2.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size));
                const pt3 = pt2.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.size * (3 / 4)));
                const pt4 = pt1.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.size * (3 / 4)));
                const pl = new McDbPolyline();
                pl.addVertexAt(pt1);
                pl.addVertexAt(pt2);
                pl.addVertexAt(pt3);
                pl.addVertexAt(pt4);
                const {
          minPt, maxPt } = pl.getBoundingBox();
                let last_x: number = maxPt.x;
                const centerPt = minPt.clone().addvec(maxPt.sub(minPt).mult(1 / 2))
                // 根据旋转角度旋转
                if (item.rotation) {
         
                    pl.rotate(centerPt, item.rotation);
                    if (item.rotation != Math.PI) {
         
                        pl.move(point, pt2);
                    }
                    const {
          maxPt } = pl.getBoundingBox();
                    last_x = maxPt.x;
                }
                lastPt = new McGePoint3d(last_x, this.fixedPoint.y);
                entityArr.push(pl);
            }
            const v = lastPt.sub(this.fixedPoint);
            return {
          entityArr, noChangeArr, v }
        }
        // 绘制带垫板符号
        private drawWidth(lastPt: McGePoint3d): McDbEntity[] {
         
            const entityArr = [];
            // 虚线间距
            let dottedPosVec = McGeVector3d.kYAxis.clone().mult(this.size * (1 / 4));
            const v1 = McGeVector3d.kXAxis.clone().mult(this.size / 2);
            const v2 = McGeVector3d.kYAxis.clone().mult(this.size * (7 / 16)).negate();
            const pt = lastPt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size));
            if (this.dottedLinePos === 2) pt.addvec(dottedPosVec.clone().negate());
            const pt1 = pt.clone().addvec(v1);
            const pt2 = pt1.clone().addvec(v2);
            const pt4 = pt.clone().addvec(v1.clone().negate());
            const pt3 = pt4.clone().addvec(v2);
            const ptArr = [pt1, pt2, pt3, pt4];
            const pl = new McDbPolyline();
            ptArr.forEach(pt => {
          pl.addVertexAt(pt) });
            entityArr.push(pl);
            return entityArr
        }
        // 绘制左标注
        private drawLeftDim(lastPt: McGePoint3d): {
          entityArr: McDbEntity[], v: McGeVector3d } {
         
            const entityArr = [];
            // 实体最大x
            let maxPt_x = null;
            // 字体实体间距
            const distanceVec = McGeVector3d.kXAxis.clone().mult(this.size * (1 / 16));
            // 虚线间距
            const dottedPosVec = McGeVector3d.kYAxis.clone().mult(this.size * (1 / 4));
            this.leftDim.forEach(item => {
         
                const text = new McDbMText();
                text.contents = item.content;
                text.textHeight = this.height;
                text.attachment = McDb.AttachmentPoint.kTopLeft;
                if (item.position === symbolPos.down) {
         
                    const pt = this.dottedPos === 2 && !this.suppleSymbol.filter(item => item.typeName === symbolName.ZSymbol).length ? lastPt.clone().addvec(dottedPosVec.negate()) : lastPt.clone()
                    text.location = pt.clone().addvec(distanceVec);
                } else if (item.position === symbolPos.top) {
         
                    const pt = this.dottedPos === 1 && this.suppleSymbol.filter(item => item.typeName === symbolName.ZSymbol).length ? lastPt.clone().addvec(dottedPosVec) : lastPt.clone()
                    text.location = pt.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.size)).addvec(distanceVec);
                }
                // 将ent的文字样式设置为当前文字样式
                const textStyleId = MxCpp.getCurrentMxCAD().getDatabase().getCurrentlyTextStyleId();
                text.textStyleId = textStyleId;
                text.reCompute();
                const {
          maxPt } = MxCADUtility.getTextEntityBox(text, false);
                if (!maxPt_x || maxPt_x < maxPt.x) {
         
                    maxPt_x = maxPt.x;
                }
                // 是否做反向处理
                // if (isReverse) {
         
                //     text.attachment = McDb.AttachmentPoint.kTopRight;
                //     const pt = new McGePoint3d(this.fixedPoint.x, text.location.y, 0)
                //     const v = pt.sub(text.location);
                //     text.location = pt.clone().addvec(v);
                // };
                if (this.dottedLinePos && item.position === this.dottedLinePos) {
         
                    const v = this.dottedLinePos === 1 ? McGeVector3d.kYAxis.clone().mult(this.size / 4) : McGeVector3d.kYAxis.clone().mult(this.size / 4).negate();
                    text.location = text.location.addvec(v);
                }
                entityArr.push(text)
            })  
            const v = (new McGePoint3d(maxPt_x, lastPt.y)).sub(lastPt);
            return {
          entityArr, v }
        }
        // 绘制上标注
        private drawTopDim(lastPt: McGePoint3d): {
          entityArr: McDbEntity[] } {
         
            const entityArr = [];
    
            const basePt = lastPt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size)).addvec(McGeVector3d.kYAxis.clone().mult(this.size * (7 / 4)));
            this.topDim.forEach(item => {
         
                const text = new McDbMText;
                text.contents = item.content;
                text.textHeight = this.height;
                text.attachment = McDb.AttachmentPoint.kBaseCenter;
                text.location = basePt.clone();
                text.location = basePt.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.height));
                if (item.position === symbolPos.down) {
         
                    text.mirror(this.fixedPoint, lastPt);
                    text.attachment = McDb.AttachmentPoint.kBaseCenter;
                    text.location = text.location.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.height));
                };
    
                // 是否有虚线
                if (this.dottedLinePos && item.position === this.dottedLinePos) {
         
                    const v = this.dottedLinePos === 1 ? McGeVector3d.kYAxis.clone().mult(this.size / 4) : McGeVector3d.kYAxis.clone().mult(this.size / 4).negate();
                    text.location = text.location.addvec(v);
                }
                entityArr.push(text)
            })
    
            return {
          entityArr }
        }
    
        // 绘制右标注
        private drawRightDim(lastPt: McGePoint3d): {
          entityArr: McDbEntity[], v: McGeVector3d } {
         
            const entityArr = [];
            const v = McGeVector3d.kXAxis.clone();
            let maxPt_x = null;
            this.rightDim.forEach(item => {
         
                const text = new McDbMText();
                text.contents = item.content;
                text.textHeight = this.height;
                text.attachment = McDb.AttachmentPoint.kTopLeft;
                if (item.position === symbolPos.top) {
         
                    text.location = lastPt.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.height + this.size / 8));
                } else if (item.position === symbolPos.down) {
         
                    text.location = lastPt.clone();
                };
                const textStyleId = MxCpp.getCurrentMxCAD().getDatabase().getCurrentlyTextStyleId();
                text.textStyleId = textStyleId;
                text.reCompute();
                const {
          maxPt } = MxCADUtility.getTextEntityBox(text, false);
                if (!maxPt_x || maxPt_x < maxPt.x) {
         
                    maxPt_x = maxPt.x;
                }
                // 是否有虚线
                if (this.dottedLinePos && item.position === this.dottedLinePos) {
         
                    const v = this.dottedLinePos === 1 ? McGeVector3d.kYAxis.clone().mult(this.size / 4) : McGeVector3d.kYAxis.clone().mult(this.size / 4).negate();
                    text.location = text.location.addvec(v);
                }
                entityArr.push(text);
            })
            v.mult(Math.abs(maxPt_x - lastPt.x));
            return {
          entityArr, v }
        }
        // 绘制基本符号
        private drawBasicSymbol(lastPt: McGePoint3d): {
          entityArr: McDbEntity[] } {
         
            const entityArr = [];
            const allEntityArr = [];
            // 设置基本符号内的文字
            const setInfoText = (item: symbolType, pl: McDbPolyline): McGePoint3d[] => {
         
                let plPoints = [];
                const {
          maxPt: plMaxPt, minPt: plMinPt } = pl.getBoundingBox();
                const mindPt = plMinPt.clone().addvec(plMaxPt.sub(plMinPt).mult(1 / 2));
                const point = new McGePoint3d(mindPt.x, lastPt.y);
                const text = new McDbMText();
                text.contents = item.info;
                text.attachment = McDb.AttachmentPoint.kTopCenter;
                text.textHeight = this.size * (1 / 3);
                text.location = point.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.size * (11 / 12)));
    
                // 将ent的文字样式设置为当前文字样式
                const textStyleId = MxCpp.getCurrentMxCAD().getDatabase().getCurrentlyTextStyleId();
                text.textStyleId = textStyleId;
                text.reCompute();
                const {
          minPt, maxPt } = MxCADUtility.getTextEntityBox(text, false);
    
                // 位置下
                if (item.position === symbolPos.down) {
         
                    const text_clone = text.clone() as McDbMText;
                    text_clone.mirror(this.fixedPoint, lastPt);
                    text.attachment = McDb.AttachmentPoint.kTopCenter;
                    text.location = text_clone.location.addvec(McGeVector3d.kYAxis.clone().mult(text.textHeight * (7 / 6)));
                }
                entityArr.push(text);
    
                const l = new McDbLine(minPt, new McGePoint3d(maxPt.x, minPt.y));
                const arr = l.IntersectWith(pl, McDb.Intersect.kOnBothOperands);
                if (arr.length() === 2) {
         
                    plPoints = [arr.at(0), pl.getPointAt(1).val, arr.at(1)]
                } else if (arr.length() === 1) {
         
                    plPoints = [pl.getPointAt(0).val, pl.getPointAt(1).val, arr.at(0)]
                }
    
                return plPoints
            }
            // 根据点数组设置多段线
            const getPl = (points: McGePoint3d[]): McDbPolyline => {
         
                const pl = new McDbPolyline();
                points.forEach(pt => {
         
                    pl.addVertexAt(pt)
                })
                return pl
            }
            // 设置文字基本符号
            const setBaseSymbolText = (content: string, item: symbolType) => {
         
                const pt1 = lastPt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size * (3 / 8)));
                const pt2 = pt1.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.size * (5 / 8)));
                const pt3 = pt2.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size * (5 / 4)));
                const pt4 = pt1.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size * (5 / 4)));
                const pl = getPl([pt1, pt2, pt3, pt4]);
                const {
          minPt, maxPt } = pl.getBoundingBox();
                const midPt = minPt.clone().addvec(maxPt.sub(minPt).mult(1 / 2));
    
                const text = new McDbMText();
                text.contents = content;
                text.attachment = McDb.AttachmentPoint.kBaseFit;
                text.textHeight = this.size * (5 / 8);
                text.location = midPt;
                // 根据中心点和location 之间的距离大小去将text文本设置到矩形框中心位置
                // 将ent的文字样式设置为当前文字样式
                text.reCompute();
                const textStyleId = MxCpp.getCurrentMxCAD().getDatabase().getCurrentlyTextStyleId();
                text.textStyleId = textStyleId;
                text.reCompute();
                const {
          minPt: textMinPt, maxPt: textMaxPt } = MxCADUtility.getTextEntityBox(text, false);
                const textMidPt = textMinPt.clone().addvec(textMaxPt.sub(textMinPt).mult(0.5));
                const vec = midPt.sub(textMidPt);
                text.location = midPt.clone().addvec(vec).addvec(McGeVector3d.kXAxis.clone().mult(this.size / 15)).addvec(McGeVector3d.kYAxis.clone().mult(this.size / 17));
    
                if (item.position === symbolPos.down) {
         
                    const text_clone = text.clone() as McDbMText;
                    text_clone.mirror(this.fixedPoint, lastPt);
                    text.location = text_clone.location.addvec(McGeVector3d.kYAxis.clone().mult(text.textHeight * (7 / 6)));
                };
    
                entityArr.push(pl, text);
            }
            this.baseSymbok.forEach(item => {
         
                entityArr.length = 0;
    
                if (item.typeName === symbolName.RolledEdge) {
         
                    // 卷边焊缝
                    const radius = this.size * (3 / 4);
                    const arc = new McDbArc();
                    arc.center = lastPt.clone().addvec(McGeVector3d.kYAxis.clone().mult(radius)).addvec(McGeVector3d.kXAxis.clone().mult(this.size / 8));
                    arc.radius = radius;
                    arc.startAngle = Math.PI * (3 / 2);
                    arc.endAngle = 0;
    
                    const endPt = arc.center.clone().addvec(McGeVector3d.kXAxis.clone().mult(radius));
                    const topPt = endPt.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.size * (1 / 8)));
                    const line = new McDbLine(topPt, endPt);
    
                    const originPt = endPt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size * (1 / 8)));
                    const _arc = arc.clone() as McDbEntity;
                    _arc.mirror(originPt, new McGePoint3d(originPt.x, lastPt.y));
                    const _line = line.clone() as McDbEntity;
                    _line.mirror(originPt, new McGePoint3d(originPt.x, lastPt.y));
                    entityArr.push(...[arc, _arc, _line, line]);
    
                } else if (item.typeName === symbolName.IWeldSeam) {
         
                    // I型焊缝
                    const pt = lastPt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size * (11 / 16)));
                    const endPt = pt.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.height));
                    const line = new McDbLine(pt, endPt);
                    const _line = line.clone() as McDbLine;
                    const toPt = pt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size * (5 / 8)));
                    _line.move(pt, toPt);
                    entityArr.push(...[line, _line]);
                } else if (item.typeName === symbolName.VWeldSeam) {
         
                    // V型焊缝
                    const pt = lastPt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size * (1 / 2)));
                    const pt1 = pt.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.size * (7 / 8)));
                    const pt2 = pt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size * (1 / 2)));
                    const pt3 = pt1.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size));
                    let plPoints = [pt1, pt2, pt3];
                    const pl = getPl(plPoints);
    
                    if (item.info) {
         
                        const pointArr = setInfoText(item, pl);
                        if (pointArr.length) {
         
                            plPoints = pointArr;
                        }
                    }
                    const polyline = getPl(plPoints);
                    entityArr.push(polyline);
    
                } else if (item.typeName === symbolName.SingleVWeldSeam) {
         
                    // 单边V型焊缝
                    const pt2 = lastPt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size * (5 / 8)));
                    const pt1 = pt2.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.height));
                    const pt3 = pt1.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.height));
                    let plPoints = [pt1, pt2, pt3];
                    const pl = getPl(plPoints);
                    if (item.info) {
         
                        const pointArr = setInfoText(item, pl);
                        if (pointArr.length) {
         
                            plPoints = pointArr;
                        }
                    }
                    const polyline = getPl(plPoints);
                    entityArr.push(polyline);
                } else if (item.typeName === symbolName.SingleSteepVWeldSeam) {
         
                    // 单边陡侧V型坡口堆焊
                    const pt2 = lastPt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size * (5 / 8)));
                    pt2.addvec(McGeVector3d.kYAxis.clone().mult(this.size * (1 / 8)));
                    const pt1 = pt2.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.height));
                    const pt3 = pt2.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size / 2));
    
                    const linePt1 = pt3.clone().addvec(pt2.sub(pt3).mult(1 / 4));
                    const linePt2 = linePt1.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.height)).addvec(McGeVector3d.kXAxis.clone().mult(this.size * (5 / 16)));
                    const line = new McDbLine(linePt1, linePt2);
    
                    let plPoints = [pt1, pt2, pt3];
    
                    const polyline = getPl(plPoints);
                    entityArr.push(polyline, line);
                } else if (item.typeName === symbolName.InclinedWeldSeam) {
         
                    // 倾斜焊缝
                    const pt1 = lastPt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size / 2));
                    const _pt1 = pt1.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.height / 2));
                    const pt2 = _pt1.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size * (5 / 8)));
                    const _pt2 = pt2.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.height / 2));
    
                    const _line = new McDbLine(_pt1, _pt2);
                    const line = new McDbLine(pt1, pt2);
                    entityArr.push(_line, line);
                } else if (item.typeName === symbolName.RemovablePadding1) {
         
                    // 可移除衬垫-MR
                    setBaseSymbolText('MR', item);
                } else if (item.typeName === symbolName.RemovablePadding2) {
         
                    // 可移除衬垫-MR
                    setBaseSymbolText('R', item);
                } else if (item.typeName === symbolName.DurableLiner) {
         
                    // 持久衬垫-M
                    setBaseSymbolText('M', item);
                } else if (item.typeName === symbolName.VFlangedEdgeSeam) {
         
                    // 带顿边V型焊缝
                    const pt1 = lastPt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size));
                    const pt2 = pt1.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.size * (3 / 8)));
                    const pt3 = pt2.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size * (5 / 16))).addvec(McGeVector3d.kYAxis.clone().mult(this.size / 2));
                    const pt4 = pt3.clone().addvec(McGeVector3d.kXAxis.clone().negate().mult(this.size * (5 / 8)));
                    let plPoints = [pt3, pt2, pt4];
    
                    const line = new McDbLine(pt1, pt2);
                    const pl = getPl(plPoints);
                    if (item.info) {
         
                        const pointArr = setInfoText(item, pl);
                        if (pointArr.length) {
         
                            plPoints = pointArr;
                        }
                    }
                    const polyline = getPl(plPoints);
                    entityArr.push(polyline, line);
                } else if (item.typeName === symbolName.SingleVFlangedEdgeSeam) {
         
                    // 带单边顿边V型焊缝
                    const pt1 = lastPt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size * (11 / 16)));
                    const pt2 = pt1.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.size * (3 / 8)));
                    const pt3 = pt2.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.size / 2));
                    const pt4 = pt3.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size * (5 / 8)));
                    let plPoints = [pt3, pt2, pt4];
    
                    const line = new McDbLine(pt1, pt2);
                    const pl = getPl(plPoints);
                    if (item.info) {
         
                        const pointArr = setInfoText(item, pl);
                        if (pointArr.length) {
         
                            plPoints = pointArr;
                        }
                    }
                    const polyline = getPl(plPoints);
                    entityArr.push(polyline, line);
                } else if (item.typeName === symbolName.UFlangedEdgeSeam) {
         
                    // 带顿边U型焊缝
                    const pt1 = lastPt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size));
                    const pt2 = pt1.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.size * (1 / 4)));
                    const line = new McDbLine(pt1, pt2);
    
                    const radius = this.size * (3 / 8);
                    const arc = new McDbArc();
                    arc.center = pt2.clone().addvec(McGeVector3d.kYAxis.clone().mult(radius));
                    arc.radius = radius;
                    arc.startAngle = Math.PI;
                    arc.endAngle = Math.PI * 2;
    
                    const startPt = arc.getStartPoint().val;
                    const point1 = startPt.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.size / 4));
    
                    const endPt = arc.getEndPoint().val;
                    const point2 = endPt.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.size / 4));
    
                    let plPoints = [point1, pt1, point2];
                    const pl = getPl(plPoints);
                    if (item.info) {
         
                        const pointArr = setInfoText(item, pl);
                        if (pointArr.length) {
         
                            plPoints = pointArr;
                        }
                        const line = new McDbLine(plPoints[0], plPoints[2]);
                        const pts = line.IntersectWith(arc, McDb.Intersect.kOnBothOperands);
                        if (pts.length()) {
         
                            const _arc = new McDbArc()
                            _arc.computeArc(pts.at(0).x, pts.at(0).y, pt2.x, pt2.y, pts.at(1).x, pts.at(1).y);
                            entityArr.push(_arc);
                        }else{
         
                            entityArr.push(arc);
                        }
                    } else {
         
                        const line1 = new McDbLine(startPt, point1);
                        const line2 = new McDbLine(endPt, point2);
                        entityArr.push(line1, line2, arc);
                    }
                    entityArr.push(line);
                } else if (item.typeName === symbolName.SingleUFlangedEdgeSeam) {
         
                    // 单边带顿边U型焊缝
                    const radius = this.size * (3 / 8);
                    const pt1 = lastPt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size - radius / 2));
                    const pt2 = pt1.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.height));
                    const line = new McDbLine(pt1, pt2);
    
                    const pt3 = pt1.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.size * (1 / 4)));
                    const arc = new McDbArc();
                    arc.center = pt3.clone().addvec(McGeVector3d.kYAxis.clone().mult(radius));
                    arc.radius = radius;
                    arc.startAngle = Math.PI * (3 / 2);
                    arc.endAngle = Math.PI * 2;
                    const endPt = arc.getEndPoint().val;
                    const point1 = endPt.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.size / 4));
                    const line2 = new McDbLine(endPt, point1);
                    entityArr.push(line2, arc, line);
                } else if (item.typeName === symbolName.EndWeldSeam) {
         
                    // 端接焊缝
                    const pt1 = lastPt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size));
                    const pt2 = pt1.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.height));
                    const line = new McDbLine(pt1, pt2);
                    const v = McGeVector3d.kXAxis.clone().mult(this.size * (3 / 16));
                    const line1 = line.clone() as McDbLine;
                    line1.move(pt1, pt1.clone().addvec(v));
                    const line2 = line.clone() as McDbLine;
                    line2.move(pt1, pt1.clone().addvec(v.clone().negate()));
                    entityArr.push(line, line1, line2)
                } else if (item.typeName === symbolName.SurfacingJoint) {
         
                    // 堆焊接头
                    const basePt = lastPt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size)).addvec(McGeVector3d.kYAxis.clone().mult(this.size * (11 / 16)));
                    const v = McGeVector3d.kXAxis.clone().mult(this.size * (3 / 8))
                    const pt1 = basePt.clone().addvec(v);
                    const pt2 = basePt.clone().addvec(v.clone().negate());
                    const line = new McDbLine(pt1, pt2);
                    const line1 = line.clone() as McDbLine;
                    line1.mirror(this.fixedPoint, lastPt);
                    entityArr.push(line, line1)
                } else if (item.typeName === symbolName.BottomSeamWeld) {
         
                    // 封底焊缝
                    const basePt = lastPt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size));
                    const center = basePt.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.size * (1 / 4)));
                    const circle = new McDbCircle();
                    circle.center = center;
                    circle.radius = this.size * (11 / 16);
                    const line = new McDbLine(this.fixedPoint, lastPt);
                    const ptsArr = circle.IntersectWith(line, McDb.Intersect.kExtendBoth);
                    if (ptsArr.length() === 2) {
         
                        const arc = new McDbArc();
                        const midPt = center.clone().addvec(McGeVector3d.kYAxis.clone().negate().mult(circle.radius));
                        const pt1 = ptsArr.at(0);
                        const pt2 = ptsArr.at(1);
                        arc.computeArc(pt1.x, pt1.y, midPt.x, midPt.y, pt2.x, pt2.y);
                        arc.mirror(this.fixedPoint, lastPt);
                        const line = new McDbLine(pt1, pt2);
                        entityArr.push(arc, line);
                    }
                } else if (item.typeName === symbolName.FilletWeld) {
         
                    // 角焊缝
                    const basePt = lastPt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size));
                    const v = McGeVector3d.kXAxis.clone().mult(this.height / 2);
                    const pt1 = basePt.clone().addvec(v);
                    const pt2 = basePt.clone().addvec(v.clone().negate());
                    const pt3 = pt2.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.height));
                    const pl = getPl([pt1, pt2, pt3]);
                    pl.isClosed = true;
                    entityArr.push(pl)
                } else if (item.typeName === symbolName.GrooveWeldSeam) {
         
                    // 槽焊缝
                    const basePt = lastPt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size));
                    const v = McGeVector3d.kXAxis.clone().mult(this.size / 2);
                    const _v = McGeVector3d.kYAxis.clone().mult(this.size * (5 / 8));
                    const pt1 = basePt.clone().addvec(v);
                    const pt2 = pt1.clone().addvec(_v);
                    const pt3 = pt2.clone().addvec(v.negate().mult(2));
                    const pt4 = pt3.clone().addvec(_v.clone().negate());
                    const pl = getPl([pt1, pt2, pt3, pt4]);
                    entityArr.push(pl);
                } else if (item.typeName === symbolName.SpotWeldSeam) {
         
                    // 点焊缝
                    const circle = new McDbCircle();
                    circle.center = lastPt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size));
                    circle.radius = this.size * (3 / 8);
                    entityArr.push(circle)
                } else if (item.typeName === symbolName.FoldingInterface) {
         
                    // 折叠接口
                    const basePt = lastPt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size));
                    const lineMidPt = basePt.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.height * (2 / 3)));
                    const v = McGeVector3d.kXAxis.clone().mult(this.size * (1 / 8))
                    const pt1 = lineMidPt.clone().addvec(v);
                    const pt2 = lineMidPt.clone().addvec(v.clone().negate());
                    const line1 = new McDbLine(pt1, pt2);
                    const vec = McGeVector3d.kYAxis.clone().mult(this.height / 3);
                    const line2 = line1.clone() as McDbLine;
                    line2.move(pt1, pt1.clone().addvec(vec));
                    line2.endPoint = line2.endPoint.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.height / 3).negate())
                    const line3 = line1.clone() as McDbLine;
                    line3.move(pt1, pt1.clone().addvec(vec.clone().negate()));
                    const arc1 = new McDbArc();
                    arc1.center = pt2.clone().addvec(vec.clone().negate());
                    arc1.radius = this.height / 3;
                    arc1.startAngle = Math.PI / 2;
                    arc1.endAngle = Math.PI * (3 / 2);
                    const arc2 = new McDbArc();
                    arc2.center = pt1;
                    arc2.radius = this.height / 3;
                    arc2.startAngle = Math.PI * (3 / 2);
                    arc2.endAngle = Math.PI / 2;
                    entityArr.push(line1, line2, line3, arc1, arc2)
                } else if (item.typeName === symbolName.InclinedInterface) {
         
                    // 倾斜接口
                    const pt1 = lastPt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size - this.height / 2));
                    const pt2 = pt1.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.height)).addvec(McGeVector3d.kXAxis.clone().mult(this.height / 2));
                    const line = new McDbLine(pt1, pt2);
                    const _line = line.clone() as McDbLine;
                    _line.move(pt1, pt1.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.height / 2)));
                    entityArr.push(line, _line)
                } else if (item.typeName === symbolName.SpotWeldSeamOffset) {
         
                    // 点焊缝(偏移中心)
                    const circle = new McDbCircle();
                    circle.center = lastPt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size));
                    circle.radius = this.height / 2;
                    entityArr.push(circle);
                } else if (item.typeName === symbolName.SeamWeld) {
         
                    // 缝焊缝
                    const basePt = lastPt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size));
                    const circle = new McDbCircle();
                    circle.center = basePt;
                    circle.radius = this.size * (11 / 16);
                    const v = McGeVector3d.kXAxis.clone().mult(this.height);
                    const pt1 = basePt.clone().addvec(v);
                    const pt2 = basePt.clone().addvec(v.clone().negate());
                    const line = new McDbLine(pt1, pt2);
                    const vec = McGeVector3d.kYAxis.clone().mult(this.height / 2);
                    const line1 = line.clone() as McDbLine;
                    line1.move(basePt, basePt.clone().addvec(vec));
                    const line2 = line.clone() as McDbLine;
                    line2.move(basePt, basePt.clone().addvec(vec.clone().negate()));
                    entityArr.push(circle, line1, line2);
                } else if (item.typeName === symbolName.SeamWeldOffset) {
         
                    // 缝焊缝(偏离中心)
                    const basePt = lastPt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size));
                    // 2.275
                    const v = McGeVector3d.kYAxis.clone().mult(this.size * (9 / 16));
                    const circle = new McDbCircle();
                    circle.center = basePt.clone().addvec(v);
                    circle.radius = this.size * (9 / 16);
                    const vec = McGeVector3d.kXAxis.clone().mult(this.height)
                    const pt1 = basePt.clone().addvec(vec);
                    const pt2 = basePt.clone().addvec(vec.clone().negate());
                    const line = new McDbLine(pt1, pt2);
                    const movePt1 = circle.center.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.size * (3 / 16)));
                    const movePt2 = circle.center.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.size / 4).negate());
                    const line1 = line.clone() as McDbLine;
                    line1.move(basePt, movePt1);
                    const line2 = line.clone() as McDbLine;
                    line2.move(basePt, movePt2);
                    entityArr.push(circle, line1, line2)
                } else if (item.typeName === symbolName.SteepVWeldSeam) {
         
                    // 陡侧V型坡口堆焊
                    const _lastPt = lastPt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size));
                    const basePt = _lastPt.addvec(McGeVector3d.kYAxis.clone().mult(this.size / 4));
                    const v = McGeVector3d.kXAxis.clone().mult(this.size * (5 / 16))
                    const pt1 = basePt.clone().addvec(v);
                    const pt2 = basePt.clone().addvec(v.clone().negate());
                    const line = new McDbLine(pt1, pt2);
                    const point1 = basePt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size / 8));
                    const point2 = point1.clone().addvec(v).addvec(McGeVector3d.kYAxis.clone().mult(this.height));
                    const line1 = new McDbLine(point1, point2);
                    const line2 = line1.clone() as McDbLine;
                    line2.mirror(_lastPt, basePt.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.size)));
                    entityArr.push(line, line1, line2);
                }
                if (item.position === symbolPos.down) {
         
                    entityArr.forEach(ent => {
         
                        if (!(ent instanceof McDbMText)) {
         
                            (ent as McDbEntity).mirror(this.fixedPoint, lastPt);
                        }
                    })
                };
                if (this.dottedLinePos && item.position === this.dottedLinePos) {
         
                    const v = this.dottedLinePos === 1 ? McGeVector3d.kYAxis.clone().mult(this.size / 4) : McGeVector3d.kYAxis.clone().mult(this.size / 4).negate();
                    entityArr.forEach(ent => {
         
                        ent.move(lastPt, lastPt.clone().addvec(v))
                    })
                }
                allEntityArr.push(...entityArr);
            });
            return {
          entityArr: allEntityArr }
        }
        // 绘制特殊符号
        private drawSpecialSymbol(lastPt: McGePoint3d): {
          entityArr: McDbEntity[] } {
         
            const entityArr: McDbEntity[] = [];
            const allEntityArr = [];
            this.specialSymbol.forEach(item => {
         
                entityArr.length = 0;
                if (item.typeName === symbolName.BellShapedWeldSeam) {
         
                    // 喇叭形焊缝
                    const basePt = lastPt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size * (5 / 4)));
                    const v = McGeVector3d.kXAxis.clone().mult(this.size / 8);
                    const pt1 = basePt.clone().addvec(v);
                    const pt2 = pt1.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.size / 8));
                    const line = new McDbLine(pt1, pt2);
                    const arc = new McDbArc();
                    const r = this.size * (3 / 4);
                    arc.center = pt2.clone().addvec(McGeVector3d.kXAxis.clone().mult(r));
                    arc.radius = r;
                    arc.startAngle = Math.PI / 2;
                    arc.endAngle = Math.PI;
                    const _pt = basePt.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.size));
                    const _line = line.clone() as McDbLine;
                    _line.mirror(basePt, _pt);
                    const _arc = arc.clone() as McDbArc;
                    _arc.mirror(basePt, _pt);
                    entityArr.push(line, arc, _line, _arc)
                } else if (item.typeName === symbolName.SingleBellShapedWeldSeam) {
         
                    // 单边喇叭形焊缝
                    const pt1 = lastPt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size * (3 / 8)));
                    const pt2 = pt1.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.height));
                    const line = new McDbLine(pt1, pt2)
                    const point1 = pt1.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size / 4));
                    const point2 = point1.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.size / 8));
                    const line1 = new McDbLine(point1, point2);
                    const arc = new McDbArc();
                    arc.center = point2.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size * (3 / 4)));
                    arc.radius = this.size * (3 / 4);
                    arc.startAngle = Math.PI / 2;
                    arc.endAngle = Math.PI;
                    entityArr.push(line, line1, arc)
                } else if (item.typeName === symbolName.HeapWeldSeam) {
         
                    // 堆焊缝
                    const basePt = lastPt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size * (3 / 8)));
                    const radius = this.size * (9 / 16);
                    const arc = new McDbArc();
                    arc.center = basePt.clone().addvec(McGeVector3d.kXAxis.clone().mult(radius));
                    arc.radius = radius;
                    arc.startAngle = 0;
                    arc.endAngle = Math.PI;
                    const _arc = arc.clone() as McDbArc;
                    const midPt = basePt.clone().addvec(McGeVector3d.kXAxis.clone().mult(radius * 2))
                    _arc.mirror(midPt, midPt.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.size)));
                    entityArr.push(arc, _arc);
                } else if (item.typeName === symbolName.SeamSeam) {
         
                    // 锁边焊缝
                    const basePt = lastPt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size * (3 / 8)));
                    const _v = McGeVector3d.kYAxis.clone().mult(this.size / 4).negate();
                    const pt2 = basePt.clone().addvec(_v);
                    const v = McGeVector3d.kXAxis.clone().mult(this.height);
                    const pt3 = pt2.clone().addvec(v);
                    const pt4 = pt3.clone().addvec(_v.clone().mult(7 / 4));
                    const pt5 = pt4.clone().addvec(v.clone().negate());
                    const pl = new McDbPolyline();
                    const pts = [basePt, pt2, pt3, pt4, pt5];
                    pts.forEach(pt => pl.addVertexAt(pt));
                    const point1 = basePt.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.height));
                    const point3 = point1.clone().addvec(v);
                    const _pl = new McDbPolyline();
                    const _pts = [point1, basePt, point3];
                    _pts.forEach(pt => _pl.addVertexAt(pt));
                    entityArr.push(pl, _pl)
                } else if (item.typeName === symbolName.LockTheSlopeOpening) {
         
                    // 锁边坡口
                    const basePt = lastPt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size)).addvec(McGeVector3d.kYAxis.clone().negate().mult(this.size / 4));
                    const vec = McGeVector3d.kXAxis.clone().mult(this.size * (7 / 16))
                    const pt2 = basePt.clone().addvec(vec);
                    const pt3 = pt2.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.size * (7 / 16)).negate());
                    const pt4 = pt3.clone().addvec(vec.clone().negate());
                    const pl = new McDbPolyline();
                    const pts = [basePt, pt2, pt3, pt4];
                    pts.forEach(pt => pl.addVertexAt(pt));
                    const point = basePt.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.size * (5 / 8)));
                    const v = McGeVector3d.kXAxis.clone().mult(this.size * (9 / 16));
                    const point1 = point.clone().addvec(v);
                    const point2 = point.clone().addvec(v.clone().negate());
                    const _pl = new McDbPolyline();
                    const _pts = [point1, basePt, point2];
                    _pts.forEach(pt => _pl.addVertexAt(pt));
                    entityArr.push(pl, _pl)
                }
                if (item.position === symbolPos.down) {
         
                    entityArr.forEach(ent => {
         
                        (ent as McDbEntity).mirror(this.fixedPoint, this.fixedPoint.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size * 10)));
                    })
                };
                if (this.dottedLinePos && item.position === this.dottedLinePos) {
         
                    const v = this.dottedLinePos === 1 ? McGeVector3d.kYAxis.clone().mult(this.size / 4) : McGeVector3d.kYAxis.clone().mult(this.size / 4).negate();
                    entityArr.forEach(ent => {
         
                        ent.move(lastPt, lastPt.clone().addvec(v))
                    })
                }
                allEntityArr.push(...entityArr);
            })
            return {
          entityArr: allEntityArr }
        }
        // 绘制辅助符号
        private drawAuxiliarySymbol(lastPt: McGePoint3d): {
          entityArr: McDbEntity[] } {
         
            const entityArr = [];
            const allEntityArr = [];
            this.auxiliarySymbol.forEach(item => {
         
                entityArr.length = 0;
                const basePt = lastPt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size)).addvec(McGeVector3d.kYAxis.clone().mult(this.size * (21 / 16)));
                const v = McGeVector3d.kXAxis.clone().mult(this.size * (5 / 8));
                const pt1 = basePt.clone().addvec(v);
                const pt2 = basePt.clone().addvec(v.clone().negate());
                if (item.typeName === symbolName.FirstPlaneSymbol) {
         
                    // 第一种平面符号
                    const line = new McDbLine(pt1, pt2);
                    entityArr.push(line)
                } else if (item.typeName === symbolName.SecondConcaveSymbol) {
         
                    // 第二种凹面符号
                    const midPt = basePt.clone().addvec(McGeVector3d.kYAxis.clone().negate().mult(this.size * (3 / 8)));
                    const arc = new McDbArc();
                    arc.computeArc(pt1.x, pt1.y, midPt.x, midPt.y, pt2.x, pt2.y);
                       entityArr.push(arc)
                } else if (item.typeName === symbolName.SecondConvexeSymbol) {
         
                    // 第二种凸面符号
                    const midPt = basePt.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.size * (3 / 8)));
                    const arc = new McDbArc();
                    arc.computeArc(pt1.x, pt1.y, midPt.x, midPt.y, pt2.x, pt2.y);
                    entityArr.push(arc)
                } else if (item.typeName === symbolName.SecondPlaneSymbol) {
         
                    // 第二种平面符号
                    const basePt = lastPt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size)).addvec(McGeVector3d.kYAxis.clone().mult(this.size / 4));
                    const pt1 = basePt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size * (11 / 16)));
                    const pt2 = basePt.clone().addvec(McGeVector3d.kXAxis.clone().negate().mult(this.size / 4)).addvec(McGeVector3d.kYAxis.clone().mult(this.size * (15 / 16)));
                    const line = new McDbLine(pt1, pt2);
                     entityArr.push(line)
                } else if (item.typeName === symbolName.ThirdPlaneSymbol) {
         
                    // 第三种平面符号
                    const basePt = lastPt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size)).addvec(McGeVector3d.kYAxis.clone().mult(this.size / 4));
                    const pt1 = basePt.clone().addvec(McGeVector3d.kXAxis.clone().negate().mult(this.size * (11 / 16)));
                    const pt2 = basePt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size / 4)).addvec(McGeVector3d.kYAxis.clone().mult(this.size * (15 / 16)));
                    const line = new McDbLine(pt1, pt2);
                    entityArr.push(line)
                } else if (item.typeName === symbolName.FirstConvexeSymbol) {
         
                    // 第一种凸面符号
                    const basePt = lastPt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size)).addvec(McGeVector3d.kYAxis.clone().mult(this.size * (5 / 8)));
                    const arc = new McDbArc();
                    arc.center = basePt;
                    arc.startAngle = 0;
                    arc.endAngle = Math.PI / 2;
                    arc.radius = this.size * (5 / 8);
                    entityArr.push(arc)
                } else if (item.typeName === symbolName.FirstConcaveSymbol) {
         
                    // 第一种凹面符号
                    const basePt = lastPt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size)).addvec(McGeVector3d.kYAxis.clone().mult(this.size * (5 / 8)));
                    const radius = this.size * (5 / 8);
                    const center = basePt.clone().addvec(McGeVector3d.kXAxis.clone().mult(radius)).addvec(McGeVector3d.kYAxis.clone().mult(radius));
                    const arc = new McDbArc();
                    arc.center = center;
                    arc.radius = radius;
                    arc.startAngle = Math.PI;
                    arc.endAngle = Math.PI * (3 / 2);
                    entityArr.push(arc)
                } else if (item.typeName === symbolName.FlattenWeldSeam) {
         
                    // 削平符号
                    const basePt = lastPt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size)).addvec(McGeVector3d.kYAxis.clone().mult(this.size));
                    const v = McGeVector3d.kXAxis.clone().mult(this.size * (7 / 16));
                    const pt1 = basePt.clone().addvec(v);
                    const pt2 = basePt.clone().addvec(v.clone().negate());
                    const line = new McDbLine(pt1, pt2);
                    const point3 = basePt.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.size / 8));
                    const vec = McGeVector3d.kXAxis.clone().mult(this.size * (7 / 32));
                    const point2 = point3.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.size * (7 / 16))).addvec(vec.clone().negate());
                    const point1 = point2.clone().addvec(vec.clone().mult(2));
                    const _vec = point1.sub(point3);
                    const point4 = point1.clone().addvec(_vec);
                    const ptsArr = [point1, point2, point3, point4];
                    const pl = new McDbPolyline();
                    ptsArr.forEach(pt => pl.addVertexAt(pt));
                    entityArr.push(pl, line)
                } else if (item.typeName === symbolName.ToeAareaTranSmoothly) {
         
                    // 趾部平滑过渡
                    const basePt = lastPt.clone().addvec(McGeVector3d.kXAxis.clone().mult(this.size));
                    const pt1 = basePt.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.size * (5 / 4)));
                    const pt2 = pt1.clone().addvec(McGeVector3d.kYAxis.clone().mult(this.size * (3 / 8)));
                    const line = new McDbLine(pt1, pt2);
    
                    const radius = this.size * (7 / 32);
                    const center = pt1.clone().addvec(McGeVector3d.kXAxis.clone().mult(radius));
                    const arc = new McDbArc();
                    arc.center = center;
                    arc.radius = radius;
                    arc.startAngle = Math.PI;
                    arc.endAngle = 0;
    
                    const _arc = arc.clone() as McDbArc;
                    _arc.mirror(basePt, pt1);
    
                    entityArr.push(line, arc, _arc)
                }   
                if (item.position === symbolPos.down) {
         
                    entityArr.forEach(item => {
         
                        item.mirror(this.fixedPoint, lastPt)
                    })
                }
                if (this.dottedLinePos && item.position === this.dottedLinePos) {
         
                    const v = this.dottedLinePos === 1 ? McGeVector3d.kYAxis.clone().mult(this.size / 4) : McGeVector3d.kYAxis.clone().mult(this.size / 4).negate();
                    entityArr.forEach(ent => {
         
                        ent.move(lastPt, lastPt.clone().addvec(v))
                    })
                }
                allEntityArr.push(...entityArr)
            })
            return {
          entityArr: allEntityArr }
        }
    
  7. 暴露获取、设置实体内部数据的属性或方法

        //设置或获取标记定位点
        public set weldingPosition(val: McGePoint3d) {
         
            this.position = this.fixedPoint = this.turningPoint = val.clone();
        }
        public get weldingPosition(): McGePoint3d {
         
            return this.position;
        }
        //设置或获取标记转折点
        public set turningPoint(val: McGePoint3d) {
         
            this.turningPt = this.fixedPoint = val.clone();
        }
        public get turningPoint(): McGePoint3d {
         
            return this.turningPt;
        }
        //设置或获取标记定点
        public set fixedPos(val: McGePoint3d) {
         
            this.fixedPoint = val.clone();
        }
        public get fixedPos(): McGePoint3d {
         
            return this.fixedPoint;
        }
        //设置或获取标记箭头尺寸
        public set dimSize(val: number) {
         
            this.size = val;
            this.height = this.size * (7 / 8)
        }
        public get dimSize(): number {
         
            return this.size;
        }
        //设置或获取虚线位置
        public set dottedLinePos(val: number) {
         
            this.dottedPos = val;
        }
        public get dottedLinePos(): number {
         
            return this.dottedPos;
        }
        //设置或获取焊接说明
        public set weldingSymbolInfo(val: string) {
         
            this.weldingInfo = val;
        }
        public get weldingSymbolInfo(): string {
         
            return this.weldingInfo;
        }
        private getBox(entityArr: McDbEntity[]) {
         
            let _minPt, _maxPt = null;
            entityArr.forEach(entity => {
         
                if (entity instanceof McDbMText) {
         
                    const textStyleId = MxCpp.getCurrentMxCAD().getDatabase().getCurrentlyTextStyleId();
                    entity.textStyleId = textStyleId;
                    entity.reCompute();
                }
                const {
          minPt, maxPt } = entity instanceof McDbMText ? MxCADUtility.getTextEntityBox(entity, false) : entity.getBoundingBox();
                if (!_minPt) _minPt = minPt.clone();
                if (!_maxPt) _maxPt = maxPt.clone();
                if (minPt.x < _minPt.x) _minPt.x = minPt.x;
                if (minPt.y < _minPt.y) _minPt.y = minPt.y;
                if (maxPt.x > _maxPt.x) _maxPt.x = maxPt.x;
                if (maxPt.y > _maxPt.y) _maxPt.y = maxPt.y;
            });
            if (_minPt && _maxPt) {
         
                this.assertWrite();
                this.maxPt = _maxPt;
                this.minPt = _minPt;
            }
        }
        // 获取包围盒
        public getBoundingBox(): {
          minPt: McGePoint3d; maxPt: McGePoint3d; ret: boolean; } {
         
            const allEntityArr = this.getAllEntity();
            this.getBox(allEntityArr);
            return {
          minPt: this.minPt, maxPt: this.maxPt, ret: true }
        }
        //获取或设置基本符号.
        public getBaseSymbok(): symbolType[] {
         
            return this.baseSymbok
        }
        public setBaseSymbok(val: symbolType[]) {
         
            const res = val.filter(item => item.typeName !== symbolName.none);
            this.baseSymbok = res;
        }
        //获取或设置辅助符号
        public getAuxiliarySymbol(): symbolType[] {
         
            return this.auxiliarySymbol
        }
        public setAuxiliarySymbol(val: symbolType[]) {
         
            const res = val.filter(item => item.typeName !== symbolName.none);
            this.auxiliarySymbol = res;
        }
        //获取或设置特殊符号
        public getSpecialSymbol(): symbolType[] {
         
            return this.specialSymbol
        }
        public setSpecialSymbol(val: symbolType[]) {
         
            const res = val.filter(item => item.typeName !== symbolName.none);
            this.specialSymbol = res;
        }
        //获取或设置补充符号
        public getSuppleSymbol(): symbolType[] {
         
            return this.suppleSymbol
        }
        public setSuppleSymbol(val: symbolType[]) {
         
            const res = val.filter(item => item.typeName !== symbolName.none);
            this.suppleSymbol = res;
        }
        //获取或设置左尺寸
        public getLeftDim(): symbolDim[] {
         
            return this.leftDim;
        }
        public setLeftDim(val: symbolDim[]) {
         
            const res = val.filter(item => item.content !== '');
            this.leftDim = res;
        }
        //获取或设置上尺寸
        public getTopDim(): symbolDim[] {
         
            return this.topDim;
        }
        public setTopDim(val: symbolDim[]) {
         
            const res = val.filter(item => item.content !== '');
            this.topDim = res;
        }
        //获取或设置右尺寸
        public getRightDim(): symbolDim[] {
         
            return this.rightDim;
        }
        public setRightDim(val: symbolDim[]) {
         
            const res = val.filter(item => item.content !== '');
            this.rightDim = res;
        }
        //获取或设置交错焊缝
        public getIntWeldSeam(): symbolDim[] {
         
            return this.interlacedWeldSeam
        }
        public setIntWeldSeam(val: symbolDim[]) {
         
            const res = val.filter(item => item.content !== '');
            this.interlacedWeldSeam = res;
        }
    

使用焊接符号标注

根据焊接符号标注于直线、圆弧或圆时标注将垂直于曲线的切线上的位置特点,我们可以通过识别标注点所在的实体类型获取该实体在标注点的切线方向和位置,并以此来确定标注的旋转角度和方向。下面为焊接符号标注的基础的用法,用户可在此基础上为焊接符号设置更多属性值,如补充符号、特殊符号、上下标注等:

let isArc = false;
// 设置标记位置点
const getPos = new MxCADUiPrPoint();
getPos.setMessage('请设置定位点或直线或圆弧');
const pos = await getPos.go();
if (!pos) return;
weldingSymbol.weldingPosition = pos;
// 定义过滤器
const filter = new MxCADResbuf()
// 添加对象类型,选择集只选择文字类型的对象
filter.AddMcDbEntityTypes("ARC,CIRCLE")
let objId = MxCADUtility.findEntAtPoint(pos.x, pos.y,pos.z,-1,filter);
if(objId.isValid()) isArc = true;
// 设置标记转折点
const getTurnPt = new MxCADUiPrPoint();
getTurnPt.setMessage('请设置引线转折点');
getTurnPt.setUserDraw((pt, pw) => {
   
    if(isArc){
   
        const arc = objId.getMcDbEntity() as McDbArc;
        const point = arc.getClosestPointTo(pt, true).val;
        weldingSymbol.weldingPosition = point;
    };
    weldingSymbol.turningPoint = pt;
    pw.drawMcDbEntity(weldingSymbol);
});
const turningPt = await getTurnPt.go();
if (!turningPt) return;
weldingSymbol.turningPoint = turningPt;

// 设置标记定点
const getFixedPt = new MxCADUiPrPoint();
getFixedPt.setMessage('拖动确定定位点');
getFixedPt.setUserDraw((pt, pw) => {
   
    const clone = weldingSymbol.clone() as McDbTestWeldingSymbol;
    clone.fixedPos = pt;
    pw.drawMcDbEntity(clone)
});
const fixedPt = await getFixedPt.go();
if (fixedPt) weldingSymbol.fixedPos = fixedPt;
const mxcad = MxCpp.getCurrentMxCAD();
mxcad.drawEntity(weldingSymbol);

效果演示

在上述介绍中,我们已经实现了焊接符号的自定义实体,通过该实体与我们的mxcad项目结合,我们就能够实现更完善的焊接符号标注功能。
基础效果演示:
image-20250530141023471.png

根据上述内容可做扩展开发,根据焊接符号特性设置对应的弹框,其示例效果如下:
image-20250530141303952.png

相关文章
|
存储 XML 安全
Jetpack DataStore 你总要了解一下吧?
一、DataStore 介绍 DataStore 是 Android Jetpack 中的一个组件,它是一个数据存储的解决方案,跟 SharedPreferences 一样,采用key-value形式存储。 DataStore 保证原子性,一致性,隔离性,持久性。尤其是,它解决了 SharedPreferences API 的设计缺陷。 Jetpack DataStore 是经过改进的新版数据存储解决方案,旨在取代 SharedPreferences,让应用能够以异步、事务方式存储数据。
1206 0
Jetpack DataStore 你总要了解一下吧?
|
6月前
|
开发者
(在线CAD控件)网页CAD实现粗糙度标注的方法
本文介绍了通过MxCAD二次开发实现机械制图中表面粗糙度符号的标注功能。表面粗糙度符号用于表示零件表面微观不平度,基本形式为三角形,可结合不同修饰(如加横线、小圆等)表达具体加工要求。文章解析了符号含义,并基于McDbCustomEntity类创建自定义实体,实现符号绘制、数据持久化、夹点设置等功能。此外,还提供了用户交互式标注方法,支持根据直线、圆弧或指定角度生成粗糙度标注。最后展示了效果演示及扩展开发示例,便于开发者进一步定制功能。
|
7月前
|
人工智能
WEB CAD 利用AI编程实现多行文本的二次开发
本文介绍了在MxCAD插件中实现自定义编辑器实体类的功能,重点展示如何通过MxCADMText类在CAD中渲染和管理富文本。文章详细说明了注册同心圆实体文本的步骤,包括实现自定义文本类、注册自定义文本以及交互式修改参数的方法。此外,还扩展实践了粗糙度实体文本的注册与应用,涵盖构造粗糙度自定义实体文本类、注册及初始化过程,并通过示例图展示了运行效果。这些功能可帮助用户将复杂图形以文本形式插入多行文本中,提升项目设计效率。
|
7月前
|
缓存 前端开发 API
(网页系统集成CAD功能)在线CAD中配置属性的使用教程
本文介绍了Mxcad SDK在线预览和编辑CAD图纸的功能及配置方法。通过Vite、CDN或Webpack实现集成,用户可自定义设置以满足项目需求。主要内容包括:1)`createMxCad()`方法的初始属性配置,如画布ID、WASM文件路径、字体加载路径等;2)`MxFun.setIniset()`方法提供的更多CAD初始配置;3)`McObject`对象API用于动态调整视图背景色、浏览模式等。此外,还提供了在线Demo(https://demo2.mxdraw3d.com:3000/mxcad/)供用户测试实时效果。
|
8月前
|
存储 JavaScript
(ERP系统查看DWG)MxCAD APP调用内部弹框的方法
MxCAD APP 二次开发提供了调用项目内部弹框的接口,以保持样式统一。用户需创建 `test_dialog` 文件夹并依次创建 `dialog.ts`、`dialog.vue` 和 `index.ts` 文件来注册、构建和渲染弹框。通过 `useDialogIsShow` 钩子函数控制弹框显示,并可在方法中直接调用 `dialog.showDialog()` 来控制弹框显隐。此外,还支持监听确认或取消事件获取数据,以及通过配置 `vite.config.ts` 解决样式冲突问题。最终在 `src/index.ts` 中引入相关文件即可实现弹框功能。
|
8月前
|
人工智能 Linux iOS开发
Linux下搭建本地deepseek(附文档下载)
本文介绍了在Linux上搭建本地DeepSeek的步骤。主要涉及安装ollama、下载deepseek模型(1.5b参数版本)和配置ChatboxAI客户端。通过命令行安装ollama后,使用`ollama run deepseek-r1:1.5b`下载模型,并配置环境变量以确保服务正常运行。最后,通过ChatboxAI与模型进行交互。整个过程适合初学者,服务器配置为4核CPU和8GB内存,无GPU,响应速度稍有延迟但可接受。相关资源链接已提供。
1109 2
|
9月前
|
存储 JSON JavaScript
WEB CAD插件通过上下文对象MxPluginContext修改UI界面的方法
本文介绍了如何使用MxPluginContext动态控制MxCAD项目的UI界面。通过该上下文对象,开发者可以灵活设置UI配置,如控制操作栏显隐、编辑按钮、添加侧边栏等。具体方法包括调用`getUiConfig()`获取并修改`mxUiConfig.json`中的属性,实现界面的定制化。此外,还提供了控制命令行聚焦的功能,解决输入框焦点锁定问题。详细代码示例和效果对比图展示了具体实现步骤,帮助开发者更好地适配项目需求。
有哪些CAD软件支持(国产操作系统)麒麟操作系统
CAD梦想画图是由成都梦想凯德科技自主研发的轻量级CAD软件,专为国产操作系统如麒麟、统信设计。支持AutoCAD所有版本的dwg二维图纸,具备精准显示、测量、标注、绘图修改、文字查找及批注等功能,操作流畅,无需安装字体。用户可通过应用商店轻松安装,适合新手和专业人士使用。
|
10月前
|
存储 JavaScript 算法
(html在线预览cad图纸插件)网页CAD绘制条形码、二维码的教程
本文介绍了如何在mxcad中绘制条形码和二维码。对于条形码,首先根据应用场景选择合适的编码标准(如CODE39、EAN13等),通过编码规则将数据转换为二进制,并利用`McDbHatch`绘制条和空的组合,同时支持自定义实体及属性管理。 对于二维码,因其能存储更多信息且具备更强纠错能力,采用开源库QRCode.js进行编码处理,再通过`McDbHatch`绘制黑白矩阵,同样封装成自定义实体以便管理和扩展。文中还给出了完整的绘制流程与效果展示,包括创建二维码对象、设置参数、调用绘制方法以及最终的效果图。整个过程体现了灵活运用API与第三方库来实现复杂图形绘制的能力。