imes/imes-modelProcessPoints
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 2 Wiki Activity

feat: 提交

Browse Source
This commit is contained in:
lixiang
2025-08-27 08:56:23 +08:00
parent b4b0cea5f2
commit 5c0a73dafc
2 changed files with 0 additions and 57238 deletions
Download Patch File Download Diff File Expand all files Collapse all files

56697
src/processors/modelProcessPoints/modelProcessPoints.test.ts
View File

File diff suppressed because it is too large Load Diff

541
src/processors/modelProcessPoints/modelProcessPoints.ts
View File

@@ -1,541 +0,0 @@
import { ConfigBase, ProcessorBase, ProcessorContext } from "cut-abstractions";
/**
* 获取造型在开料大板的坐标
*
* 输入的造型数据为 要处理的造型数据
*/
export class ModelProcessPointsProc extends ProcessorBase<ModelProcessPointsInput, ModelProcessPointsOutput, ModelProcessPointsProcConfig> {
get name(): string {
return 'ModelProcessPoints';
}
get version(): string {
return '1.0.0';
}
exec(context: ProcessorContext<ModelProcessPointsInput, ModelProcessPointsOutput, ModelProcessPointsProcConfig>): Promise<void> | void {
return new Promise(async (resolve, reject) => {
try {
if (context.input) {
if (context.input.block) {
// if (Array.isArray(context.input.block.models) && context.input.block.models.length > 0) {
/** 板件的坐标X */
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
}
}
/**
* 提要：
* 1、这里的造型数据 都是 基于板件（小板）的正面的点阵数据
* 2、坐标转换 依据2个要素进行转换 【板件（小板）的优化坐标】 和 【板件（小板）的放置方式】
*
* 先处理放置方式 在处理 优化坐标 会简单很多
*/
let resBlock = this.handleByPositionType(context.input.block, context.input.targetPosition)
let res1 = this.handleByPlaceXY(resBlock.models, placeX, placeY)
resBlock.models = res1
output.block = {
...output.block,
...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: ModelProcessPointsInputBlock, targetPosition: PositionType) {
let _width = block.width
let _length = block.length
let temp = JSON.parse(JSON.stringify(block))
let resBlock: ModelProcessPointsInputBlock = {
...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
// 处理造型的部分
/** 造型输出的数据 */
let models: ModelProcessItem[] = []
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)
}
/** 左转 或者 右转 长宽值 要互换 */
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
}
/** 获取翻面 后的 放置方式 */
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(model: ModelProcessItem, valueX: number) {
let newModel = { ...model }
for (const i in newModel.pts) {
newModel.pts[i] = {
x: valueX - newModel.pts[i].y,
y: newModel.pts[i].x
}
}
return newModel
}
/** 左转
* @param model 造型数据
* @param valueX 排版长
*/
change_turnLeft(model: ModelProcessItem, valueX: number) {
let newModel = { ...model }
for (const i in newModel.pts) {
newModel.pts[i] = {
x: newModel.pts[i].y,
y: valueX - newModel.pts[i].x
}
}
return newModel
}
/** 翻转 改变 xy 坐标
* @param model 造型数据
* @param valueX 排版长
* @param valueY 排版宽
*/
change_turnAround(model: ModelProcessItem, valueX: number, valueY: number) {
let newModel = { ...model }
for (const i in newModel.pts) {
newModel.pts[i] = {
x: valueX - newModel.pts[i].x,
y: valueY - newModel.pts[i].y
}
}
return newModel
}
/**翻面 改变 y坐标 */
change_turnFace(model: ModelProcessItem, valueY: number) {
let newModel = { ...model }
for (const i in newModel.pts) {
newModel.pts[i].y = valueY - newModel.pts[i].y
}
return newModel
}
/** 给 弧度值 取反 */
reverseBuls(model: ModelProcessItem) {
let newModel = { ...model }
for (const i in newModel.buls) {
newModel.buls[i] = -newModel.buls[i]
}
return newModel
}
/**正面的放置方式 集合*/
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
}
/** 根据 优化后的坐标XY偏移 */
handleByPlaceXY(models: ModelProcessItem[], placeX: number, placeY: number) {
let newModels: ModelProcessItem[] = []
for (const model of models) {
let newModel: ModelProcessItem = { ...model }
let newPts = []
for (const k in newModel.pts) {
let p = {
x: model.pts[k].x + placeX,
y: model.pts[k].y + placeY
}
newPts.push(p)
}
newModel.pts = newPts
newModels.push(newModel)
}
return newModels
}
}
/** 处理器输入-- 获取造型在大板的刀路 */
export type ModelProcessPointsInput = {
/** 小板数据 */
block: ModelProcessPointsInputBlock,
/** 小板的最终的放置位置 */
targetPosition: PositionType
}
/** 处理器输入--小板 -- 获取造型在大板的刀路 */
export type ModelProcessPointsInputBlock = {
/** 板件唯一标识 */
id: string | number,
/** 板件基于大板的 坐标X */
x: number,
/** 板件基于大板的 坐标y */
y: number,
/** 板件(小板)长 */
length: number,
/** 板件(小板)宽 */
width: number,
/** 造型数据 依据放置方式positionType 下的造型数据 默认为 依据放置方式positionType.FRONT 的造型数据 */
models: ModelProcessItem[],
/** 板件的原放置方式 默认为正面（0） 不传则为正面 原 placestyle*/
positionType?: PositionType,
/** 偏移值 */
offsetInfo: OffsetInfo
}
/** 板件 上下左右 偏移值信息 */
export type OffsetInfo = {
top: number,
bottom: number,
left: number,
right: number,
}
/** 处理器输出--小板 -- 获取造型在大板的刀路 */
export type ModelProcessPointsOutputBlock = {
/** 板件唯一标识 */
id: string | number
/** 放置方式 */
positionType: PositionType
/** 造型数据 */
models: ModelProcessItem[]
/** 板件(小板)长 */
length: number,
/** 板件(小板)宽 */
width: number,
/** 偏移值 */
offsetInfo: OffsetInfo
}
/** 处理器输出-- 获取造型在大板的刀路 */
export type ModelProcessPointsOutput = {
block: ModelProcessPointsOutputBlock
}
/** 处理器配置-- 获取造型在大板的刀路 暂无 */
export declare class ModelProcessPointsProcConfig extends ConfigBase {
}
/** 造型类 */
export interface ModelProcessItem {
/** 加工项唯一标识 */
id?: string | number
/**
* 加工点数组
*/
pts: IPoint[];
/**
* 凸度数组
*/
buls: number[];
/** 加工面 */
face: FaceType
}
/** 加工面 */
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'
/**
* 原放置方式 依据 目标放置方式 转 行为的 转换关系
*
* 注：原放置方式 为 翻面 转换后 的数值
* 若要支持 翻转转换前 需对内容进一步填充
*/
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
}