更新：类型 TransformProcessingItem 添加 depth （可选） TransformProcessingItem ?: number

添加原因：1、后续可能有依据 Z轴做坐标转化 2、对接后续流程后发现  有depth  后续可能会少很多操作

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

src/processors/TransformProcessItemByPosition/TransformProcessItemByPosition.ts

@@ -1,37 +1,24 @@
-import { ConfigBase, ProcessorBase, ProcessorContext } from "cut-abstractions";
+import { ConfigBase, FaceType, IPoint, OffsetInfo, PositionType, ProcessorBase, ProcessorContext, RotationAction } from "cut-abstractions";
 
 /**
- * 获取造型在开料大板的坐标
  *  
- * 输入的造型数据为 要处理的造型数据
+ * 
+ *  坐标转换
  */
-export class ModelProcessPointsProc extends ProcessorBase<ModelProcessPointsInput, ModelProcessPointsOutput, ModelProcessPointsProcConfig> {
+export class TransformProcessItemByPositionProc extends ProcessorBase<TransformProcessItemByPositionInput, TransformProcessItemByPositionOutput, TransformProcessItemByPositionProcConfig> {
     get name(): string {
-        return 'ModelProcessPoints';
+        return 'TransformProcessItemByPosition';
     }
     get version(): string {
         return '1.0.0';
     }
-    exec(context: ProcessorContext<ModelProcessPointsInput, ModelProcessPointsOutput, ModelProcessPointsProcConfig>): Promise<void> | void {
+    exec(context: ProcessorContext<TransformProcessItemByPositionInput, TransformProcessItemByPositionOutput, TransformProcessItemByPositionProcConfig>): Promise<void> | void {
         return new Promise(async (resolve, reject) => {
             try {
                 if (context.input) {
-                    if (context.input.block) {
+                    if (context.input.blocks) {
-                        // if (Array.isArray(context.input.block.models) && context.input.block.models.length > 0) {
+                        let output: TransformProcessItemByPositionOutput = {
-                        /** 板件的坐标X */
+                            blocks: []
-                        let placeX = context.input.block.x
-                        /** 板件的坐标Y */
-                        let placeY = context.input.block.y
-
-                        let output: ModelProcessPointsOutput = {
-                            block: {
-                                id: context.input.block.id,
-                                positionType: context.input.block.positionType || 0,
-                                models: [],
-                                width: context.input.block.width,
-                                length: context.input.block.length,
-                                offsetInfo: context.input.block.offsetInfo
-                            }
                         }
 
                         /** 
@@ -41,16 +28,15 @@ export class ModelProcessPointsProc extends ProcessorBase<ModelProcessPointsInpu
                          * 
                          * 先处理放置方式  在处理  优化坐标  会简单很多
                         */
-
+                        for (const k in context.input.blocks) {
-                        let resBlock = this.handleByPositionType(context.input.block, context.input.targetPosition)
+                            let block = context.input.blocks[k]
-
+                            let targetPosition = block.targetPositionType || 0
-                        let res1 = this.handleByPlaceXY(resBlock.models, placeX, placeY)
+                            let resBlock: TransformProcessItemByPositionOutputBlock = this.handleByPositionType(block, targetPosition)
-
+                            resBlock = await this.handleProcessItemPointsData(resBlock)
-                        resBlock.models = res1
+                            // resBlock = res1
-                        output.block = {
+                            output.blocks.push(resBlock)
-                            ...output.block,
-                            ...resBlock,
                         }
+
                         context.output = output
                         resolve()
                     } else {
@@ -95,15 +81,13 @@ export class ModelProcessPointsProc extends ProcessorBase<ModelProcessPointsInpu
      *  block.width 对应 Y轴的值
      *  block.length 对应 x轴的值
     */
-    handleByPositionType(block: ModelProcessPointsInputBlock, targetPosition: PositionType) {
+    handleByPositionType(block: TransformProcessItemByPositionInputBlock, targetPosition: PositionType) {
-        /** 造型输出的数据 */
-        let models: ModelProcessItem[] = []
 
         let _width = block.width
 
         let _length = block.length
         let temp = JSON.parse(JSON.stringify(block))
-        let resBlock: ModelProcessPointsInputBlock = {
+        let resBlock: TransformProcessItemByPositionOutputBlock = {
             ...temp
         }
         /** 默认 正面 */
@@ -138,47 +122,11 @@ export class ModelProcessPointsProc extends ProcessorBase<ModelProcessPointsInpu
 
         //#endregion
 
-        // 处理造型的部分
-        for (const i in resBlock.models) {
-            let model = { ...resBlock.models[i] }
-            /** 如果要 翻面 那就先把面 翻过来 */
-            if (isTurn) {
-                // 翻面  x 不变 Y 变  
-                model = this.change_turnFace(model, _width)
-                // 然后 弧度值要取反
-                model = this.reverseBuls(model)
-            }
 
-            /** 
-             * 根据 行为标识  转换坐标  
-             * 注: 左转 或者时右转 需要 转换 板件（小板）的 长宽值
-             * 
-            */
-            switch (action) {
-                case 'doNothing':
-                    // 啥事也不做
-                    break;
-
-                case 'turnAround':
-                    //  翻转 x 变 y 也变
-                    model = this.change_turnAround(model, _length, _width)
-                    break;
-                case 'turnLeft':
-
-                    model = this.change_turnLeft(model, _length)
-                    break;
-
-                case 'turnRight':
-                    model = this.change_turnRight(model, _length)
-                    break;
-
-                default:
-                    break;
-            }
-
-            models.push(model)
-        }
 
+        resBlock.models = this.transformByBlock(resBlock.models, isTurn, action, _width, _length)
+        resBlock.holes = this.transformByBlock(resBlock.holes, isTurn, action, _width, _length)
+        resBlock.border = this.transformByBlock(resBlock.border, isTurn, action, _width, _length)
 
 
         /** 左转 或者 右转  长宽值 要互换 */
@@ -233,6 +181,62 @@ export class ModelProcessPointsProc extends ProcessorBase<ModelProcessPointsInpu
 
         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]
@@ -254,64 +258,64 @@ export class ModelProcessPointsProc extends ProcessorBase<ModelProcessPointsInpu
      * @param model 造型数据
      * @param valueX 排版长
     */
-    change_turnRight(model: ModelProcessItem, valueX: number) {
+    change_turnRight(processItem: TransformProcessingItem, valueX: number) {
-        let newModel = { ...model }
+        let newProcessItem = { ...processItem }
-        for (const i in newModel.pts) {
+        for (const i in newProcessItem.pts) {
-            newModel.pts[i] = {
+            newProcessItem.pts[i] = {
-                x: valueX - newModel.pts[i].y,
+                x: valueX - newProcessItem.pts[i].y,
-                y: newModel.pts[i].x
+                y: newProcessItem.pts[i].x
             }
         }
-        return newModel
+        return newProcessItem
     }
 
     /** 左转 
      * @param model 造型数据
      * @param valueX 排版长
     */
-    change_turnLeft(model: ModelProcessItem, valueX: number) {
+    change_turnLeft(processItem: TransformProcessingItem, valueX: number) {
-        let newModel = { ...model }
+        let newProcessItem = { ...processItem }
-        for (const i in newModel.pts) {
+        for (const i in newProcessItem.pts) {
-            newModel.pts[i] = {
+            newProcessItem.pts[i] = {
-                x: newModel.pts[i].y,
+                x: newProcessItem.pts[i].y,
-                y: valueX - newModel.pts[i].x
+                y: valueX - newProcessItem.pts[i].x
             }
         }
-        return newModel
+        return newProcessItem
     }
     /** 翻转  改变 xy 坐标 
      * @param model 造型数据
      * @param valueX 排版长
      * @param valueY 排版宽
     */
-    change_turnAround(model: ModelProcessItem, valueX: number, valueY: number) {
+    change_turnAround(processItem: TransformProcessingItem, valueX: number, valueY: number) {
-        let newModel = { ...model }
+        let newProcessItem = { ...processItem }
-        for (const i in newModel.pts) {
+        for (const i in newProcessItem.pts) {
-            newModel.pts[i] = {
+            newProcessItem.pts[i] = {
-                x: valueX - newModel.pts[i].x,
+                x: valueX - newProcessItem.pts[i].x,
-                y: valueY - newModel.pts[i].y
+                y: valueY - newProcessItem.pts[i].y
             }
         }
-        return newModel
+        return newProcessItem
     }
 
 
 
     /**翻面 改变 y坐标 */
-    change_turnFace(model: ModelProcessItem, valueY: number) {
+    change_turnFace(processItem: TransformProcessingItem, valueY: number) {
-        let newModel = { ...model }
+        let newProcessItem = { ...processItem }
-        for (const i in newModel.pts) {
+        for (const i in newProcessItem.pts) {
-            newModel.pts[i].y = valueY - newModel.pts[i].y
+            newProcessItem.pts[i].y = valueY - newProcessItem.pts[i].y
         }
-        return newModel
+        return newProcessItem
     }
     /** 给 弧度值 取反 */
-    reverseBuls(model: ModelProcessItem) {
+    reverseBuls(processItem: TransformProcessingItem) {
-        let newModel = { ...model }
+        let newProcessItem = { ...processItem }
-        for (const i in newModel.buls) {
+        for (const i in newProcessItem.buls) {
-            newModel.buls[i] = -newModel.buls[i]
+            newProcessItem.buls[i] = -newProcessItem.buls[i]
         }
-        return newModel
+        return newProcessItem
     }
     /**正面的放置方式 集合*/
     frontArr = [
@@ -340,36 +344,72 @@ export class ModelProcessPointsProc extends ProcessorBase<ModelProcessPointsInpu
         }
         return res
     }
+    /** 处理入参的加工项数据
+     *  将加工数据以大板为基准 进行偏移
+     */
+    async handleProcessItemPointsData(block: TransformProcessItemByPositionOutputBlock) {
+        let placeX = block.x
+        let placeY = block.y
 
-    /** 根据 优化后的坐标XY便宜 */
+        // 造型
-    handleByPlaceXY(models: ModelProcessItem[], placeX: number, placeY: number) {
+        let models = block.models
-        let newModels: ModelProcessItem[] = []
+        // 孔
-        for (const model of models) {
+        let holes = block.holes
-            let newModel: ModelProcessItem = { ...model }
+        // 板件轮廓
+        let border = block.border
+
+        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(border) && border.length > 0) {
+            border = await this.handleByPlaceXY(border, placeX, placeY)
+        } else {
+            border = []
+        }
+        block = {
+            ...block,
+            holes: holes,
+            models: models,
+            border: border
+        }
+        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 newModel.pts) {
+            for (const k in newProcessItem.pts) {
                 let p = {
-                    x: model.pts[k].x + placeX,
+                    x: newProcessItem.pts[k].x + placeX,
-                    y: model.pts[k].y + placeY
+                    y: newProcessItem.pts[k].y + placeY
                 }
                 newPts.push(p)
             }
-            newModel.pts = newPts
+            newProcessItem.pts = newPts
-            newModels.push(newModel)
+            newProcessItemList.push(newProcessItem)
         }
 
-        return newModels
+        return newProcessItemList
     }
 }
 /** 处理器输入-- 获取造型在大板的刀路 */
-export type ModelProcessPointsInput = {
+export type TransformProcessItemByPositionInput = {
     /** 小板数据 */
-    block: ModelProcessPointsInputBlock,
+    blocks: TransformProcessItemByPositionInputBlock[],
-    /** 小板的最终的放置位置 */
+
-    targetPosition: PositionType
 }
 /** 处理器输入--小板 -- 获取造型在大板的刀路 */
-export type ModelProcessPointsInputBlock = {
+export type TransformProcessItemByPositionInputBlock = {
     /** 板件唯一标识 */
     id: string | number,
     /** 板件基于大板的 坐标X */
@@ -381,48 +421,56 @@ export type ModelProcessPointsInputBlock = {
     /** 板件(小板)宽 */
     width: number,
     /** 造型数据 依据放置方式positionType 下的造型数据  默认为 依据放置方式positionType.FRONT 的造型数据 */
-    models: ModelProcessItem[],
+    models: TransformProcessingItem[],
+    /** 孔数据 */
+    holes: TransformProcessingItem[],
+    /** 轮廓数据 */
+    border: TransformProcessingItem[],
     /** 板件的原放置方式 默认为正面（0） 不传则为正面  原 placestyle*/
     positionType?: PositionType,
+    /** 目标放置方式 优化后会有这个数据  或者是 手动排版 */
+    targetPositionType?: PositionType
     /** 偏移值 */
     offsetInfo: OffsetInfo
 
 }
-/** 板件 上下左右 偏移值信息 */
+
-export type OffsetInfo = {
+/** 处理器输出--小板 修改放置方式后  内部的加工数据-- 基于大板 */
-    top: number,
+export type TransformProcessItemByPositionOutputBlock = {
-    bottom: number,
-    left: number,
-    right: number,
-}
-/** 处理器输出--小板 -- 获取造型在大板的刀路 */
-export type ModelProcessPointsOutputBlock = {
     /** 板件唯一标识 */
     id: string | number
     /** 放置方式 */
     positionType: PositionType
-    /** 造型数据 */
+    /** 造型数据 依据放置方式positionType 下的造型数据  默认为 依据放置方式positionType.FRONT 的造型数据 */
-    models: ModelProcessItem[]
+    models: TransformProcessingItem[],
+    /** 孔数据 */
+    holes: TransformProcessingItem[],
+    /** 轮廓数据 看需求  因为存在多种类型的轮廓 所有这里为数组 */
+    border: TransformProcessingItem[],
     /** 板件(小板)长 */
     length: number,
     /** 板件(小板)宽 */
     width: number,
+    /** 板件坐标 */
+    x: number,
+    /** 板件坐标 */
+    y: number,
     /** 偏移值 */
-    offsetInfo: OffsetInfo
+    offsetInfo: OffsetInfo,
+
 }
 /** 处理器输出-- 获取造型在大板的刀路 */
-export type ModelProcessPointsOutput = {
+export type TransformProcessItemByPositionOutput = {
-    block: ModelProcessPointsOutputBlock
+    blocks: TransformProcessItemByPositionOutputBlock[]
 }
 
 /** 处理器配置-- 获取造型在大板的刀路  暂无 */
-export declare class ModelProcessPointsProcConfig extends ConfigBase {
+export declare class TransformProcessItemByPositionProcConfig extends ConfigBase {
 
 }
 
-
 /** 造型类 */
-export interface ModelProcessItem {
+export interface TransformProcessingItem {
     /** 加工项唯一标识 */
     id?: string | number
     /**
@@ -435,43 +483,9 @@ export interface ModelProcessItem {
     buls: number[];
     /** 加工面 */
     face: FaceType
-
+    /** 加工项深度 */
+    depth?: number
 }
-
-/** 加工面 */
-export enum FaceType {
-    /** 正面 */
-    FRONT = 0,
-    /** 反面 */
-    BACK = 1,
-}
-
-/** 点坐标类 */
-export interface IPoint { x: number, y: number; }
-
-/** 小板的放置方式 */
-export enum PositionType {
-    /** 正面 */
-    FRONT = 0,
-    /** 正面右转 */
-    FRONT_TURN_RIGHT = 1,
-    /** 正面后转 */
-    FRONT_TURN_BACK = 2,
-    /** 正面左转 */
-    FRONT_TURN_LEFT = 3,
-    /** 反面 */
-    BACK = 4,
-    /** 反面右转 */
-    BACK_TURN_RIGHT = 5,
-    /** 反面后转 */
-    BACK_TURN_BACK = 6,
-    /** 反面左转 */
-    BACK_TURN_LEFT = 7,
-}
-
-
-/** 行为类型  */
-export type RotationAction = 'doNothing' | 'turnLeft' | 'turnRight' | 'turnAround'
 /** 
  * 原放置方式 依据 目标放置方式  转 行为的 转换关系 
  *