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

新增 TransformProcessItemByPositionProc  小板翻转处理器， 可获得小板 孔、造型、轮廓 在大板上的坐标，并修改 放置方式修改后的小板其他属性

.vscode/launch.json

@@ -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"
+            ]
+        }
+    ]
+}

package.json

@@ -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",

src/index.ts

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

src/processors/TransformProcessItemByPosition/TransformProcessItemByPosition.ts

@@ -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
+}

src/processors/modelProcessPoints/modelProcessPoints.ts

@@ -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) {