（VUE3集成CAD）在线CAD实现焊接符号自定义

前言

在工程制图和制造领域，焊接符号（Welding Symbols）是用于表示焊缝类型、尺寸、位置以及工艺要求的标准化图形语言。广泛应用于机械设计、钢结构、船舶制造、压力容器等行业中，帮助技术人员理解焊接意图。

本文将介绍焊接符号的基本结构、符号、含义，并根据焊接符号的特性通过网页CAD实现焊接符号类，实现绘制焊接符号的功能。

焊接符号特性分析

一、焊接符号的基本构成

焊接符号由以下几个基本部分组成：

1.参考线：焊接符号的核心部分，通常是一条水平线，所有其他符号都依附于这条线。参考线分为两部分，箭头上面就是上方区域，箭头下面就是下方区域，如下图：

2.箭头：箭头指向要焊接的位置，连接参考线和被焊件的具体部位。

3.基本焊接符号:表示焊缝的类型，如角焊缝、对接焊缝等，绘制在参考线的上方或下方。

4.尾部：可选部分，用于标注焊接方法、工艺编号或其他说明信息（如"GTAW"、"SMAW"等）。

5.补充符号：包括现场焊缝符号、周围焊缝符号、熔透深度符号等。

6.尺寸标注：表示焊缝的具体尺寸，如焊脚高度、坡口角度、根部间隙等。

二、焊接符号的附加元素

1.现场焊缝符号:一个小旗子标志，表示该焊缝需在现场施工时完成，而非在工厂内完成。

2.周围焊缝符号:一个圆圈，表示焊缝应围绕整个接合处进行。

3.熔透符号:表示焊接过程中需要完全熔透母材。

4.打底焊道符号:表示打底焊或衬垫焊。

三、焊接尺寸标注方法

焊接符号中常常包含尺寸信息，以指导焊工操作。以下是常见尺寸标注方式：

3.1.角焊缝尺寸标注

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

3.2.对接焊缝尺寸标注

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

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

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

ts 复制代码

 // 符号位置
   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.基本结构设置

ts 复制代码

  // 焊接符号自定义实体
   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.构造函数和创建方法

ts 复制代码

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

4.数据持久化

ts 复制代码

 // 读取自定义实体数据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.设置标注夹点及夹点移动规则

ts 复制代码

  // 移动自定义对象的夹点
       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.绘制标注实体

ts 复制代码

// 绘制实体
       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.暴露获取、设置实体内部数据的属性或方法

ts 复制代码

       //设置或获取标记定位点
       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;
       }

使用焊接符号标注

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

ts 复制代码

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项目结合，我们就能够实现更完善的焊接符号标注功能,demo查看地址demo2.mxdraw3d.com:3000/mxcad/。

基础效果演示：

根据上述内容可做扩展开发，根据焊接符号特性设置对应的弹框，其示例效果如下：