移除 ModelProcessPointsProc 功能无法覆盖业务,

新增 TransformProcessItemByPositionProc  小板翻转处理器, 可获得小板 孔、造型、轮廓 在大板上的坐标,并修改 放置方式修改后的小板其他属性
This commit is contained in:
2025-08-26 18:21:32 +08:00
parent a13586526f
commit b4b0cea5f2
6 changed files with 30569 additions and 14 deletions

21
.vscode/launch.json vendored Normal file
View File

@@ -0,0 +1,21 @@
{
// 使用 IntelliSense 了解相关属性。
// 悬停以查看现有属性的描述。
// 欲了解更多信息,请访问: https://go.microsoft.com/fwlink/?linkid=830387
"version": "0.2.0",
"configurations": [
{
"type": "node",
"request": "launch",
"name": "启动程序",
"skipFiles": [
"<node_internals>/**"
],
"program": "${workspaceFolder}\\src\\processors\\modelProcessPoints\\modelProcessPoints.test.ts",
"outFiles": [
"${workspaceFolder}/**/*.js"
]
}
]
}

View File

@@ -1,6 +1,6 @@
{
"name": "@imes-modelprocesspoints/libs",
"version": "0.1.0",
"version": "1.1.0",
"description": "",
"type": "module",
"scripts": {
@@ -21,7 +21,7 @@
"./utils": "./src/utils/index.ts"
},
"dependencies": {
"cut-abstractions": "http://gitea.cf/MES-FE/cut-abstractions/releases/download/0.2/cut-abstractions-0.2.1.tgz"
"cut-abstractions": "http://gitea.cf/MES-FE/cut-abstractions/releases/download/0.3/cut-abstractions-0.3.4.tgz"
},
"devDependencies": {
"@types/node": "^24.0.10",

View File

@@ -1,7 +1,2 @@
/**
* @package @mes-modelprocesspoints/libs
* @description 工作流处理器类库,在这个文件中使用导出时,不要在路径中使用'@',否则模块无法加载
*/
// CutOrder
export * from "./processors/modelProcessPoints/modelProcessPoints";
// export * from "./processors/modelProcessPoints/modelProcessPoints";
export * from "./processors/TransformProcessItemByPosition/TransformProcessItemByPosition"

View File

@@ -0,0 +1,555 @@
import { ConfigBase, FaceType, IPoint, OffsetInfo, PositionType, ProcessorBase, ProcessorContext, RotationAction } from "cut-abstractions";
/**
*
*
* 坐标转换
*/
export class TransformProcessItemByPositionProc extends ProcessorBase<TransformProcessItemByPositionInput, TransformProcessItemByPositionOutput, TransformProcessItemByPositionProcConfig> {
get name(): string {
return 'TransformProcessItemByPosition';
}
get version(): string {
return '1.0.0';
}
exec(context: ProcessorContext<TransformProcessItemByPositionInput, TransformProcessItemByPositionOutput, TransformProcessItemByPositionProcConfig>): Promise<void> | void {
return new Promise(async (resolve, reject) => {
try {
if (context.input) {
if (context.input.blocks) {
let output: TransformProcessItemByPositionOutput = {
blocks: []
}
/**
* 提要:
* 1、这里的造型数据 都是 基于板件(小板)的正面的点阵数据
* 2、坐标转换 依据2个要素进行转换 【板件(小板)的优化坐标】 和 【板件(小板)的放置方式】
*
* 先处理放置方式 在处理 优化坐标 会简单很多
*/
for (const k in context.input.blocks) {
let block = context.input.blocks[k]
let targetPosition = block.targetPositionType || 0
let resBlock: TransformProcessItemByPositionOutputBlock = this.handleByPositionType(block, targetPosition)
resBlock = await this.handleProcessItemPointsData(resBlock)
// resBlock = res1
output.blocks.push(resBlock)
}
context.output = output
resolve()
} else {
reject('ModelProcessPoints error: input.block is undefined;')
}
} else {
reject('ModelProcessPoints error: input is undefined;')
}
resolve()
} catch (error) {
reject(error);
}
});
}
/**
* 根据小板的放置方式进行偏移
*
* 提要:models内的造型数据 都是以小板正面 为基准
* 即 PositionType.FRONT
* 需要 以下几种情况
* 加工项所在的面 -- 2种 正 反 -- 但实际 在改处理器应该是不考虑的
* 小板放置方式 -- 8 种 详见 PositionType 处理器入参 默认为 PositionType.FRONT
*
* 细节:
* 加工项 为正面 且放置方式为正面的 无需操作 直接输出,其它情况 都需要做处理
*
* 如果有 翻面的情况 弧度值需要取反
*
* 思考: 坐标转换的实质 其实 也就是以下几种行为
* 面与面的行为: 翻面a 面到 b 面
* 单面内的行为: 左转 右转 翻转
*
* 这里其实 可以有个流程
* 先判定 是不是要 翻面
* 然后再去 做 单面内的行为 相关的坐标转换 将问题集中在一个面的操作上
*
* PositionType XXX 转到 PositionType XX 无非就是 【左转 或 右转 或 翻转】 或者 先 翻面 然后 【左转 或 右转 或 翻转】
* 那么 就
* 有翻面 先 翻面 然后 再 【左| 右 | 翻】 转
*
* 注: 这里的操作 都依据绘图可视的X Y 轴进行处理
* block.width 对应 Y轴的值
* block.length 对应 x轴的值
*/
handleByPositionType(block: TransformProcessItemByPositionInputBlock, targetPosition: PositionType) {
let _width = block.width
let _length = block.length
let temp = JSON.parse(JSON.stringify(block))
let resBlock: TransformProcessItemByPositionOutputBlock = {
...temp
}
/** 默认 正面 */
if (resBlock.positionType == undefined) {
resBlock.positionType = PositionType.FRONT
}
//#region 板件 进行分析 翻面 以及 行为
let face = this.getFace(resBlock.positionType)
let targetFace = this.getFace(targetPosition)
if (face == -1) {
// 异常情况
console.log(`block-${resBlock.id}:block.positionType is invalid`)
}
if (targetFace == -1) {
// 异常情况
console.log(`targetFace:targetFace is invalid`)
}
// 判定是否要翻面
const isTurn = !(face == targetFace)
/** 翻面后的 放置方式 */
let tempPosition = resBlock.positionType
if (isTurn) {
tempPosition = this.getPositionAfterTurnFace(resBlock.positionType)
}
// 获取行为 左|右|翻转|不操作
const action = this.getDir(tempPosition, targetPosition)
//#endregion
resBlock.models = this.transformByBlock(resBlock.models, isTurn, action, _width, _length)
resBlock.holes = this.transformByBlock(resBlock.holes, isTurn, action, _width, _length)
resBlock.board = this.transformByBlock(resBlock.board, isTurn, action, _width, _length)
/** 左转 或者 右转 长宽值 要互换 */
if (action == 'turnLeft' || action == 'turnRight') {
resBlock = {
...resBlock,
width: _length,
length: _width,
}
}
/** 更加行为 以及是否 翻转 转换 板件的偏移值 */
if (isTurn) {
// 翻面 左右封边互换 上下不变
resBlock.offsetInfo = {
...resBlock.offsetInfo,
top: resBlock.offsetInfo.bottom,
bottom: resBlock.offsetInfo.top
}
}
switch (action) {
case 'turnAround':
// 翻转
resBlock.offsetInfo = {
top: resBlock.offsetInfo.bottom,
bottom: resBlock.offsetInfo.top,
left: resBlock.offsetInfo.right,
right: resBlock.offsetInfo.left
}
break;
case 'turnLeft':
resBlock.offsetInfo = {
top: resBlock.offsetInfo.right,
right: resBlock.offsetInfo.bottom,
bottom: resBlock.offsetInfo.left,
left: resBlock.offsetInfo.top
}
break
case 'turnRight':
resBlock.offsetInfo = {
top: resBlock.offsetInfo.left,
left: resBlock.offsetInfo.bottom,
bottom: resBlock.offsetInfo.right,
right: resBlock.offsetInfo.top
}
break
default:
break;
}
return resBlock
}
/**
*
* @param processItemList 加工项数据集
* @param isTurn 是否翻面
* @param action 放置行为
* @param width 小板宽---优化尺寸
* @param length 小板长---优化尺寸
*
* @returns TransformProcessingItem[] 依据翻面和放置行为转换后的加工项数据集
*/
transformByBlock(processItemList: TransformProcessingItem[], isTurn: boolean, action: RotationAction, width: number, length: number): TransformProcessingItem[] {
/** 要输出的加工项的数据 */
let newProcessItemList: TransformProcessingItem[] = []
for (const i in processItemList) {
let processItem = { ...processItemList[i] }
/** 如果要 翻面 那就先把面 翻过来 */
if (isTurn) {
// 翻面 x 不变 Y 变
processItem = this.change_turnFace(processItem, width)
// 然后 弧度值要取反
processItem = this.reverseBuls(processItem)
}
/**
* 根据 行为标识 转换坐标
* 注: 左转 或者时右转 需要 转换 板件(小板)的 长宽值
*
*/
switch (action) {
case 'doNothing':
// 啥事也不做
break;
case 'turnAround':
// 翻转 x 变 y 也变
processItem = this.change_turnAround(processItem, length, width)
break;
case 'turnLeft':
processItem = this.change_turnLeft(processItem, length)
break;
case 'turnRight':
processItem = this.change_turnRight(processItem, length)
break;
default:
break;
}
newProcessItemList.push(processItem)
}
return newProcessItemList
}
/** 获取翻面 后的 放置方式 */
getPositionAfterTurnFace(v: PositionType) {
let res = transitions_PositionTurnFace[v]
return res
}
/** 获取行为 左|右|翻转|不需要操作 */
getDir(v1: PositionType, v2: PositionType) {
let flag: RotationAction = 'doNothing'
try {
flag = transitions_PositionToAction[v1][v2]
} catch (error) {
console.log('逻辑异常!请保证 v1 v2 的放置方式处在同一个面上,或者输入的值在转换关系中没有匹配的值')
flag = 'doNothing'
}
return flag
}
/** 右转
* @param model 造型数据
* @param valueX 排版长
*/
change_turnRight(processItem: TransformProcessingItem, valueX: number) {
let newProcessItem = { ...processItem }
for (const i in newProcessItem.pts) {
newProcessItem.pts[i] = {
x: valueX - newProcessItem.pts[i].y,
y: newProcessItem.pts[i].x
}
}
return newProcessItem
}
/** 左转
* @param model 造型数据
* @param valueX 排版长
*/
change_turnLeft(processItem: TransformProcessingItem, valueX: number) {
let newProcessItem = { ...processItem }
for (const i in newProcessItem.pts) {
newProcessItem.pts[i] = {
x: newProcessItem.pts[i].y,
y: valueX - newProcessItem.pts[i].x
}
}
return newProcessItem
}
/** 翻转 改变 xy 坐标
* @param model 造型数据
* @param valueX 排版长
* @param valueY 排版宽
*/
change_turnAround(processItem: TransformProcessingItem, valueX: number, valueY: number) {
let newProcessItem = { ...processItem }
for (const i in newProcessItem.pts) {
newProcessItem.pts[i] = {
x: valueX - newProcessItem.pts[i].x,
y: valueY - newProcessItem.pts[i].y
}
}
return newProcessItem
}
/**翻面 改变 y坐标 */
change_turnFace(processItem: TransformProcessingItem, valueY: number) {
let newProcessItem = { ...processItem }
for (const i in newProcessItem.pts) {
newProcessItem.pts[i].y = valueY - newProcessItem.pts[i].y
}
return newProcessItem
}
/** 给 弧度值 取反 */
reverseBuls(processItem: TransformProcessingItem) {
let newProcessItem = { ...processItem }
for (const i in newProcessItem.buls) {
newProcessItem.buls[i] = -newProcessItem.buls[i]
}
return newProcessItem
}
/**正面的放置方式 集合*/
frontArr = [
PositionType.FRONT,
PositionType.FRONT_TURN_BACK,
PositionType.FRONT_TURN_LEFT,
PositionType.FRONT_TURN_RIGHT
]
/** 反面的放置方式 集合*/
backArr = [
PositionType.BACK,
PositionType.BACK_TURN_BACK,
PositionType.BACK_TURN_LEFT,
PositionType.BACK_TURN_RIGHT
]
/** 根据放置方式 获取面 */
getFace(positionValue: PositionType) {
let res = -1
if (this.frontArr.includes(positionValue)) {
res = FaceType.FRONT
}
if (this.backArr.includes(positionValue)) {
res = FaceType.BACK
}
return res
}
/** 处理入参的加工项数据
* 将加工数据以大板为基准 进行偏移
*/
async handleProcessItemPointsData(block: TransformProcessItemByPositionOutputBlock) {
let placeX = block.x
let placeY = block.y
// 造型
let models = block.models
// 孔
let holes = block.holes
// 板件轮廓
let board = block.board
if (Array.isArray(models) && models.length > 0) {
models = await this.handleByPlaceXY(models, placeX, placeY)
} else {
models = []
}
if (Array.isArray(holes) && holes.length > 0) {
holes = await this.handleByPlaceXY(holes, placeX, placeY)
} else {
holes = []
}
if (Array.isArray(board) && board.length > 0) {
board = await this.handleByPlaceXY(board, placeX, placeY)
} else {
board = []
}
block = {
...block,
holes: holes,
models: models,
board: board
}
return block
}
/** 根据 优化后的坐标XY偏移 */
handleByPlaceXY(processItemList: TransformProcessingItem[], placeX: number, placeY: number) {
let newProcessItemList: TransformProcessingItem[] = []
for (const processItem of processItemList) {
let newProcessItem: TransformProcessingItem = { ...processItem }
let newPts = []
for (const k in newProcessItem.pts) {
let p = {
x: newProcessItem.pts[k].x + placeX,
y: newProcessItem.pts[k].y + placeY
}
newPts.push(p)
}
newProcessItem.pts = newPts
newProcessItemList.push(newProcessItem)
}
return newProcessItemList
}
}
/** 处理器输入-- 获取造型在大板的刀路 */
export type TransformProcessItemByPositionInput = {
/** 小板数据 */
blocks: TransformProcessItemByPositionInputBlock[],
}
/** 处理器输入--小板 -- 获取造型在大板的刀路 */
export type TransformProcessItemByPositionInputBlock = {
/** 板件唯一标识 */
id: string | number,
/** 板件基于大板的 坐标X */
x: number,
/** 板件基于大板的 坐标y */
y: number,
/** 板件(小板)长 */
length: number,
/** 板件(小板)宽 */
width: number,
/** 造型数据 依据放置方式positionType 下的造型数据 默认为 依据放置方式positionType.FRONT 的造型数据 */
models: TransformProcessingItem[],
/** 孔数据 */
holes: TransformProcessingItem[],
/** 轮廓数据 */
board: TransformProcessingItem[],
/** 板件的原放置方式 默认为正面0 不传则为正面 原 placestyle*/
positionType?: PositionType,
/** 目标放置方式 优化后会有这个数据 或者是 手动排版 */
targetPositionType?: PositionType
/** 偏移值 */
offsetInfo: OffsetInfo
}
/** 处理器输出--小板 修改放置方式后 内部的加工数据-- 基于大板 */
export type TransformProcessItemByPositionOutputBlock = {
/** 板件唯一标识 */
id: string | number
/** 放置方式 */
positionType: PositionType
/** 造型数据 依据放置方式positionType 下的造型数据 默认为 依据放置方式positionType.FRONT 的造型数据 */
models: TransformProcessingItem[],
/** 孔数据 */
holes: TransformProcessingItem[],
/** 轮廓数据 看需求 因为存在多种类型的轮廓 所有这里为数组 */
board: TransformProcessingItem[],
/** 板件(小板)长 */
length: number,
/** 板件(小板)宽 */
width: number,
/** 板件坐标 */
x: number,
/** 板件坐标 */
y: number,
/** 偏移值 */
offsetInfo: OffsetInfo,
}
/** 处理器输出-- 获取造型在大板的刀路 */
export type TransformProcessItemByPositionOutput = {
blocks: TransformProcessItemByPositionOutputBlock[]
}
/** 处理器配置-- 获取造型在大板的刀路 暂无 */
export declare class TransformProcessItemByPositionProcConfig extends ConfigBase {
}
/** 造型类 */
export interface TransformProcessingItem {
/** 加工项唯一标识 */
id?: string | number
/**
* 加工点数组
*/
pts: IPoint[];
/**
* 凸度数组
*/
buls: number[];
/** 加工面 */
face: FaceType
}
/**
* 原放置方式 依据 目标放置方式 转 行为的 转换关系
*
* 注:原放置方式 为 翻面 转换后 的数值
* 若要支持 翻转转换前 需对内容进一步填充
*/
export const transitions_PositionToAction: any = {
[PositionType.FRONT]: {
[PositionType.FRONT_TURN_BACK]: 'turnAround',
[PositionType.FRONT_TURN_LEFT]: 'turnLeft',
[PositionType.FRONT_TURN_RIGHT]: 'turnRight',
[PositionType.FRONT]: 'doNothing'
},
[PositionType.FRONT_TURN_LEFT]: {
[PositionType.FRONT]: 'turnRight',
[PositionType.FRONT_TURN_RIGHT]: 'turnAround',
[PositionType.FRONT_TURN_BACK]: 'turnLeft',
[PositionType.FRONT_TURN_LEFT]: 'doNothing'
},
[PositionType.FRONT_TURN_RIGHT]: {
[PositionType.FRONT]: 'turnLeft',
[PositionType.FRONT_TURN_LEFT]: 'turnAround',
[PositionType.FRONT_TURN_BACK]: 'turnRight',
[PositionType.FRONT_TURN_RIGHT]: 'doNothing'
},
[PositionType.FRONT_TURN_BACK]: {
[PositionType.FRONT]: 'turnAround',
[PositionType.FRONT_TURN_LEFT]: 'turnRight',
[PositionType.FRONT_TURN_RIGHT]: 'turnLeft',
[PositionType.FRONT_TURN_BACK]: 'doNothing'
},
[PositionType.BACK]: {
[PositionType.BACK_TURN_BACK]: 'turnAround',
[PositionType.BACK_TURN_LEFT]: 'turnLeft',
[PositionType.BACK_TURN_RIGHT]: 'turnRight',
[PositionType.BACK]: 'doNothing'
},
[PositionType.BACK_TURN_LEFT]: {
[PositionType.BACK]: 'turnRight',
[PositionType.BACK_TURN_RIGHT]: 'turnAround',
[PositionType.BACK_TURN_BACK]: 'turnLeft',
[PositionType.BACK_TURN_LEFT]: 'doNothing'
},
[PositionType.BACK_TURN_RIGHT]: {
[PositionType.BACK]: 'turnLeft',
[PositionType.BACK_TURN_LEFT]: 'turnAround',
[PositionType.BACK_TURN_BACK]: 'turnRight',
[PositionType.BACK_TURN_RIGHT]: 'doNothing'
},
[PositionType.BACK_TURN_BACK]: {
[PositionType.BACK]: 'turnAround',
[PositionType.BACK_TURN_LEFT]: 'turnRight',
[PositionType.BACK_TURN_RIGHT]: 'turnLeft',
[PositionType.BACK_TURN_BACK]: 'doNothing'
}
}
/** 放置方式 翻转后的转换关系 */
export const transitions_PositionTurnFace: any = {
[PositionType.FRONT]: PositionType.BACK,
[PositionType.FRONT_TURN_RIGHT]: PositionType.BACK_TURN_LEFT,
[PositionType.FRONT_TURN_BACK]: PositionType.BACK_TURN_BACK,
[PositionType.FRONT_TURN_LEFT]: PositionType.BACK_TURN_RIGHT,
[PositionType.BACK]: PositionType.FRONT,
[PositionType.BACK_TURN_BACK]: PositionType.FRONT_TURN_BACK,
[PositionType.BACK_TURN_LEFT]: PositionType.FRONT_TURN_RIGHT,
[PositionType.BACK_TURN_RIGHT]: PositionType.FRONT_TURN_LEFT
}

File diff suppressed because it is too large Load Diff

View File

@@ -96,8 +96,6 @@ export class ModelProcessPointsProc extends ProcessorBase<ModelProcessPointsInpu
* block.length 对应 x轴的值
*/
handleByPositionType(block: ModelProcessPointsInputBlock, targetPosition: PositionType) {
/** 造型输出的数据 */
let models: ModelProcessItem[] = []
let _width = block.width
@@ -139,6 +137,9 @@ export class ModelProcessPointsProc extends ProcessorBase<ModelProcessPointsInpu
//#endregion
// 处理造型的部分
/** 造型输出的数据 */
let models: ModelProcessItem[] = []
for (const i in resBlock.models) {
let model = { ...resBlock.models[i] }
/** 如果要 翻面 那就先把面 翻过来 */
@@ -179,8 +180,6 @@ export class ModelProcessPointsProc extends ProcessorBase<ModelProcessPointsInpu
models.push(model)
}
/** 左转 或者 右转 长宽值 要互换 */
if (action == 'turnLeft' || action == 'turnRight') {
resBlock = {
@@ -341,7 +340,7 @@ export class ModelProcessPointsProc extends ProcessorBase<ModelProcessPointsInpu
return res
}
/** 根据 优化后的坐标XY便宜 */
/** 根据 优化后的坐标XY偏移 */
handleByPlaceXY(models: ModelProcessItem[], placeX: number, placeY: number) {
let newModels: ModelProcessItem[] = []
for (const model of models) {