import { Circle, Contour, ConverToPolylineAndSplitArc, Shape, ShapeManager } from 'cadapi' import type { Polyline } from 'cadapi' import { Vector3 } from 'three' import { PolylineHelper } from '../../common/LayoutEngine/PolylineHelper.js' import type { Curve2d } from '../../common/base/CAD.js' import { Arc2d, Line2d, Point2d } from '../../common/base/CAD.js' import { PlaceStyle, SizeExpand, PlaceBlock, PlaceBlockDetail, PlaceBorderContour, PlaceSpace, PlaceMaterial } from '../../confClass.js' import { equal, getDis, getDis2, getDis_PointLine, getRect } from '../../common/base/MathComm.js' import { getPlacePosition } from '../../common/base/PlaceStyleHelper' import { SpacePlus } from './SpacePlus' /**板件计算工具类 小板轮廓，走刀路径等 */ export class BlockPlus { /** 小板初始化：1各种轮廓|走刀路径|，2尺寸扩展后的轮廓与走刀路径 * 配置入参 * isRectBlockChamfer = false, // 矩形板件倒角开料 isUnRegularBlockChamfer = false, // 异形板件倒角开料 preMillingSize = 0, // 预铣尺寸 */ static initBlock(block: PlaceBlock, placeMaterial: PlaceMaterial, params: any) { if(block.blockDetail == null) { console.error('BlockPlus.initBlock: block.blockDetail is undefined', block) return } if (block.blockDetail.borderContour) return // 已初始化 const { isRectBlockChamfer = false, // 矩形板件倒角开料 isUnRegularBlockChamfer = false, // 异形板件倒角开料 preMillingSize = 0, // 预铣尺寸 helpCutStyle = 0, // 辅助开料方式(0同刀辅助开料 1小刀辅助开料) useSameKnifeToHelpCutStyle helpCutGap = 2, // 同刀辅助开料缝隙 } = params if (!block.blockDetail) { return } const pm = placeMaterial const bd = block.blockDetail if (pm == null) { return // 异常 } const cutKnifeR = pm.diameter / 2 const cutGap = pm.cutKnifeGap // 开料偏移值 ,矩形波倒角 bd.offsetKnifeRadius = pm.diameter / 2 bd.isOffsetRounding = true // 默认要倒角 bd.preMillingSize = pm.preMillingSize if (bd.points.length == 0) // 矩形板，设置不倒角 { bd.isOffsetRounding = isRectBlockChamfer } else // 异形板 { // 异形板倒角 bd.isOffsetRounding = isUnRegularBlockChamfer } // 初始化 小板基础轮廓 // 1.原始轮廓,成品轮廓 const border_final = this.createFinalBorder(bd, block) // 2.开料轮廓 <不含预铣> const border_org = this.createOrgBorder(bd) bd.borderContour = new PlaceBorderContour(PlaceStyle.FRONT, border_final, border_org) // 3.开料轮廓_带预铣, 外扩尺寸 bd.borderContour.borderPreMilling = border_org bd.preMillingExpandSize = new SizeExpand() if (preMillingSize > 0.0001) { const rt = this.creatOrgBorderWithPrevCut(block, border_org, preMillingSize) bd.borderContour.borderPreMilling = rt?.newBorders || [] bd.preMillingExpandSize = rt?.newSizeExpand || new SizeExpand() // console.log('开料轮廓_带预铣, 外扩尺寸==》after', block, rt.newSizeExpand) } // 4. 板内走刀路径,板内空间 const innerGroup = this.analyeInners(bd, cutKnifeR, cutGap) bd.borderContour.borderModelThrough = innerGroup.borders_inner_org bd.borderContour.borderModelThroughR = innerGroup.borders_inner_r bd.borderContour.cutLinesModelThrough = innerGroup.borders_inner_cut bd.borderContour.borderInnerPlace = innerGroup.borders_inner_place bd.borderContour.blockInnerSpace = innerGroup.spaces // 5 造型外扩轮廓， 外扩尺寸 const { pls_model, sizeout: sizeout_model } = this.createPolyline_model(block) bd.borderContour.polylinesOutModel = pls_model bd.modelExpandSize = sizeout_model // 6. 2V刀路 外扩轮廓，外扩尺寸 const { pls_2v, sizeout_2v } = this.createPolyline_2vModel(block) bd.borderContour.polylines2vModel = pls_2v || [] bd.vKnifeModelExpandSize = sizeout_2v // 7.同刀辅助 外扩尺寸 let isUseSameKnifeToHelpCut = helpCutStyle || 0 let useSameKnifeToHelpCutGap = helpCutGap || 0 const isSameKnifeToCut = isUseSameKnifeToHelpCut && useSameKnifeToHelpCutGap > 0 if (isSameKnifeToCut == false || bd.isUseSameKnifeToHelpCut == false) { // 未启动同刀辅助， 或 该小板 不需要同刀辅助 bd.useSameKnifeToHelpCutGap = 0 bd.sameKnifeHelpExpandSize = new SizeExpand() } else { const gap = useSameKnifeToHelpCutGap bd.useSameKnifeToHelpCutGap = gap bd.sameKnifeHelpExpandSize = new SizeExpand({ left: gap, right: gap, under: gap, upper: gap }) } // 2V刀路,预洗,同刀辅助开料，出板造型刀 this.resetBlock(block, pm) } /** 重设小板 ，因为板材重新设置 预铣值 或 板外下刀 */ static resetBlock(block: PlaceBlock, placeMaterial: PlaceMaterial) { if (!block.blockDetail) { console.error('BlockPlus.resetBlock: block.blockDetail is undefined', block) return } const pm = placeMaterial const bd = block.blockDetail const preMillingSize = pm.preMillingSize // startDebug(block); if (!bd.borderContour) { console.error('BlockPlus.resetBlock: bd.borderContour is undefined', block) return } // 开料刀 修改了,内部空间发生变化 if (!equal(bd.offsetKnifeRadius, pm.diameter / 2)) { bd.offsetKnifeRadius = pm.diameter / 2 bd.borderContour.cutKnifeChanged() // 4. 板内走刀路径,板内空间 const innerGroup = this.analyeInners(bd, pm.diameter / 2, pm.cutKnifeGap) bd.borderContour.borderModelThrough = innerGroup.borders_inner_org bd.borderContour.cutLinesModelThrough = innerGroup.borders_inner_cut bd.borderContour.borderInnerPlace = innerGroup.borders_inner_place bd.borderContour.blockInnerSpace = innerGroup.spaces } // 因为预铣, 同刀辅助会影响到开料走刀等轮廓，所以要将受影响的轮廓清空，需要的时候再生成 // 预铣 if (!equal(bd.preMillingSize, pm.preMillingSize)) { bd.preMillingSize = preMillingSize bd.borderContour.preValueChanged() } // 同刀辅助 let newTDFZ = 0 if (pm.isHelpCut && pm.helpCutGap > 0 && block.blockDetail.isUseSameKnifeToHelpCut) { newTDFZ = pm.helpCutGap block.blockDetail.sameKnifeHelpExpandSize = new SizeExpand({ left: newTDFZ, right: newTDFZ, upper: newTDFZ, under: newTDFZ }) } else { newTDFZ = 0 block.blockDetail.sameKnifeHelpExpandSize = new SizeExpand() } if (!equal(newTDFZ, bd.useSameKnifeToHelpCutGap)) { bd.useSameKnifeToHelpCutGap = newTDFZ bd.borderContour.sameKnifeGapChanged() } const cutRadius = (pm.diameter + pm.cutKnifeGap) / 2 // 预铣 let off1 = block.blockDetail.preMillingExpandSize || new SizeExpand() // 造型外扩 const off2 = block.blockDetail.modelExpandSize || new SizeExpand() // 2v 板外下刀 const off3 = block.blockDetail.vKnifeModelExpandSize || new SizeExpand() // 同刀辅助 let off4 = block.blockDetail?.sameKnifeHelpExpandSize || new SizeExpand() // 不启用 预铣 // if (preMillingSize < 0.0001) // off1 = new SizeExpand() if (newTDFZ < 0.001) off4 = new SizeExpand() // 预铣+同刀辅助+， 造型外扩，2v刀路 应该取最大值 const off = new SizeExpand() off.left = Math.max(off1.left + off4.left + cutRadius, off2.left, off3.left) off.right = Math.max(off1.right + off4.right + cutRadius, off2.right, off3.right) off.bottom = Math.max(off1.bottom + off4.bottom + cutRadius, off2.bottom, off3.bottom) off.top = Math.max(off1.top + off4.top + cutRadius, off2.top, off3.top) off.setSize() bd.currentSizeExpand = off } /** 小板是否有超出造型或二维刀路 */ static hasModelOutBlock(block: PlaceBlock): boolean { if (block.blockDetail == null) return false if (block.blockDetail.borderContour == null) return false if (block.blockDetail.borderContour.polylinesOutModel == null || block.blockDetail.borderContour.polylines2vModel == null) return false return block.blockDetail.borderContour.polylinesOutModel.length + block.blockDetail.borderContour.polylines2vModel.length > 0 } /** 获得 成品轮廓 isPlaced=false为不旋转的 */ static getFinalBorder(block: PlaceBlock, isPlaced = true, placeStyle?: PlaceStyle): Curve2d[] { const bu = this.getPlacedUnit(block, isPlaced, placeStyle) if (bu == null) { console.error('BlockPlus.getOrgBorderNew: bu is undefined', block) return [] } return bu.borderFinal } /** 获得 开料轮廓-不含预铣 isPlaced=false为不旋转的 */ static getOrgBorder(block: PlaceBlock, isPlaced = true, placeStyle?: PlaceStyle): Curve2d[] { const bu = this.getPlacedUnit(block, isPlaced, placeStyle) if (bu == null) { console.error('BlockPlus.getOrgBorder: bu is undefined', block) return [] } return bu.borderOrg } /** 获得 开料轮廓-不含预铣 isPlaced=false为不旋转的 */ static getOrgBorderNew(block: PlaceBlock, isPlaced = true, placeStyle?: PlaceStyle): Curve2d[] { const bu = this.getPlacedUnitNew(block, isPlaced, placeStyle) if (bu == null) { console.error('BlockPlus.getOrgBorderNew: bu is undefined', block) return [] } return bu.borderOrg } /** 获得当前板 轮廓多段线 */ static getOrgPolyline(block: PlaceBlock): Polyline | null { if (block.blockDetail == null) { console.error('BlockPlus.getOrgPolyline: block.blockDetail is undefined', block) return null } const bd = block.blockDetail.borderContour if (bd == null) { console.error('BlockPlus.getOrgPolyline: bd is undefined', block) return null } if (!bd.polylineOrg) { const border = bd.borderOrg const pl = PolylineHelper.createByCurve2d(border) bd.polylineOrg = pl } return bd.polylineOrg } /** 获得 开料轮廓 _有预铣含预铣 */ static getBorder(block: PlaceBlock, isPlaced = true, placeStyle?: PlaceStyle): Curve2d[] { if (block.blockDetail == null) { console.error('BlockPlus.getBorder: block.blockDetail is undefined', block) return [] } let preSize = block.blockDetail.preMillingSize if (preSize < 0.0001) preSize = 0 // 初始 const baseContour = block.blockDetail.borderContour if (baseContour == null) { console.error('BlockPlus.getBorder: baseContour is undefined', block) return [] } if (!baseContour.border ||(Array.isArray(baseContour.border) && baseContour.border.length ==0)) // 生成 预铣轮廓 { const border = preSize == 0 ? baseContour.borderOrg : baseContour.borderPreMilling baseContour.border = border } // 放置后 const pbu = this.getPlacedUnit(block, isPlaced, placeStyle) if (pbu == null) { console.error('BlockPlus.getBorder_moving_new: pbu is undefined', block) return [] } if (!pbu.border) { pbu.border = this.transformBorder(baseContour.border, pbu.placeStyle, block.cutWidth, block.cutLength) } return pbu.border } /** 获得 开料轮廓—有预铣带预铣-有同刀辅助带同刀辅助 */ static getBorder_sameKnife(block: PlaceBlock, isPlaced = true, placeStyle?: PlaceStyle): Curve2d[] { if (block.blockDetail == null) { console.error('BlockPlus.getBorder_sameKnife: block.blockDetail is undefined', block) return [] } // 如果没有同刀辅助，直接返回开料轮廓 let helpCutGap = block.blockDetail.useSameKnifeToHelpCutGap if (helpCutGap < 0.001) helpCutGap = 0 // 初始 const baseContour = block.blockDetail.borderContour if (baseContour == null) { console.error('BlockPlus.getBorder_sameKnife: baseContour is undefined', block) return [] } if (!baseContour.borderSameKnifeHelpCut) { const borders = this.getBorder(block, false) if (helpCutGap == 0) // 无同刀辅助 { baseContour.borderSameKnifeHelpCut = borders } else { let rounding = block.blockDetail.isOffsetRounding if (block.isUnRegular) rounding = true // 异形板 必须倒角 baseContour.borderSameKnifeHelpCut = this.offsetCurves(borders, helpCutGap, rounding) // 必须倒角，否则 尖角超出 开料范围 } } // 放置后 const pbu = this.getPlacedUnit(block, isPlaced, placeStyle) if (pbu == null) { console.error('BlockPlus.getBorder_moving_new: pbu is undefined', block) return [] } if (!pbu.borderSameKnifeHelpCut) { pbu.borderSameKnifeHelpCut = this.transformBorder(baseContour.borderSameKnifeHelpCut, pbu.placeStyle, block.cutWidth, block.cutLength) } return pbu.borderSameKnifeHelpCut } /** 获得走刀路径(含预铣) isPlaced = false为不旋转 */ /** * * @param block 小板 * @param placeMaterial 开料大板 * @param isPlaced 是否旋转 * @param placeStyle 旋转后的放置方式 * @param config 配置 { isRectBlockChamfer: false, // 矩形板件倒角开料 isUnRegularBlockChamfer: false, // 异形板件倒角开料 } * @returns */ static getCutLines(block: PlaceBlock, placeMaterial: PlaceMaterial, isPlaced = true, placeStyle: PlaceStyle | undefined, config: any): Curve2d[] { // 走刀路径由开料轮廓(含预铣) border_plus 偏移一个刀半径而成 const { isRectBlockChamfer = false, // 矩形板件倒角开料 isUnRegularBlockChamfer = false, // 异形板件倒角开料 } = config if (!block.blockDetail) { console.error('BlockPlus.getCutLines: block.blockDetail is undefined', block) return [] } if (!block.blockDetail.borderContour) { console.error('BlockPlus.getCutLines: block.blockDetail.borderContour is undefined', block) return [] } // 初始 const baseContour = block.blockDetail.borderContour if (!baseContour.cutLines) { const borders = this.getBorder(block, false) // 偏移值 const offvalue = placeMaterial.diameter / 2 // 开料刀的一半 // 是否倒角 let isOffsetRounding = false // block.SaleBlockDetail.IsOffsetRounding; if (block.isUnRegular == false) // 矩形板，设置不倒角 { isOffsetRounding = isRectBlockChamfer } else // 异形板 { // 异形倒角 isOffsetRounding = isUnRegularBlockChamfer } baseContour.cutLines = this.offsetCurves(borders, offvalue, isOffsetRounding) } // 放置后 const pbu = this.getPlacedUnit(block, isPlaced, placeStyle) if (pbu == null) { console.error('BlockPlus.getBorder_moving_new: pbu is undefined', block) return [] } if (!pbu.cutLines) { pbu.cutLines = this.transformBorder(baseContour.cutLines, pbu.placeStyle, block.cutWidth, block.cutLength) } return pbu.cutLines } /** * 获得 同刀辅助 的走刀路径 * @param block 小板 * @param isPlaced 是否翻转 * @param placeStyle 翻转后的放置方式 * @param config 配置 * { isRectBlockChamfer: false, // 矩形板件倒角开料 isUnRegularBlockChamfer: false, // 异形板件倒角 } = config || {} * @returns */ static getCutLines_sameKnife(block: PlaceBlock, placeMaterial: PlaceMaterial, isPlaced = true, placeStyle?: PlaceStyle, config?: any): Curve2d[] { // 同刀辅助 走刀路径 由 开料轮廓 _含预铣_同刀辅助 偏移一个刀半径 厚度 而成 const { isRectBlockChamfer = false, // 矩形板件倒角开料 isUnRegularBlockChamfer = false, // 异形板件倒角开料 } = config || {} if (!block.blockDetail) { console.error('BlockPlus.getCutLines_sameKnife: block.blockDetail is undefined', block) return [] } // 不用同刀辅助 const helpCutGap = block.blockDetail.useSameKnifeToHelpCutGap if (helpCutGap < 0.001) { return this.getCutLines(block, placeMaterial, isPlaced, placeStyle, config) } const baseContour = block.blockDetail.borderContour if (baseContour == null) { console.error('BlockPlus.getCutLines_sameKnife: baseContour is undefined', block) return [] } if (!baseContour.cutLinesSameKnifeHelpCut) { const borders = this.getBorder_sameKnife(block, false) // 偏移值 const kr = placeMaterial.diameter / 2 // 开料刀的一半 // 同刀辅助 不倒角 , // 是否倒角 异形板必须倒角 let isOffsetRounding = false // block.SaleBlockDetail.IsOffsetRounding; if (block.isUnRegular == false) // 矩形板，设置不倒角 { isOffsetRounding = isRectBlockChamfer } else // 异形板 { isOffsetRounding = isUnRegularBlockChamfer } baseContour.cutLinesSameKnifeHelpCut = this.offsetCurves(borders, kr, isOffsetRounding) } // 放置后 const pbu = this.getPlacedUnit(block, isPlaced, placeStyle) if (pbu == null) { console.error('BlockPlus.getBorder_moving_new: pbu is undefined', block) return [] } if (!pbu.cutLinesSameKnifeHelpCut) { pbu.cutLinesSameKnifeHelpCut = this.transformBorder(baseContour.cutLinesSameKnifeHelpCut, pbu.placeStyle, block.cutWidth, block.cutLength) } return pbu.cutLinesSameKnifeHelpCut } /** * 获得 手动排版路径 包括板外下刀等轮廓 * 由开料轮廓 偏移 （ 预铣 ，同刀辅助， 开料刀半径 ， 缝隙/2 ) * 再与 二维刀路，板外小刀，造型外扩 合并起来的 */ static getBorder_moving(block: PlaceBlock, placeMaterial: PlaceMaterial, isPlaced = true, placeStyle?: PlaceStyle): Curve2d[] { if (!block.blockDetail || !block.blockDetail.borderContour) { console.error('BlockPlus.getBorder_moving: block.blockDetail or block.blockDetail.borderContour is undefined', block) return [] } this.theBlock = block const bd = block.blockDetail // 初始 const baseContour = bd.borderContour if (baseContour == null) { console.error('BlockPlus.getBorder_moving: baseContour is undefined', block) return [] } if (!baseContour.borderMoving) { // 1.开料轮廓<带预铣> const borders = this.getBorder(block, false) // 偏移值 = 同刀辅助 + 刀半径 + 缝隙 /2 const cutGap = block.blockDetail.useSameKnifeToHelpCutGap + (placeMaterial.diameter + placeMaterial.cutKnifeGap) / 2 // 是否倒角(如果倒角，手动排版，拖拉时，停靠点不便计算，所以设置成不倒角，然后截断> const isOffsetRounding = false // 原轮廓 let border_moving = this.offsetCurves(borders, cutGap, isOffsetRounding) const pl = this.borderToPolyline(border_moving) // 造型的外扩,2v刀路的 const pls_m = baseContour.polylinesOutModel.concat(baseContour.polylines2vModel) // 合并 const rpl = this.unionPolylines(pl, pls_m) // border_moving = this.polylineToBorder(rpl) baseContour.borderMoving = border_moving } // 放置后 const pbu = this.getPlacedUnit(block, isPlaced, placeStyle) if (pbu == null) { console.error('BlockPlus.getBorder_moving_new: pbu is undefined', block) return [] } return pbu.borderMoving } static getBorder_moving_new(block: PlaceBlock, pb: PlaceMaterial, isPlaced = true, placeStyle: PlaceStyle): Curve2d[] { if (block.blockDetail == null) { console.error('BlockPlus.getBorder_moving_new: block.blockDetail is undefined', block) return [] } this.theBlock = block const bd = block.blockDetail // 初始 const baseContour = bd.borderContour if (!baseContour) { console.error('BlockPlus.getBorder_moving_new: baseContour is undefined', block) return [] } if (!baseContour.borderMoving) { // 1.开料轮廓<带预铣> const borders = this.getBorder(block, false) // 偏移值 = 同刀辅助 + 刀半径 + 缝隙 /2 const cutGap = block.blockDetail.useSameKnifeToHelpCutGap + (pb.diameter + pb.cutKnifeGap) / 2 // 是否倒角(如果倒角，手动排版，拖拉时，停靠点不便计算，所以设置成不倒角，然后截断> const isOffsetRounding = false // 原轮廓 let border_moving = this.offsetCurves(borders, cutGap, isOffsetRounding) const pl = this.borderToPolyline(border_moving) // 造型的外扩,2v刀路的 const pls_m = baseContour.polylinesOutModel.concat(baseContour.polylines2vModel) // 合并 const rpl = this.unionPolylines(pl, pls_m) // border_moving = this.polylineToBorder(rpl) baseContour.borderMoving = border_moving } // 放置后 const pbu = this.getPlacedUnit(block, isPlaced, placeStyle) if (pbu == null) { console.error('BlockPlus.getBorder_moving_new: pbu is undefined', block) return [] } if (!pbu.borderMoving) { pbu.borderMoving = this.transformBorder(baseContour.borderMoving, pbu.placeStyle, block.cutWidth, block.cutLength) } return pbu.borderMoving } static getOutModelPloyline(block: PlaceBlock, isPlaced = true, placeStyle?: PlaceStyle): Polyline[] { if (!block.blockDetail || !block.blockDetail.borderContour) { console.error('BlockPlus.getOutModelPloyline: block.blockDetail or block.blockDetail.borderContour is undefined', block) return [] } const bd = block.blockDetail // 初始 const baseContour = bd.borderContour if (baseContour == null) { console.error('BlockPlus.getOutModelPloyline: baseContour is undefined', block) return [] } const pls_m = baseContour.polylinesOutModel.concat(baseContour.polylines2vModel) if (placeStyle == PlaceStyle.FRONT) return pls_m const pbu = this.getPlacedUnit(block, isPlaced, placeStyle) if (pbu == null) { console.error('BlockPlus.getOutModelPloyline: pbu is undefined', block) return [] } let newPls: Polyline[] = [] for (let pl of pls_m) { let newpl = this.transformPolyline(pl, pbu.placeStyle, block.cutWidth, block.cutLength) newPls.push(newpl) } return newPls } static theBlock /** 获取轮廓用于王者优化，预铣 + 同刀辅助 ，造型外扩 + 2维刀路外扩 */ static getBorder_WZYH(block: PlaceBlock, placeMaterial: PlaceMaterial, isPlaced = true, placeStyle?: PlaceStyle): Curve2d[] { this.theBlock = block const bd = block.blockDetail if (!bd || !bd.borderContour) { console.error('BlockPlus.getBorder_WZYH: block.blockDetail or block.blockDetail.borderContour is undefined', block) return [] } const baseContour = bd.borderContour // 生成 同刀辅助 路径 <原方向》 if (baseContour.borderKingOptimize == null) { // 开料轮廓 <同刀辅助> const borders = this.getBorder_sameKnife(block, false) // 偏移值= 同刀辅助 + 刀半径 + + 缝隙 /2 const cutGap = (placeMaterial.diameter + placeMaterial.diameter) / 2 // 是否倒角 < 如果倒角，手动排版，拖拉时，停靠点 不好计算,所以设置成不倒角，然后截断>, const isOffsetRounding = bd.isOffsetRounding // 走刀路径 const borders2 = this.offsetCurves(borders, cutGap, isOffsetRounding) const pl = this.borderToPolyline(borders2) // 造型的外扩,2v刀路的 const pls_m = baseContour.polylinesOutModel.concat(baseContour.polylines2vModel) // 合并 const rpl = this.unionPolylines(pl, pls_m) baseContour.borderKingOptimize = this.polylineToBorder(rpl) } // 放置后 const pbu = this.getPlacedUnit(block, isPlaced, placeStyle) if (pbu == null) { return [] } if (!pbu.borderKingOptimize) { pbu.borderKingOptimize = this.transformBorder(baseContour.borderKingOptimize, pbu.placeStyle, block.cutWidth, block.cutLength) } return pbu.borderKingOptimize } /** 获得 内部轮廓 <挖穿造型> */ static getBorders_inner(block: PlaceBlock, isPlaced = true, placeStyle?: PlaceStyle): Curve2d[][] { const bu = this.getPlacedUnit(block, isPlaced, placeStyle) if (bu == null) { console.error('BlockPlus.getBorders_inner: 获取板的内部轮廓失败', block) return [] } // 如果没有内部轮廓 if (bu.borderModelThrough == null) { const borders = this.getBorders_inner(block, false) const borders_off: Curve2d[][] = [] for (const border of borders) { const newBorder = this.transformBorder(border, bu.placeStyle, block.cutWidth, block.cutLength) borders_off.push(newBorder) } bu.borderModelThrough = borders_off } return bu.borderModelThrough } /** 获得 内部轮廓 <挖穿造型> */ static getBorders_innerNew(block: PlaceBlock, isPlaced = true, placeStyle?: PlaceStyle): Curve2d[][] { const bu = this.getPlacedUnitNew(block, isPlaced, placeStyle) if (bu == null) { console.error('BlockPlus.getBorders_innerNew: 获取板的内部轮廓失败', block) return [] } if (bu.borderModelThrough == null) { const borders = this.getBorders_innerNew(block, false) const borders_off: Curve2d[][] = [] for (const border of borders) { const newBorder = this.transformBorderNew(border, bu.placeStyle, block.cutWidth, block.cutLength) borders_off.push(newBorder) } bu.borderModelThrough = borders_off } return bu.borderModelThrough } /** 获得内部轮廓 <挖穿造型> 半径 */ static getBorders_inner_r(block: PlaceBlock) { if (block.blockDetail == null || block.blockDetail.borderContour == null) { console.error('BlockPlus.getBorders_inner_r: block.blockDetail or block.blockDetail.borderContour is undefined', block) return [] } return block.blockDetail.borderContour.borderModelThroughR } /** 获得 内部走刀轮廓 <挖穿造型> */ static getCutLines_inner(block: PlaceBlock, isPlaced = true, placeStyle?: PlaceStyle): Curve2d[][] { const bu = this.getPlacedUnit(block, isPlaced, placeStyle) if (bu == null) { console.error('BlockPlus.getCutLines_inner: 获取板的内部走刀轮廓失败', block) return [] } if (bu.cutLinesModelThrough == null) { const borders = this.getCutLines_inner(block, false) const borders_off: Curve2d[][] = [] for (const border of borders) { const newBorder = this.transformBorder(border, bu.placeStyle, block.cutWidth, block.cutLength) borders_off.push(newBorder) } bu.cutLinesModelThrough = borders_off } return bu.cutLinesModelThrough } /** 获得 内部排版轮廓 <挖穿造型> */ static getInnerPlaceBorders(block: PlaceBlock, isPlaced = true, placeStyle?: PlaceStyle): Curve2d[][] { const bu = this.getPlacedUnit(block, isPlaced, placeStyle) if (bu == null) { console.error('BlockPlus.getInnerPlaceBorders: 获取板的内部排版轮廓失败', block) return [] } if (bu.borderInnerPlace == null) { const borders = this.getInnerPlaceBorders(block, false) const borders_off: Curve2d[][] = [] for (const border of borders) { const newBorder = this.transformBorder(border, bu.placeStyle, block.cutWidth, block.cutLength) borders_off.push(newBorder) } bu.borderInnerPlace = borders_off } return bu.borderInnerPlace } /** 获得 板内空间 《挖穿孔洞 + 缺角》 */ static getSpaces(block: PlaceBlock, pm: PlaceMaterial): PlaceSpace[] { if (block.blockDetail == null || block.blockDetail.borderContour == null) { console.error('BlockPlus.getSpaces: block.blockDetail or block.blockDetail.borderContour is undefined', block) return [] } const bu = block.blockDetail.borderContour if (!bu.blockOuterSpace) bu.blockOuterSpace = this.createOutSpaces(block, pm) // 缺角空间不存在,创建 // 挖穿孔洞 + 缺角 return bu.blockInnerSpace.concat(bu.blockOuterSpace) } static getInnerSpaces(block: PlaceBlock): PlaceSpace[] { const bu = this.getPlacedUnit(block, false) // 挖穿孔洞 return bu ? bu.blockInnerSpace : [] } static getModelHole(block: PlaceBlock, isPlaced = true, placeStyle?: PlaceStyle): Curve2d[][] { const bu = this.getPlacedUnit(block, isPlaced, placeStyle) if (bu == null) { console.error('BlockPlus.getModelHole: 获取板的轮廓集失败', block) return [] } if (!bu.borderInnerPlace) { if (block.blockDetail == undefined) { console.error('BlockPlus.getModelHole: block.blockDetail is undefined', block) return [] } if (block.blockDetail.borderContour == undefined) { console.error('BlockPlus.getModelHole: block.blockDetail.borderContour is undefined', block) return [] } const org_list = block.blockDetail.borderContour.borderInnerPlace if (!org_list || org_list.length == 0) return [] const liset: Curve2d[][] = [] for (const cur of org_list) { const newCur = this.transformBorder(cur, bu.placeStyle, block.cutWidth, block.cutLength) if (newCur) liset.push(newCur) } bu.borderInnerPlace = liset } return bu.borderInnerPlace } /** 获得 板的轮廓多段线（包括内部挖穿) */ static getOrgPloylines(block: PlaceBlock, isPlaced = true, placeStyle?: PlaceStyle) { const borderPlus = this.getBorder(block, isPlaced, placeStyle) const innerBorders = this.getBorders_inner(block, isPlaced, placeStyle) const pl = this.borderToPolyline(borderPlus) const pls_inner = new Array() for (const border of innerBorders) { const npl = this.borderToPolyline(border) pls_inner.push(npl) } return { pl, pls_inner } } /** 获得 板的开料多段线（包括内部挖穿) */ static getCutPloylines(block: PlaceBlock, pm: PlaceMaterial, isPlaced = true, placeStyle?: PlaceStyle) { const borderPlus = this.getCutLines_sameKnife(block, pm, isPlaced, placeStyle) const innerBorders = this.getCutLines_inner(block, isPlaced, placeStyle) const pl = this.borderToPolyline(borderPlus) const pls_inner = new Array() for (const border of innerBorders) { const npl = this.borderToPolyline(border) pls_inner.push(npl) } return { pl, pls_inner } } /** 获得小板 板外造型轮廓 */ static getOutModelBorders(block: PlaceBlock, isPlaced = true, placeStyle?: PlaceStyle) { // b1.SaleBlockDetail.borderUnit.polylines_outModel // b1.SaleBlockDetail.borderUnit.polylines_2vModel const bu = this.getPlacedUnit(block, isPlaced, placeStyle) if (bu == null) { console.error('BlockPlus.getOutModelBorders: 获取板的轮廓集失败', block) return [] } if (block.blockDetail == undefined) { console.error('BlockPlus.getOutModelBorders: block.blockDetail is undefined', block) return [] } if (block.blockDetail.borderContour == undefined) { console.error('BlockPlus.getOutModelBorders: block.blockDetail.borderContour is undefined', block) return [] } if (bu.polylinesOutModel == null) { const polylines_outModel = block.blockDetail.borderContour.polylinesOutModel const new_outModels: Polyline[] = [] for (const border of polylines_outModel) { const newBorder = this.transformPolyline(border, bu.placeStyle, block.cutWidth, block.cutLength) new_outModels.push(newBorder) } bu.polylinesOutModel = new_outModels } if (bu.polylines2vModel == null) { const polylines_2vModel = block.blockDetail.borderContour.polylines2vModel const new_outModels: Polyline[] = [] for (const border of polylines_2vModel) { const newBorder = this.transformPolyline(border, bu.placeStyle, block.cutWidth, block.cutLength) new_outModels.push(newBorder) } bu.polylines2vModel = new_outModels } return bu.polylinesOutModel.concat(bu.polylines2vModel) } /** 获得小板外形轮廓 */ static getOrgContour(block: PlaceBlock): any { if (!block.blockDetail) { console.error('BlockPlus.getOrgContour: block.blockDetail is undefined', block) return null } if (!block.blockDetail.orgContourData) { const pts: any = [] const buls: any = [] if (!block.isUnRegular) { pts.push({ x: 0, y: 0 }) pts.push({ x: block.width, y: 0 }) pts.push({ x: block.width, y: block.length }) pts.push({ x: 0, y: block.length }) buls.push(0) buls.push(0) buls.push(0) buls.push(0) } else // 矩形板 { for (const p of block.blockDetail.orgPoints) { pts.push({ x: p.pointX, y: p.pointY }) buls.push(p.curve) } } block.blockDetail.orgContourData = { pts, buls } } return block.blockDetail.orgContourData } /** 获得板的 轮廓集 isPlaced=false为不旋转的 */ private static getPlacedUnit(block: PlaceBlock, isPlaced = true, style?: PlaceStyle): PlaceBorderContour | null { if (!block.blockDetail) { console.error('BlockPlus.getPlacedUnit: block.blockDetail is undefined', block) return null } if (block.blockDetail.borderContour == undefined) { console.error('BlockPlus.getPlacedUnit: block.blockDetail.borderContour is undefined', block) return null } const baseContour = block.blockDetail.borderContour if (isPlaced == false) style = PlaceStyle.FRONT if (isPlaced == true) { if (style == undefined || style == null) style = block.placeStyle } if (style == undefined) { style = PlaceStyle.FRONT } if (style == PlaceStyle.FRONT) return baseContour let placeContour = baseContour.placeContours.find(t => t.placeStyle == style) if (placeContour == null) { const border_final = this.transformBorder(baseContour.borderFinal, style, block.width, block.length) const border_org = this.transformBorder(baseContour.borderOrg, style, block.cutWidth, block.cutLength) placeContour = new PlaceBorderContour(style, border_final, border_org) baseContour.placeContours.push(placeContour) } return placeContour } /** * 获得板的 轮廓集 isPlaced=false为不旋转的 * @param block * @param isPlaced * @param style * @returns */ private static getPlacedUnitNew(block: PlaceBlock, isPlaced = true, style?: PlaceStyle): PlaceBorderContour | null { if (!block.blockDetail) { console.error('BlockPlus.getPlacedUnitNew: block.blockDetail is undefined', block) return null } if (block.blockDetail.borderContour == undefined) { console.error('BlockPlus.getPlacedUnitNew: block.blockDetail.borderContour is undefined', block) return null } const baseContour = block.blockDetail.borderContour if (isPlaced == false) style = PlaceStyle.FRONT if (isPlaced == true) { if (style == undefined || style == null) style = block.placeStyle } if (style == undefined) { style = PlaceStyle.FRONT } if (style == PlaceStyle.FRONT) return baseContour let placeContour = baseContour.placeContours.find(t => t.placeStyle == style) if (placeContour == null) { const border_final = this.transformBorderNew(baseContour.borderFinal, style, block.width, block.length) const border_org = this.transformBorderNew(baseContour.borderOrg, style, block.cutWidth, block.cutLength) placeContour = new PlaceBorderContour(style, border_final, border_org) baseContour.placeContours.push(placeContour) } return placeContour } /** 创建 小板成品轮廓 */ private static createFinalBorder(bd: PlaceBlockDetail, block: PlaceBlock): Curve2d[] { const orgPoints = bd.orgPoints const orgBorderCurveList = new Array() if (orgPoints && orgPoints.length > 1) // 异形 { const count = orgPoints.length for (let i = 0; i < count; i++) { const p0 = orgPoints[i] const p1 = i == count - 1 ? orgPoints[0] : orgPoints[i + 1] const sideHoleCount = bd.holeListSide.filter(t => t.faceId == i).length if (p0.curve == 0) // 直线 { const newLine = Line2d.New(p0.pointX, p0.pointY, p1.pointX, p1.pointY) newLine.tagData = p0.sealSize newLine.tagData2 = sideHoleCount orgBorderCurveList.push(newLine) p0.radius = 0 } else // 曲线 { const crc = Arc2d.New(p0.pointX, p0.pointY, p1.pointX, p1.pointY, p0.curve) crc.tagData = p0.sealSize crc.tagData2 = sideHoleCount p0.radius = crc.m_Radius orgBorderCurveList.push(crc) } } } else // 矩形板 { const w = block.width const l = block.length const line0 = Line2d.New(0, 0, w, 0) line0.tagData = block.sealBottom line0.tagData2 = block.holeCountBottom() const line1 = Line2d.New(w, 0, w, l) line1.tagData = block.sealRight line1.tagData2 = block.holeCountRight() const line2 = Line2d.New(w, l, 0, l) line2.tagData = block.sealTop line2.tagData2 = block.holeCountTop() const line3 = Line2d.New(0, l, 0, 0) line3.tagData = block.sealLeft line3.tagData2 = block.holeCountLeft() orgBorderCurveList.push(line0) orgBorderCurveList.push(line1) orgBorderCurveList.push(line2) orgBorderCurveList.push(line3) } return orgBorderCurveList } /** 创建 开料轮廓 */ private static createOrgBorder(bd: PlaceBlockDetail): Curve2d[] { const borders = new Array() if (bd.points && bd.points.length > 1) // 异形 { const count = bd.points.length for (let i = 0; i < count - 1; i++) // 异形点（无封边，起点终点 是重复的） { const p0 = bd.points[i] const p1 = i == count - 1 ? bd.points[0] : bd.points[i + 1] const sideHoleCount = bd.holeListSide.filter(t => t.faceId == i).length if (p0.curve == 0) // 直线 { const newLine = Line2d.New(p0.pointX, p0.pointY, p1.pointX, p1.pointY) newLine.tagData = p0.sealSize newLine.tagData2 = sideHoleCount borders.push(newLine) p0.radius = 0 } else // 曲线 { const crc = Arc2d.New(p0.pointX, p0.pointY, p1.pointX, p1.pointY, p0.curve) crc.tagData = p0.sealSize crc.tagData2 = sideHoleCount p0.radius = crc.m_Radius if (p0.radius < 2) { p0.curve = 0 p0.radius = 0 } borders.push(crc) } } } else // 矩形板 { const w = bd.cutWidth const l = bd.cutLength const line0 = Line2d.New(0, 0, w, 0) const line1 = Line2d.New(w, 0, w, l) const line2 = Line2d.New(w, l, 0, l) const line3 = Line2d.New(0, l, 0, 0) borders.push(line0) borders.push(line1) borders.push(line2) borders.push(line3) } return borders } /** 创建预铣轮廓 */ private static creatOrgBorderWithPrevCut(block: PlaceBlock, border: Curve2d[], preSize: number) { // 矩形板 const newBorders: Curve2d[] = [] const newSizeExpand = new SizeExpand() if (!block.isUnRegular) { let x1 = 0 let y1 = 0 let x2 = block.cutWidth let y2 = block.cutLength if (block.isUnRegular == false) // 矩形板 { if (block.sealLeft > 0.001) { x1 -= preSize newSizeExpand.left = preSize } if (block.sealRight > 0.001) { x2 += preSize newSizeExpand.right = preSize } if (block.sealBottom > 0.001) { y1 -= preSize newSizeExpand.bottom = preSize } if (block.sealTop > 0.001) { y2 += preSize newSizeExpand.top = preSize } } newBorders.push(Line2d.New(x1, y1, x2, y1)) newBorders.push(Line2d.New(x2, y1, x2, y2)) newBorders.push(Line2d.New(x2, y2, x1, y2)) newBorders.push(Line2d.New(x1, y2, x1, y1)) newSizeExpand.setSize() return { newBorders, newSizeExpand } } // 二。异形板 // 2.1 先分析 每条原始边 是否预铣 if (!block.blockDetail) { console.error("创建预铣轮廓时，block.blockDetail 为空", block); return; } const bd = block.blockDetail for (let i = 0; i < bd.orgPoints.length; i++) { let s = i - 1 let j = i + 1 if (s == -1) s = bd.orgPoints.length - 1 if (j == bd.orgPoints.length) j = 0 const p0 = bd.orgPoints[s] const p1 = bd.orgPoints[i] const p2 = bd.orgPoints[j] p1.isPreCutRequired = checkYX(p0, p1, p2, block.width, block.length) } // 2.1.5 同一边，如果有缺角，则都不能预铣 for (let i = 0; i < bd.orgPoints.length - 1; i++) { const j = (i + 1) % bd.orgPoints.length const pi = bd.orgPoints[i] const pj = bd.orgPoints[j] // if(pi.needPreCut==false) continue; // 垂直或平行 let isVertical = equal(pi.pointX, pj.pointX) if (isVertical == false) { if (equal(pi.pointY, pj.pointY)) { isVertical = false } else { continue // 斜线 } } for (let m = j; m < bd.orgPoints.length; m++) { const n = (m + 1) % bd.orgPoints.length const pm = bd.orgPoints[m] const pn = bd.orgPoints[n] // 垂直 ，同边 有缝隙，多段线 ,不能预铣 if (isVertical && equal(pi.pointX, pm.pointX) && equal(pi.pointX, pn.pointX)) { pi.isPreCutRequired = false pm.isPreCutRequired = false } // 水平 ，同边 有缝隙，多段线 ,不能预铣 if (isVertical == false && equal(pi.pointY, pm.pointY) && equal(pi.pointY, pn.pointY)) { pi.isPreCutRequired = false pm.isPreCutRequired = false } } } // 2.2 生成预铣轮廓 for (let i = 0; i < border.length; i++) { const cur = border[i] let newCur: Curve2d if (cur instanceof Arc2d) { newCur = new Arc2d(cur.StartPoint, cur.EndPoint, cur.Bul) } else { newCur = new Line2d(cur.StartPoint, cur.EndPoint) } if ((newCur instanceof Line2d) && newCur.m_Length < 0.001) continue // 曲线肯定不能偏移, // 直线的话,需要跟 板原始轮廓边 比对确定是否需要偏移 const curNeedOff = preSize > 0 && needPrev(cur) if (curNeedOff) { // 偏移 const line = cur as Line2d newCur = line.Offset(preSize) } // 判断前一条边的终点是否 != 当前边的起点,需要加一条连接线 if (newBorders.length > 0) { const pLast = newBorders[newBorders.length - 1] if (equal2Point(pLast.EndPoint, newCur.StartPoint) == false) { let hasJD = false if ((pLast instanceof Line2d) && (newCur instanceof Line2d)) { const p_jds: Point2d[] = [] newCur.IntersectWith(pLast, p_jds) if (p_jds.length == 1) { pLast.EndPoint = new Point2d(p_jds[0].m_X, p_jds[0].m_Y) newCur.StartPoint = new Point2d(p_jds[0].m_X, p_jds[0].m_Y) hasJD = true } } if (hasJD == false) // 直接连接 { const linkLine = new Line2d(pLast.EndPoint, newCur.StartPoint) newBorders.push(linkLine) } } } // 插入新的边 newBorders.push(newCur) } // 2.3 闭合 最后一边 ,是否与 第一条边 连接 const firstB = newBorders[0] const lastB = newBorders[newBorders.length - 1] if (equal2Point(lastB.EndPoint, firstB.StartPoint) == false) { // 如果前后都是直线则求交点, 直接延长直线 let hasJD = false if ((firstB instanceof Line2d) && (lastB instanceof Line2d)) { const p_jds: Point2d[] = [] lastB.IntersectWith(firstB, p_jds) if (p_jds.length == 1) { lastB.EndPoint = new Point2d(p_jds[0].m_X, p_jds[0].m_Y) firstB.StartPoint = new Point2d(p_jds[0].m_X, p_jds[0].m_Y) hasJD = true } } if (hasJD == false) // 直接连接 { const linkLine = new Line2d(lastB.EndPoint, firstB.StartPoint) newBorders.push(linkLine) } } // 2.4 生成外扩 let xz = 0; let xy = block.cutWidth; let yx = 0; let ys = block.cutLength for (const cur of newBorders) { const p = cur.StartPoint if (p.m_X < xz) xz = p.m_X if (p.m_X > xy) xy = p.m_X if (p.m_Y < yx) yx = p.m_Y if (p.m_Y > ys) ys = p.m_Y } newSizeExpand.left = -xz newSizeExpand.right = xy - block.cutWidth newSizeExpand.bottom = -yx newSizeExpand.top = ys - block.cutLength newSizeExpand.setSize() return { newBorders, newSizeExpand } // 判断外轮廓点p1是否需要预铣 function checkYX(p0, p1, p2, width, length) { if (p1.curve != 0) return false // 本身是圆弧 if (p1.sealSize < 0.001) return false// 本身不封边 if (p0.curve != 0) return false // 前一段是圆弧 if (p2.curve != 0) return false// 后一段是圆弧 // p1.p2 只要有一点在板内,就不行 const isIn1 = (p1.pointX > 0.001 && p1.pointX < width - 0.001 && p1.pointY > 0.001 && p1.pointY < length - 0.001) if (isIn1) return false const isIn2 = (p2.pointX > 0.001 && p2.pointX < width - 0.001 && p2.pointY > 0.001 && p2.pointY < length - 0.001) if (isIn2) return false return true // 需要预洗 } // 判断边是否预铣 function needPrev(line: Curve2d) { if (!block.blockDetail) { console.error("判断边是否预铣时，block.blockDetail 为空", block); return false; } if (!(line instanceof Line2d)) return false if (block.isUnRegular == false) // 矩形 { if (line.StartPoint.m_Y == 0 && line.EndPoint.m_Y == 0) return block.sealBottom > 0 if (line.StartPoint.m_X == block.cutWidth && line.EndPoint.m_X == block.cutWidth) return block.sealRight > 0 if (line.StartPoint.m_Y == block.cutLength && line.EndPoint.m_Y == block.cutLength) return block.sealTop > 0 if (line.StartPoint.m_X == 0 && line.EndPoint.m_X == 0) return block.sealLeft > 0 return false } const offx = block.blockDetail.offsetX const offy = block.blockDetail.offsetY const x1 = line.StartPoint.m_X const y1 = line.StartPoint.m_Y const x2 = line.EndPoint.m_X const y2 = line.EndPoint.m_Y const tag0 = (x2 - x1) / getDis(x1, y1, x2, y2) // 找出原始轮廓中 对应的边 , 是否有 预洗信息 for (let i = 0; i < block.orgPoints.length; i++) { let j = i + 1 if (j == block.orgPoints.length) j = 0 if (block.orgPoints[i].isPreCutRequired == false) continue const tag1 = (block.orgPoints[j].pointX - block.orgPoints[i].pointX) / getDis(block.orgPoints[i].pointX, block.orgPoints[i].pointY, block.orgPoints[j].pointX, block.orgPoints[j].pointY) if (equal(tag0, tag1, 0.1) == false) continue // 不平行 const dis = getDis_PointLine(x1, y1, x2, y2, block.orgPoints[i].pointX - offx, block.orgPoints[i].pointY - offy) if (dis < block.orgPoints[i].sealSize * 2 + 3) return true } return false } function equal2Point(p1, p2, dis = 0.001) { const x1 = p1.m_X const y1 = p1.m_Y const x2 = p2.m_X const y2 = p2.m_Y const len1 = (x1 - x2) * (x1 - x2) const len2 = (y1 - y2) * (y1 - y2) const len = Math.sqrt(len2 + len1) return len < dis } } /** 创建 挖穿造型，走刀路径,板内空间 */ private static analyeInners(bd: PlaceBlockDetail, cutR, cutGap = 1) { /** 挖穿轮廓 */ const borders_inner_org: Curve2d[][] = [] /** 挖穿轮廓 刀半径 */ const borders_inner_r: number[] = [] /** 挖穿走刀路径 */ const borders_inner_cut: Curve2d[][] = [] /** 挖穿排版轮廓 <加缝隙> */ const borders_inner_place: Curve2d[][] = [] /** 排版空间 */ const spaces: PlaceSpace[] = [] for (const m of bd.models) { if (m.depth < bd.thickness - 0.01) continue // 非挖穿 if (m.isVKnifeModel()) continue // 挖穿的二维刀路造型 不计算. if (m.isCutting == false) continue // 不加工 // 挖穿轮廓 <切割后的>,顺时针的 let baseBorder if (m.hasContour()) // 有轮廓数据 { let ptsArr = m.originModeling.outline.map(e => e.pts) const pts = ptsArr.map((t) => { return { x: t.x, y: t.y } }) for (let i = 0; i < pts.length; i++) { pts[i].bul = m.originModeling.outline[i].buls } baseBorder = this.createBorderByPts(pts) } else // 没有轮廓数据，用走刀路径 偏移 { const pts = m.pointList.map((t) => { return { x: t.pointX, y: t.pointY, bul: t.curve } }) baseBorder = this.createBorderByPts(pts) baseBorder = this.offsetCurves(baseBorder, m.knifeRadius, false) } // 铣刀路径 const border_cut = this.offsetCurves(baseBorder, -m.realKnifeRadius, false) // 排版轮廓 const placeGap = Math.max(m.realKnifeRadius, cutR) * 2 - cutR + cutGap / 2 // 取造型刀，开料刀 最大的 const border_place = this.offsetCurves(baseBorder, -placeGap, false) borders_inner_org.push(baseBorder) borders_inner_r.push(m.realKnifeRadius) borders_inner_cut.push(border_cut) borders_inner_place.push(border_place) // 内部空间 let createdSpaces = false if (m.hasContour()) // 简单形状，直接生成矩形,圆形 { // 是否矩形,圆形 const rect = isRect(m.originModeling.outline) || isCircle(m.originModeling.outline) if (rect) { const gap = placeGap rect.x += gap rect.y += gap rect.w -= gap * 2 rect.l -= gap * 2 if (rect.w > 100 && rect.l > 100) { const space = new PlaceSpace(rect.x, rect.y, rect.w, rect.l) space.isBlockInnerSpace = true spaces.push(space) } createdSpaces = true } } if (createdSpaces == false) // 复杂形状 { const tmpSpaces = SpacePlus.borderToSpace(border_place) if (tmpSpaces) { tmpSpaces.forEach(t => t.isBlockInnerSpace = true) tmpSpaces.forEach(t => spaces.push(t)) } } } return { borders_inner_org, borders_inner_r, borders_inner_cut, borders_inner_place, spaces } function isRect(outline: any): any { const pts = outline.map(e => e.pts) //outline.pts const buls = outline.map(e => e.buls) // outline.buls if (buls.length != 5) return null if (buls.some(t => t != 0)) return null if (pts.length != 5) return null if (pts[4].x != pts[0].x || pts[4].y != pts[0].y) return null return getRect(pts[0], pts[1], pts[2], pts[3]) } function isCircle(outline: any): any { // const pts = outline.pts // const buls = outline.buls const pts = outline.map(e => e.pts) //outline.pts const buls = outline.map(e => e.buls) // outline.buls if (buls.length != 3) return null if (equal(buls[0], 1) && equal(buls[1], 1) && equal(buls[2], 0)) { const p0 = Array.isArray(outline) ? outline[0].pts : outline?.pts[0] const p1 = Array.isArray(outline) ? outline[1].pts : outline?.pts[1] let x0 = Math.min(p0.x, p1.x) let x1 = Math.max(p0.x, p1.x) let y0 = Math.min(p0.y, p1.y) let y1 = Math.max(p0.y, p1.y) let r if (equal(x0, x1)) { r = (y1 - y0) / 2 x0 -= r x1 += r } else { r = (x1 - x0) / 2 y0 -= r y1 += r } const t = r / Math.SQRT2 const dis = r - t return { x: x0 + dis, y: y0 + dis, w: t * 2, l: t * 2 } } } } /** 创建 缺角空间 */ private static createOutSpaces(block: PlaceBlock, placeMaterial: PlaceMaterial): PlaceSpace[] { if (block.blockDetail == undefined) { console.error("创建缺角空间时，block.blockDetail 为空", block); return []; } if (block.blockDetail.borderContour == null) { console.error("创建缺角空间时，block.blockDetail.borderContour 为空", block); return []; } if (block.isUnRegular == false && (block.blockDetail.borderContour.polylines2vModel.length + block.blockDetail.borderContour.polylinesOutModel.length == 0)) return [] // 矩形 const pm = placeMaterial let border = this.getBorder_WZYH(block, placeMaterial, false) // 获得全偏移的轮廓 const pl = this.borderToPolyline(border, true) /** 空间 */ let spaces: PlaceSpace[] = [] const reg = { z: 0, x: 0, y: 0, s: 0, w: 0, l: 0 } // 外围空间 左右上下 ，宽长 reg.z = pl.BoundingBox.min.x reg.x = pl.BoundingBox.min.y reg.y = pl.BoundingBox.max.x reg.s = pl.BoundingBox.max.y reg.w = -reg.z + reg.y reg.l = -reg.x + reg.s const checkSize = new SizeExpand() // 空间验证 checkSize.left = -block.sizeExpand()?.left - (pm.diameter + pm.cutKnifeGap) / 2 checkSize.right = block.cutWidth + block.sizeExpand()?.right + (pm.diameter + pm.cutKnifeGap) / 2 checkSize.bottom = -block.sizeExpand()?.bottom - (pm.diameter + pm.cutKnifeGap) / 2 checkSize.top = block.cutLength + block.sizeExpand()?.top + (pm.diameter + pm.cutKnifeGap) / 2 const offDis = pm.preMillingSize + 0.01 // 点判断是否在边缘 误差 一个预铣值 border = border.slice(0) // 确保 第一条 起点在边缘 let count = 0 // 移动不能大于一个循环，避免死循环 while (count < border.length) { const line0 = border[0] const isOnBorder = onBorder(line0.StartPoint) if (isOnBorder) break // 如果起点在板内，移动到最后面 border.shift() border.push(line0) count++ } SpacePlus.setSpaceStyle(block) let lines: Curve2d[] = [] // for (let i = 0; i < border.length; i++) { const line = border[i] const spOnBorder = onBorder(line.StartPoint) const epOnBorder = onBorder(line.EndPoint) const isxl = isXL(line) if (spOnBorder && (!epOnBorder || isxl)) // 起始线 { lines = [] lines.push(line) } if (!spOnBorder && !epOnBorder) // 板内线 { if (lines && lines.length > 0 && lines[lines.length - 1] != line) lines.push(line) } if (epOnBorder && (!spOnBorder || isxl)) // 结束线，开始分析空间 { if (lines && lines.length > 0) { if (lines[lines.length - 1] != line) lines.push(line) const newspaces = createSpace(lines) if (newspaces && newspaces.length > 0) spaces = spaces.concat(newspaces) lines = [] } } } const newSpaces: PlaceSpace[] = [] // 空间验证 for (const space of spaces) { let x1 = space.x let y1 = space.y let x2 = space.topX() let y2 = space.topY() if (x1 < checkSize.left) x1 = checkSize.left if (y1 < checkSize.bottom) y1 = checkSize.bottom if (x2 > checkSize.right) x2 = checkSize.right if (y2 > checkSize.top) y2 = checkSize.top const newspace = PlaceSpace.create(x1, y1, x2, y2) newSpaces.push(newspace) } return newSpaces /** 缺角的开始？ 起点在边缘，终点在板内的 或 斜线 （终点在另外一边） */ function isBegin(curve: Curve2d) { return onBorder(curve.StartPoint) && (!onBorder(curve.EndPoint) || isXL(curve)) } /** 缺角的结束? 终点在边缘的 起点在板内 或 （起点点在另外一边） */ function isEnd(curve: Curve2d) { return onBorder(curve.EndPoint) && (!onBorder(curve.StartPoint) || isXL(curve)) } /** 在板内 */ function inBorder(curve: Curve2d) { return !onBorder(curve.StartPoint) && !onBorder(curve.EndPoint) } /** 点是否在边缘 */ function onBorder(p: Point2d) { return equal(p.m_X, reg.z, offDis) || equal(p.m_X, reg.y, offDis) || equal(p.m_Y, reg.s, offDis) || equal(p.m_Y, reg.x, offDis) } /** 斜线 */ function isXL(line: Curve2d) { return !equal(line.StartPoint.m_X, line.EndPoint.m_X) && !equal(line.StartPoint.m_Y, line.EndPoint.m_Y) } /** 线是边缘 */ function isBorderLine(line: Line2d) { return !isXL(line) && onBorder(line.StartPoint) && onBorder(line.EndPoint) } /** 分析空间 */ function createSpace(curves: Curve2d[]): PlaceSpace[] { if (curves.length == 0) return [] // 1.补边，闭合轮廓 const sp = curves[0].StartPoint const ep = curves[curves.length - 1].EndPoint const pushPts: Point2d[] = [] pushPts.push(ep) const sb = getEdge(sp) // 起点的边 const eb = getEdge(ep) // 终点的边 if (sb == -1 || eb == -1) return []// 不在边上 // 在同一边 的缺角 if (sb == eb) { if (equal(sp.m_X, ep.m_X, offDis) && sp.m_X != ep.m_X) // 消除误差 { let x = Math.max(sp.m_X, ep.m_X) if (sp.m_X > block.width / 2) x = Math.min(sp.m_X, ep.m_X) sp.m_X = x ep.m_X = x } if (equal(sp.m_Y, ep.m_Y, offDis) && sp.m_Y != ep.m_Y) // 消除误差 { let y = Math.max(sp.m_Y, ep.m_Y) if (sp.m_Y > block.length / 2) y = Math.min(sp.m_Y, ep.m_Y) sp.m_Y = y ep.m_Y = y } } // 右下角 else if (sb == 0 && eb == 1) { const cp = new Point2d(ep.m_X, sp.m_Y) pushPts.push(cp) } // 右上角 else if (sb == 1 && eb == 2) { const cp = new Point2d(sp.m_X, ep.m_Y) pushPts.push(cp) } // 左上角 else if (sb == 2 && eb == 3) { const cp = new Point2d(ep.m_X, sp.m_Y) pushPts.push(cp) } // 左下角 else if (sb == 3 && eb == 0) { const cp = new Point2d(sp.m_X, ep.m_Y) pushPts.push(cp) } // 起点下边 -> 终点上边 //因为倒角 else if (sb == 0 && eb == 2) { const cp1 = new Point2d(reg.y, ep.m_Y) const cp2 = new Point2d(reg.y, sp.m_Y) pushPts.push(cp1) pushPts.push(cp2) } // 起点右边 -> 终点左边 else if (sb == 1 && eb == 3) { const cp1 = new Point2d(ep.m_X, reg.s) const cp2 = new Point2d(sp.m_X, reg.s) pushPts.push(cp1) pushPts.push(cp2) } // 起点上边 -> 终点下边 else if (sb == 2 && eb == 0) { const cp1 = new Point2d(reg.z, ep.m_Y) const cp2 = new Point2d(reg.z, sp.m_Y) pushPts.push(cp1) pushPts.push(cp2) } // 起点左边 -> 终点右边 else if (sb == 3 && eb == 1) { const cp1 = new Point2d(ep.m_X, reg.x) const cp2 = new Point2d(sp.m_X, reg.x) pushPts.push(cp1) pushPts.push(cp2) } // 起点下边 -> 终点左边 else if (sb == 0 && eb == 3) { const cp1 = new Point2d(reg.z, reg.s) const cp2 = new Point2d(reg.y, reg.s) const cp3 = new Point2d(reg.y, reg.x) pushPts.push(cp1) pushPts.push(cp2) pushPts.push(cp3) } // 起点右边 -> 终点下边 else if (sb == 1 && eb == 0) { const cp1 = new Point2d(reg.z, reg.x) const cp2 = new Point2d(reg.z, reg.s) const cp3 = new Point2d(reg.y, reg.s) pushPts.push(cp1) pushPts.push(cp2) pushPts.push(cp3) } // 起点上 -> 终点右边 else if (sb == 2 && eb == 1) { const cp1 = new Point2d(reg.y, reg.x) const cp2 = new Point2d(reg.z, reg.x) const cp3 = new Point2d(reg.z, reg.s) pushPts.push(cp1) pushPts.push(cp2) pushPts.push(cp3) } // 起点左 -> 终点上边 else if (sb == 3 && eb == 2) { const cp1 = new Point2d(reg.y, reg.s) const cp2 = new Point2d(reg.y, reg.x) const cp3 = new Point2d(reg.z, reg.x) pushPts.push(cp1) pushPts.push(cp2) pushPts.push(cp3) } else // 判断不了 缺口 的起点终点 范围 { return [] } pushPts.push(sp) for (let i = 0; i < pushPts.length - 1; i++) // 闭合缺口 { const newLine = new Line2d(pushPts[i], pushPts[i + 1]) curves.push(newLine) } // 3 目前轮廓顺时针，必须转成 逆时针 curves = SpacePlus.reverseCurves(curves) // 4. 分析空间 analyeSpace const tmpSpaces = SpacePlus.borderToSpace(curves) || [] return tmpSpaces } /** 获得点所在的边 getB */ function getEdge(sp) { if (equal(sp.m_Y, reg.x, offDis)) return 0 if (equal(sp.m_X, reg.y, offDis)) return 1 if (equal(sp.m_Y, reg.s, offDis)) return 2 if (equal(sp.m_X, reg.z, offDis)) return 3 return -1 } /** 设置方向 */ function setDirect(line: Line2d) { let fx = -1 // 向右 0,向上 1，向左 2，向下 3 ,右上 4,左上5,左下6，右下 7 if (line.EndPoint.m_X > line.StartPoint.m_X && equal(line.EndPoint.m_Y, line.StartPoint.m_Y)) { fx = 0 } else if (line.EndPoint.m_X < line.StartPoint.m_X && equal(line.EndPoint.m_Y, line.StartPoint.m_Y)) { fx = 2 } else if (line.EndPoint.m_Y > line.StartPoint.m_Y && equal(line.EndPoint.m_X, line.StartPoint.m_X)) { fx = 1 } else if (line.EndPoint.m_Y < line.StartPoint.m_Y && equal(line.EndPoint.m_X, line.StartPoint.m_X)) { fx = 3 } else if (line.EndPoint.m_X > line.StartPoint.m_X && line.EndPoint.m_Y > line.StartPoint.m_Y) { fx = 4 } else if (line.EndPoint.m_X < line.StartPoint.m_X && line.EndPoint.m_Y > line.StartPoint.m_Y) { fx = 5 } else if (line.EndPoint.m_X < line.StartPoint.m_X && line.EndPoint.m_Y < line.StartPoint.m_Y) { fx = 6 } else if (line.EndPoint.m_X > line.StartPoint.m_X && line.EndPoint.m_Y < line.StartPoint.m_Y) { fx = 7 } line.fx = fx return fx > -1 } } /** 创建 普通造型外扩的 多段线 */ public static createPolyline_model(block: PlaceBlock) { if (!block.blockDetail) { console.warn("PlaceBlock没有blockDetail，无法创建造型轮廓") return { pls_model: [], sizeout: new SizeExpand() } } const pl_block = this.getOrgPolyline(block) const pls_model: Polyline[] = [] for (const model of block.blockDetail.models) { if (model.originModeling == undefined) { continue } let _pts: any[] = [] let _buls: any[] = [] if (Array.isArray(model.originModeling.outline)) { _pts = model.originModeling.outline.map(e => e.pts) _buls = model.originModeling.outline.map(e => e.buls) } else { _pts = model.originModeling.outline.pts _buls = model.originModeling.outline.buls } if (model.isCutting == false) continue if (model.isVKnifeModel()) continue if (model.depth > block.thickness - 0.01) continue if (model.pointList.length < 2) continue if (model.hasContour() == false) continue if (model.originModeling == null) continue if (model.originModeling.outline == null) continue if (!Array.isArray(_pts)) continue if (_pts.length < 1) continue if (model.knifeRadius < 0.001) continue const pl_model = PolylineHelper.createByPts(_pts, _buls, true) const pl_off = pl_model.GetOffsetCurves(model.knifeRadius)[0] if (pl_off == null) continue if (pl_block.IntersectWith(pl_off, 0).length == 0) continue // 造型轮廓偏移一个刀半径 ，没有与板轮廓相交 // 有可能超出板外 const pts: any[] = [] const p0 = model.pointList[0] let isClose = false for (let i = 0; i < model.pointList.length; i++) { const p = model.pointList[i] if (i == 0) { pts.push({ x: p.pointX, y: p.pointY, bul: p.curve }) continue } const pp = pts[pts.length - 1] if (getDis2(pp, p) < 0.1) pts.pop() // 与前一点，接近去掉前一点，避免重合 pts.push({ x: p.pointX, y: p.pointY, bul: p.curve }) if (i == model.pointList.length - 1) break // 完成了 isClose = getDis2(p0, p) < 0.1 if (isClose) // 闭环且后面的点都在环内，那后面的点就不需要考虑了 { const pl = PolylineHelper.create(pts, true) let isAllIn = true for (let j = i + 1; j < model.pointList.length; j++) { const pn = model.pointList[j] isAllIn = pl.PtInCurve(new Vector3(pn.pointX, pn.pointY, 0)) if (isAllIn == false) break } if (isAllIn) break } } try { this.createModelPLS(pl_block, pls_model, pts, model.knifeRadius) } catch { continue } } // 计算外扩偏移 let xz = 0; let xy = block.cutWidth; let yx = 0; let ys = block.cutLength for (const pl of pls_model) { if (pl.BoundingBox.min.x < xz) xz = pl.BoundingBox.min.x if (pl.BoundingBox.min.y < yx) yx = pl.BoundingBox.min.y if (pl.BoundingBox.max.x > xy) xy = pl.BoundingBox.max.x if (pl.BoundingBox.max.y > ys) ys = pl.BoundingBox.max.y } const sizeout_model = new SizeExpand() if (xz < 0) sizeout_model.left = -xz if (xy > block.cutWidth) sizeout_model.right = xy - block.cutWidth if (yx < 0) sizeout_model.bottom = -yx if (ys > block.cutLength) sizeout_model.top = ys - block.cutLength sizeout_model.setSize() return { pls_model, sizeout: sizeout_model } } /** 创建 2v板外下刀的 多段线 */ private static createPolyline_2vModel(block: PlaceBlock) { if (!block.blockDetail) { console.warn("PlaceBlock没有blockDetail，无法创建造型轮廓") return { pls_model: [], sizeout: new SizeExpand() } } const pls_2v: Polyline[] = [] for (const model of block.blockDetail.models) { if (model.isVKnifeModel() == false) continue if (model.isCutting == false) continue // if(model.depth > block.thickness - 0.01) continue; const pl_block = this.getOrgPolyline(block) for (const vline of model.VLines) { // knifeRadius 刀半径, depth深度, points{x,y,z,bul,r} const r = vline.knifeRadius if (r < 0.001) continue const pts = vline.points.map((t) => { return { x: t.x, y: t.y, bul: t.bul } }) try { this.createModelPLS(pl_block, pls_2v, pts, r, true) } catch { continue } } } // 计算外扩偏移 let xz = 0; let xy = block.cutWidth; let yx = 0; let ys = block.cutLength for (const pl of pls_2v) { if (pl.BoundingBox.min.x < xz) xz = pl.BoundingBox.min.x if (pl.BoundingBox.min.y < yx) yx = pl.BoundingBox.min.y if (pl.BoundingBox.max.x > xy) xy = pl.BoundingBox.max.x if (pl.BoundingBox.max.y > ys) ys = pl.BoundingBox.max.y } const sizeout_2v = new SizeExpand() if (xz < 0) sizeout_2v.left = -xz if (xy > block.cutWidth) sizeout_2v.right = xy - block.cutWidth if (yx < 0) sizeout_2v.bottom = -yx if (ys > block.cutLength) sizeout_2v.top = ys - block.cutLength sizeout_2v.setSize() return { pls_2v, sizeout_2v } } /** * 创建超出板外的造型轮廓 * */ private static createModelPLS(pl_block: Polyline, pls_model: Polyline[], points: any[], r: number, is2V = false) { const lines: any = [] // 23.10.9 发现普通造型还是有自交的线段，强制 分段处理 for (let i = 0; i < points.length - 1; i++) { const j = i + 1 const p1 = { x: points[i].x, y: points[i].y, bul: points[i].bul } const p2 = { x: points[j].x, y: points[j].y, bul: 0 } lines.push([p1, p2]) } // 对 每段line 进行 偏移多半径,获取闭合多段线 const pls: Polyline[] = [] for (const pts of lines) { // 1. pts 不闭合，偏移0.5 // 原路回来，组合成闭合线 const l = pts.length - 1 pts[l].bul = 0 // 确保最后一点 是直线点 const isclose = equal(pts[0].x, pts[l].x) && equal(pts[0].y, pts[l].y) if (isclose == false) // { const pl_0 = PolylineHelper.create(pts, false) const pl_1s = pl_0.GetOffsetCurves(0.5) let pl_1 = pl_1s[0] if (pl_1 == null) continue pl_1 = pl_1.Reverse() for (const p of pl_1.LineData) { pts.push({ x: p.pt.x, y: p.pt.y, bul: p.bul }) } } // 2 偏移刀r后的 轮廓 let pl_vline = PolylineHelper.create(pts, true) if (pl_vline.IsClockWise) pl_vline = pl_vline.Reverse() const pl_off = pl_vline.GetOffsetCurves(r)[0] if (pl_off == null) continue // if(pl_off.CloseMark == false) ; pls.push(pl_off) } if (pls.length == 0) return // 对 多段线进行 合并,获得最后 造型轮廓 let pl: Polyline | undefined = pls.shift() if (pl == undefined || pl == null) { console.warn("创建造型轮廓失败，pls数组为空") return } if (pls.length > 0) { pl = this.unionPolylines(pl, pls) } // 3 造型轮廓 与 板轮廓干涉 if (pl_block.IntersectWith(pl, 0).length > 0) { pls_model.push(pl) } // 4 2V 轮廓 可能包含了 板轮廓 if (pl.BoundingBox.min.x <= pl_block.BoundingBox.min.x && pl.BoundingBox.min.y <= pl_block.BoundingBox.min.y && pl.BoundingBox.max.x >= pl_block.BoundingBox.max.x && pl.BoundingBox.max.y >= pl_block.BoundingBox.max.y) { pls_model.push(pl) } } /** 创建 点阵pts ，在 板边缘 干涉到的 区域 */ private static createInterPLS(pl_block: Polyline, pts: any[], r: number, pls_model: Polyline[]) { const pl_vline = PolylineHelper.create(pts) let curves curves = pl_vline.Explode() // 分解成 一段 一段的 const outlines: any = [] // 当前在板外的线段 for (let i = 0; i < curves.length;) // 判断 有没有交集 { const curve = curves[i] const pos = getRelation(pl_block, curve, r) if (pos[0] == -1) { if (outlines.length > 0) createPL_outLines(outlines, pls_model, r) } else if (pos[0] == 0 || pos[0] == 1) // 板外,或交接 { outlines.push(curve) } else // 多个连接点 。,要拆分 多段，处理 { const childs = curve.GetSplitCurves(0.2) curves.splice(i, 1) for (let j = childs.length - 1; j >= 0; j--) { const child = childs[j] curves.splice(i, 0, child) } continue } i++ } // 最后一条线段可能是板外，那就要补 板外线段生成 if (outlines.length > 0) createPL_outLines(outlines, pls_model, r) /** 判断 line 与 polyline 的关系 -1 板内，0 板外 ,> 0 相交点数 */ function getRelation(pl_block, curve, r) { const xjd = pl_block.IntersectWith(curve, 0) if (xjd.length > 0) return [xjd.length, xjd] // 相交点 // line 的 4 个点 const box = curve.BoundingBox const x0 = box.min.x - r const y0 = box.min.y - r const x1 = box.max.x + r const y1 = box.max.y + r const p0 = pl_block.PtInCurve(new Vector3(x0, y0)) const p1 = pl_block.PtInCurve(new Vector3(x1, y0)) const p2 = pl_block.PtInCurve(new Vector3(x1, y1)) const p3 = pl_block.PtInCurve(new Vector3(x0, y1)) if (p0 && p1 && p2 && p3) return [-1, []] // 板内 if (!p0 && !p1 && !p2 && !p3) return [0, []] // 板外 return [0, []] } function createPL(x0, y0, x1, y1) { const pts: any[] = [] pts.push({ x: x0, y: y0 }) pts.push({ x: x1, y: y0 }) pts.push({ x: x1, y: y1 }) pts.push({ x: x0, y: y1 }) const pl_line = PolylineHelper.create(pts, true) return pl_line } function createPL_outLines(outlines, pls_model, r) { let xz = 28000; let xy = -100000; let yx = 2900000; let ys = -100000 for (const curve of outlines) { const box = curve.BoundingBox const x0 = box.min.x - r - 1 const y0 = box.min.y - r - 1 const x1 = box.max.x + r + 1 const y1 = box.max.y + r + 1 if (x0 < xz) xz = x0 if (x1 > xy) xy = x1 if (y0 < yx) yx = y0 if (y1 > ys) ys = y1 } const pl_line = createPL(xz, yx, xy, ys) pls_model.push(pl_line) outlines.splice(0) // 清空，可能下面 还有 板外的线段 } } /** 创建 轮廓 pts : {x,y,bul}[] */ static createBorderByPts(pts: any[]): Curve2d[] { const borders: Curve2d[] = [] for (let i = 0; i < pts.length; i++) { let j = i + 1 if (j == pts.length) j = 0 const pi = pts[i] const pj = pts[j] if (pi.bul == 0) { const line = new Line2d(new Point2d(pi.x, pi.y), new Point2d(pj.x, pj.y)) borders.push(line) } else { const arc = new Arc2d(new Point2d(pi.x, pi.y), new Point2d(pj.x, pj.y), pi.bul) borders.push(arc) } } return borders } /** 翻转 多线段 */ static transformBorder(borders: Curve2d[], placeStyle: PlaceStyle, width: number, length: number, blockNo?: any): Curve2d[] { // console.log('翻转 多线段') const newBorders: Curve2d[] = [] for (let i = 0; i < borders.length; i++) { const border = borders[i] const np1 = getPlacePosition(border.StartPoint.m_X, border.StartPoint.m_Y, width, length, placeStyle) const np2 = getPlacePosition(border.EndPoint.m_X, border.EndPoint.m_Y, width, length, placeStyle) let p1 = new Point2d(np1.x, np1.y) let p2 = new Point2d(np2.x, np2.y) if (placeStyle >= 4) [p1, p2] = [p2, p1] let newBorder if (border instanceof Arc2d) { newBorder = new Arc2d(p1, p2, border.Bul) } else { newBorder = new Line2d(p1, p2) } if (border.tagData != undefined || border.tagData != null) { newBorder.tagData = border.tagData newBorder.tagData2 = border.tagData2 } newBorders.push(newBorder) } if (placeStyle >= 4) newBorders.reverse() return newBorders } /** 翻转 多线段 */ static transformBorderNew(borders: Curve2d[], placeStyle: PlaceStyle, width: number, length: number): Curve2d[] { const newBorders: Curve2d[] = [] for (let i = 0; i < borders.length; i++) { const border = borders[i] const np1 = getPlacePosition(border.StartPoint.m_X, border.StartPoint.m_Y, width, length, placeStyle) const np2 = getPlacePosition(border.EndPoint.m_X, border.EndPoint.m_Y, width, length, placeStyle) let p1 = new Point2d(np1.x, np1.y) let p2 = new Point2d(np2.x, np2.y) if (placeStyle >= 4) [p1, p2] = [p2, p1] let newBorder if (border instanceof Arc2d) { newBorder = new Arc2d(p1, p2, border.Bul) } else { newBorder = new Line2d(p1, p2) } if (border.tagData != undefined || border.tagData != null) { newBorder.tagData = border.tagData newBorder.tagData2 = border.tagData2 } newBorders.push(newBorder) } if (placeStyle >= 4) newBorders.reverse() return newBorders } /** 翻转 多段线 */ static transformPolyline(pl: Polyline, placeStyle: PlaceStyle, width: number, length: number): Polyline { const bx = pl.Position.x const by = pl.Position.y let pts = pl.LineData.map((t) => { return { x: t.pt.x, y: t.pt.y, bul: t.bul } }) pts.forEach((t) => { t.x += bx; t.y += by }) // 翻面,翻转点阵 if (placeStyle > 3) { const newPts: any[] = [] for (let j = pts.length - 1; j >= 0; j--) { let i = j - 1 if (i < 0) i = pts.length - 1 const x = pts[j].x const y = pts[j].y const bul = pts[i].bul newPts.push({ x, y, bul }) } pts = newPts } // 转换坐标 for (let i = 0; i < pts.length; i++) { const p = pts[i] const np = getPlacePosition(p.x, p.y, width, length, placeStyle) p.x = np.x p.y = np.y } const npl = PolylineHelper.create(pts) npl.CloseMark = true return npl } /** 偏移 多段线 */ static offsetCurves(borders: Curve2d[], offvalue: number, isOffsetRounding: boolean): Curve2d[] { if (equal(offvalue, 0)) return borders const pts: any[] = [] for (const cur of borders) { const x = cur.StartPoint.m_X const y = cur.StartPoint.m_Y const bul = (cur instanceof Arc2d) ? cur.Bul : 0 pts.push({ x, y, bul }) } if (borders.length != 0) { pts.push({ x: borders[0].StartPoint.m_X, y: borders[0].StartPoint.m_Y, bul: 0 }) } const pl = PolylineHelper.create(pts) // 偏移 倒角：直角不倒角 2023.10.27 QQ陈雄 const pls = isOffsetRounding ? pl.GetFeedingToolPath(offvalue, 0) : pl.GetOffsetCurves(offvalue) if (pls.length == 0) return borders const npls = pls[0] // 偏移多段线 const ita = ConverToPolylineAndSplitArc(npls, false, true) // 拆分多段线 const offsetCurves: Curve2d[] = [] for (let i = 0; i < ita.pts.length; i++) { let j = i + 1 if (j == ita.pts.length) j = 0 const p1 = ita.pts[i] const p2 = ita.pts[j] const np1 = new Point2d(p1.x, p1.y) const np2 = new Point2d(p2.x, p2.y) if (ita.buls[i] == 0) { const line = new Line2d(np1, np2) if (line.m_Length < 0.01) continue offsetCurves.push(line) } else { const arc = new Arc2d(np1, np2, ita.buls[i]) if (arc.m_Radius < 0.01) continue offsetCurves.push(arc) } } return offsetCurves } /** 轮廓 转成 多断线 */ static borderToPolyline(border: Curve2d[], CloseMark = true): Polyline { return PolylineHelper.createByCurve2d(border, CloseMark) } /** 多段线 转成 轮廓 */ static polylineToBorder(pl: Polyline): Curve2d[] { const pts = pl.LineData.map((t) => { return { x: t.pt.x, y: t.pt.y, bul: t.bul } }) return this.createBorderByPts(pts) } /** 合并 多段线 */ static unionPolylines(pl: Polyline, childs: Polyline[]): Polyline { const strPLS = PolylineHelper.getStrPLs([pl].concat(childs)) if (childs.length == 0) return pl try { const contour1 = Contour.CreateContour(pl) const reg1 = new ShapeManager([new Shape(contour1)]) for (const c of childs) { const contour2 = Contour.CreateContour(c, false) if (contour2 == null) { return pl } else { PolylineHelper.getArcRadius const reg2 = new ShapeManager([new Shape(contour2)]) reg1.UnionBoolOperation(reg2) } } if (reg1.ShapeList.length == 0) return pl let newStr = '' const pls: Array = [] for (const sh of reg1.ShapeList) { pls.push(sh.Outline.Curve) } newStr = PolylineHelper.getStrPLs(pls) const cur = reg1.ShapeList[0].Outline.Curve let newpl: Polyline if (cur instanceof Circle) { newpl = PolylineHelper.cicleToPolyline(cur) } else { newpl = cur } newStr = PolylineHelper.getStrPLs([newpl]) return PolylineHelper.resetPosition(newpl) } catch (err) { console.log(err); throw new Error('有非常规造型或2v刀路在合并空间时发生错误，请导出优化结果cfdat文件，并与软件服务商联系!') } } /** 小板 标签位置 */ static resetLabelPos(b: PlaceBlock) { if (!b.blockDetail) { console.warn("PlaceBlock没有blockDetail，无法计算标签位置") return } if (b.blockDetail.labelPosX != -1) return // 已计算 const pls = this.getOrgPloylines(b, false) const pl = pls.pl const mpls = pls.pls_inner const x = b.cutWidth / 2 const y = b.cutLength / 2 b.blockDetail.labelPosX = x b.blockDetail.labelPosY = y // 矩形 且没有挖穿造型 if (b.isUnRegular == false && mpls.length == 0) return const vp = getValidPos() if (vp) { b.blockDetail.labelPosX = vp.x b.blockDetail.labelPosY = vp.y } // 从中心点出发，左右上下偏移，求点。 function getValidPos() { const off = 40 const offw = x / off const offl = y / off let nx = 0; let ny = 0 for (let i = 0; i < offw; i++) { for (let j = 0; j < offl; j++) { nx = x + i * off ny = y + j * off if (isInPolyline(pl, mpls, nx, ny)) return { x: nx, y: ny } nx = x + i * off ny = y - j * off if (isInPolyline(pl, mpls, nx, ny)) return { x: nx, y: ny } nx = x - i * off ny = y + j * off if (isInPolyline(pl, mpls, nx, ny)) return { x: nx, y: ny } nx = x - i * off ny = y - j * off if (isInPolyline(pl, mpls, nx, ny)) return { x: nx, y: ny } } } return null } /** 判断点 在范围内 */ function isInPolyline(pl: Polyline, mpls: Polyline[], x: number, y: number): boolean { for (const mp of mpls) { if (PolylineHelper.isPointInPolyline(mp, x, y)) return false // 在造型洞里头， } return PolylineHelper.isPointInPolyline(pl, x, y) } } }