Public
/
WebCAD
mirror of https://gitee.com/cf-fz/WebCAD.git
7
1
Fork 0
Code Issues Projects Releases Wiki Activity

!2480 开发:铰链类型判断重构

Browse Source
pull/2499/head
林三 10 months ago committed by ChenX
parent a41f66b140
commit 96989664da
9 changed files with 544 additions and 118 deletions
Show Stats Download Patch File Download Diff File

103
src/Add-on/DrawBoard/DrawDoorDrawer/DrawDoorTool.ts
Unescape View File

@ -5,6 +5,7 @@ import { app } from "../../../ApplicationServices/Application";
import { EBoardKeyList } from "../../../Common/BoardKeyList";
import { Solid3D } from "../../../Common/InterfereUtil";
import { DuplicateRecordCloning } from "../../../Common/Status";
import { safeEval } from "../../../Common/eval";
import { ExtrudeHole } from "../../../DatabaseServices/3DSolid/ExtrudeHole";
import { SweepSolid } from "../../../DatabaseServices/3DSolid/SweepSolid";
import { CADObject } from "../../../DatabaseServices/CADObject";
@ -19,6 +20,7 @@ import { TemplateSizeBoard } from "../../../DatabaseServices/Template/ProgramTem
import { TemplateVisualSpace } from "../../../DatabaseServices/Template/ProgramTempate/TemplateVisualSpace";
import { GetOnlineTemplate } from "../../../DatabaseServices/Template/TempateUtils";
import { TemplateRecord } from "../../../DatabaseServices/Template/TemplateRecord";
import { userConfig } from "../../../Editor/UserConfig";
import { Box3Ext } from "../../../Geometry/Box";
import { equaln, isParallelTo } from "../../../Geometry/GeUtils";
import { OBB } from "../../../Geometry/OBB/obb";
@ -39,6 +41,8 @@ import { IsDoor, IsHandle, IsHinge } from "../../HideSelect/HideSelectUtils";
* */
const MoveNum: number = 8;
export type HingeType = "全盖铰链" | "半盖铰链" | "无盖铰链";
export class DrawDoorTool
{
/**id模板对应表*/
@ -333,7 +337,8 @@ export class DrawDoorTool
}
}
}
protected GetHingeTemp(info: IDoorInfo, door: TemplateRecord)
// hingeTypes[0]绑定左开门或上开门 hingeTypes[1]绑定右开门或下开门
protected GetHingeTemp(info: IDoorInfo, door: TemplateRecord, hingeTypes: HingeType[])
{
if (info.tempInfo.hingeTemp && info.tempInfo.hingeTemp.id && this._idTempMap.has(info.tempInfo.hingeTemp.id))
{
@ -344,6 +349,8 @@ export class DrawDoorTool
let count = this.option.hingeCount;
const isLROpen = info.openDir === DoorOpenDir.Left || info.openDir === DoorOpenDir.Right;
let hingeName = (info.openDir === DoorOpenDir.Left || info.openDir === DoorOpenDir.Top) ? hingeTypes[0] : hingeTypes[1];
let zExpr = "";
let jlsjExpr = "___JLSJ";
let jlxjExpr = "___JLXJ";
@ -401,8 +408,12 @@ export class DrawDoorTool
for (let objId of temp.Objects)
{
if (objId.Object instanceof HardwareCompositeEntity)
let hinge = objId.Object;
if (hinge instanceof HardwareCompositeEntity)
{
hinge.HardwareOption.name = hingeName;
this.hingeSet.add(objId);
}
}
temp.HParam.expr = "0";
temp.LParam.expr = "0";
@ -658,7 +669,7 @@ export class DrawDoorTool
{
parseTypedHinges.add(ironware.Id);
//设置铰链类型
SetHingeType(br, ironware);
// SetHingeType(br, ironware);
}
}
else if (isParallelTo(ironware.Normal, br.Normal) || !isDoor)
@ -743,11 +754,11 @@ export class DrawDoorTool
intent: Intent.DANGER,
});
SetNoPareTypeHigneName(parseTypedHinges, this.hingeSet);
// SetNoPareTypeHigneName(parseTypedHinges, this.hingeSet);
return needUpdate;
}
getSpaceAllBoards(templateEntitys: Entity[])
getSpaceAllEnts(templateEntitys: Entity[])
{
let box = this.spaceParse.SpaceBox.clone().applyMatrix4(this.spaceParse.SpaceOCS);
@ -987,6 +998,25 @@ export class DrawDoorTool
}
}
/**
* 获取铰链类型
* @param thickness 与空间X向量平行相交板的厚度
* @param doorExtend 门板延申距离
* @returns HingeType
*/
protected GetHingeType(thickness: number, doorExtend: number): HingeType
{
if (!thickness) return "无盖铰链";
let hingeLidRule = userConfig.hingeLidRule;
let noLid = safeEval(hingeLidRule.noLid, { BH: thickness });
let allLid = safeEval(hingeLidRule.allLid, { BH: thickness });
if (doorExtend - allLid > -1e-3)
return "全盖铰链";
else if (doorExtend - noLid < 1e-3)
return "无盖铰链";
else
return "半盖铰链";
}
}
/**
@ -1009,52 +1039,30 @@ export function SetNoPareTypeHigneName(parseTypedHinges: Set<ObjectId<CADObject>
}
}
/**
* 设置铰链的类型(全盖 无盖 半盖)
* @param br
* @param ironware
* @returns void
*/
export function SetHingeType(br: Board, ironware: HardwareCompositeEntity): void
{
let temp = ironware.Template.Object as TemplateRecord;
if (temp.AllEntitys.length > 1 && !ironware.HardwareOption.name.includes("铰链")) return;
let moveValue = temp.GetParam("MOVE")?.value as number;
let r = temp.GetParam("R")?.value as number;
if (moveValue === undefined || r === undefined) return;
if (moveValue < r - br.Thickness / 2 - 1e-3)
ironware.HardwareOption.name = "全盖铰链";
else if (moveValue > r - 1e-3)
ironware.HardwareOption.name = "无盖铰链";
else
ironware.HardwareOption.name = "半盖铰链";
}
//OBB增加10容差
export function getFuzzOBB(obb: OBB, normalizeZ: Vector3, isParallel: boolean, parentIntersectEntOCS: Matrix4, isExtrudeSolid: boolean): OBB
export function getFuzzOBB(obb: OBB, normalizeZ: Vector3, parentIntersectEntOCS: Matrix4, isExtrudeSolid: boolean): OBB
{
let addSize = isParallel ? new Vector3(0, 0, 10) : new Vector3(-0.1, -0.1, 10);
let addSize = new Vector3(-0.1, -0.1, 10);
if (!isExtrudeSolid)
addSize.applyMatrix4(parentIntersectEntOCS.clone().setPosition(0, 0, 0));
let halfSizes = obb.halfSizes.add(addSize.applyMatrix4((obb.ocs).clone().setPosition(0, 0, 0)));
let ocs = obb.ocs.clone();
let vz = normalizeZ.clone().multiplyScalar(10);
if (!isParallel)
{
const XNormal = new Vector3().setFromMatrixColumn(ocs, 0).multiplyScalar(0.1);
const YNormal = new Vector3().setFromMatrixColumn(ocs, 1).multiplyScalar(0.1);
const ZNormal = new Vector3().setFromMatrixColumn(ocs, 2).multiplyScalar(0.1);
ocs.elements[12] += XNormal.x;
ocs.elements[13] += XNormal.y;
ocs.elements[14] += XNormal.z;
ocs.elements[12] += YNormal.x;
ocs.elements[13] += YNormal.y;
ocs.elements[14] += YNormal.z;
ocs.elements[12] += ZNormal.x;
ocs.elements[13] += ZNormal.y;
ocs.elements[14] += ZNormal.z;
}
const XNormal = new Vector3().setFromMatrixColumn(ocs, 0).multiplyScalar(0.1);
const YNormal = new Vector3().setFromMatrixColumn(ocs, 1).multiplyScalar(0.1);
const ZNormal = new Vector3().setFromMatrixColumn(ocs, 2).multiplyScalar(0.1);
ocs.elements[12] += XNormal.x;
ocs.elements[13] += XNormal.y;
ocs.elements[14] += XNormal.z;
ocs.elements[12] += YNormal.x;
ocs.elements[13] += YNormal.y;
ocs.elements[14] += YNormal.z;
ocs.elements[12] += ZNormal.x;
ocs.elements[13] += ZNormal.y;
ocs.elements[14] += ZNormal.z;
ocs.elements[12] -= Math.abs(vz.x);
ocs.elements[13] -= Math.abs(vz.y);
@ -1069,7 +1077,7 @@ export function getFuzzOBB(obb: OBB, normalizeZ: Vector3, isParallel: boolean, p
* @param ZNormal 铰链Z向量方向
* @param translate checkEnts偏移
*/
export function IsBoxAndEntitysIntersect(checkEnts: Entity[], intersectEnts: Entity[], ZNormal: Vector3, translate?: Vector3, parentIntersectEntOCS?: Matrix4, parentcheckEntOCS?: Matrix4, isParallel?: boolean): boolean
export function IsBoxAndEntitysIntersect(checkEnts: Entity[], intersectEnts: Entity[], ZNormal: Vector3, translate?: Vector3, parentIntersectEntOCS?: Matrix4, parentcheckEntOCS?: Matrix4): boolean
{
for (let checkEnt of checkEnts)
if (checkEnt instanceof HardwareCompositeEntity)
@ -1078,8 +1086,7 @@ export function IsBoxAndEntitysIntersect(checkEnts: Entity[], intersectEnts: Ent
if (parentcheckEntOCS) ocs = new Matrix4().multiplyMatrices(parentcheckEntOCS, ocs);
let ents = checkEnt.Entitys.filter(ent => ent instanceof ExtrudeHole || ent instanceof SweepSolid || ent instanceof ExtrudeSolid || ent instanceof HardwareCompositeEntity);
//没有碰撞不return 继续检测其他checkEnt
if (IsBoxAndEntitysIntersect(ents, intersectEnts, ZNormal, translate, undefined, ocs, isParallel))
if (IsBoxAndEntitysIntersect(ents, intersectEnts, ZNormal, translate, undefined, ocs))
return true;
}
else
@ -1094,7 +1101,7 @@ export function IsBoxAndEntitysIntersect(checkEnts: Entity[], intersectEnts: Ent
let ocs = intersectEnt.OCS;
if (parentIntersectEntOCS) ocs = new Matrix4().multiplyMatrices(parentIntersectEntOCS, ocs);
let ents = intersectEnt.Entitys.filter(ent => ent instanceof ExtrudeHole || ent instanceof SweepSolid || ent instanceof ExtrudeSolid || ent instanceof HardwareCompositeEntity);
if (IsBoxAndEntitysIntersect([newCheckEnt], ents, ZNormal, translate, ocs, undefined, isParallelTo(new Vector3().setFromMatrixColumn(ocs, 0), newCheckEnt.Normal)))
if (IsBoxAndEntitysIntersect([newCheckEnt], ents, ZNormal, translate, ocs))
return true;
}
else
@ -1103,7 +1110,7 @@ export function IsBoxAndEntitysIntersect(checkEnts: Entity[], intersectEnts: Ent
if (parentIntersectEntOCS) ent.ApplyMatrix(parentIntersectEntOCS);
if (translate) ent.ApplyMatrix(new Matrix4().setPosition(translate));
let obb = getFuzzOBB(newCheckEnt.OBB, ZNormal, isParallel, parentIntersectEntOCS, newCheckEnt instanceof ExtrudeSolid);
let obb = getFuzzOBB(newCheckEnt.OBB, ZNormal, parentIntersectEntOCS, newCheckEnt instanceof ExtrudeSolid);
if (obb.intersectsOBB(ent.OBB))
return true;
}

124
src/Add-on/DrawBoard/DrawDoorDrawer/DrawLeftRightOpenDoor.ts
Unescape View File

@ -1,4 +1,5 @@
import { Intent } from "@blueprintjs/core";
import { Vector3 } from "three";
import { app } from "../../../ApplicationServices/Application";
import { EBoardKeyList } from "../../../Common/BoardKeyList";
import { Board } from "../../../DatabaseServices/Entity/Board";
@ -8,6 +9,7 @@ import { TemplateSizeBoard } from "../../../DatabaseServices/Template/ProgramTem
import { SetTemplatePositionAndSetParent } from "../../../DatabaseServices/Template/TempateUtils";
import { TemplateRecord } from "../../../DatabaseServices/Template/TemplateRecord";
import { TemplateSplitType } from "../../../DatabaseServices/Template/TemplateType";
import { isParallelTo } from "../../../Geometry/GeUtils";
import { AppToaster } from "../../../UI/Components/Toaster";
import { DoorOpenDir, IDoorInfo } from "../../../UI/Store/DoorInterface";
import { DrillType } from "../../DrawDrilling/DrillType";
@ -38,10 +40,93 @@ export class DrawLeftRightOpenDoor extends DrawDoorTool
cbHightDrillOption: { down: cbDrillDown, up: cbDrillUp, left: cbDrillLeft, right: cbDrillRight },
} = this.option;
//最左侧立板
let leftParallelToXBoard: Board;
//最右侧立板
let rightParallelToXBoard: Board;
let spaceBox = this.spaceParse.SpaceBox.clone();
const xNormal = new Vector3().setFromMatrixColumn(this.spaceParse.SpaceOCS, 0);
let spaceAllBoards = this.getSpaceAllEnts(templateSpace.AllEntitys);
//计算与空间X向量平行的侧板
for (let ent of spaceAllBoards)
{
if (ent instanceof Board)
{
let isParallelToX = isParallelTo(xNormal, ent.Normal);
let entBox = ent.GetBoundingBoxInMtx(this.spaceParse.SpaceOCSInv);
if (entBox.max.x - spaceBox.min.x <= 1e-2)
{
if (!leftParallelToXBoard && entBox.intersectsBox(spaceBox) && isParallelToX)
leftParallelToXBoard = ent;
}
else if (entBox.min.x - spaceBox.max.x >= -1e-2)
{
if (!rightParallelToXBoard && entBox.intersectsBox(spaceBox) && isParallelToX)
rightParallelToXBoard = ent;
}
}
}
//每块门板组所在的左右侧板
let leftBoard: Board = leftParallelToXBoard;
let rightBoard: Board;
let ZGParam: number = this.option.leftExt - this.option.leftSpace;
let YGParam: number;
//按列处理
for (let i = 0; i < col; i++)
{
let lValue = this.colWidths[i];
let colTemp = this.GetColTemplate(lValue, i);
let verTemp: TemplateRecord;
//预先加载 补的立板
if (i < col - 1)
{
verTemp = this.GetVerticalTemp(size.z, size.y - offset, thickness, !this.isDrawVerBrS[i], isAuto);
if (verTemp.Objects.length > 0)
{
verBoardIds.push(...verTemp.Objects);
let en = verTemp.Objects[0].Object as Board;
en.Name = verticalBoardName;
en.BoardProcessOption[EBoardKeyList.UpSealed] = lbSealedUp.toString();
en.BoardProcessOption[EBoardKeyList.DownSealed] = lbSealedDown.toString();
en.BoardProcessOption[EBoardKeyList.LeftSealed] = lbSealedLeft.toString();
en.BoardProcessOption[EBoardKeyList.RightSealed] = lbSealedRight.toString();
en.BoardProcessOption.highDrill = [lbDrillDown, lbDrillRight, lbDrillUp, lbDrillLeft];
let drillSet = new Set(en.BoardProcessOption.highDrill);
if (drillSet.size > 1)
en.BoardProcessOption.drillType = DrillType.More;
else if (drillSet.size === 1)
en.BoardProcessOption.drillType = en.BoardProcessOption.highDrill[0];
if (this.surroundOption && useBoardProcessOption)
{
en.BoardProcessOption[EBoardKeyList.RoomName] = this.surroundOption[EBoardKeyList.RoomName];
en.BoardProcessOption[EBoardKeyList.CabinetName] = this.surroundOption[EBoardKeyList.CabinetName];
en.BoardProcessOption[EBoardKeyList.Mat] = this.surroundOption[EBoardKeyList.Mat];
en.BoardProcessOption[EBoardKeyList.BrMat] = this.surroundOption[EBoardKeyList.BrMat];
en.BoardProcessOption[EBoardKeyList.Color] = this.surroundOption[EBoardKeyList.Color];
}
//使用补的立板当作右侧板
rightBoard = en;
YGParam = rightBoard.Thickness / 2 - this.option.midSpace / 2;
}
else
rightBoard = undefined;
}
else
{
rightBoard = rightParallelToXBoard;
YGParam = this.option.rightExt - this.option.rightSpace;
}
let leftOpenDirType = this.GetHingeType(leftBoard?.Thickness, ZGParam);
let rightOpenDirType = this.GetHingeType(rightBoard?.Thickness, YGParam);
for (let j = 0; j < row; j++)
{
@ -51,9 +136,10 @@ export class DrawLeftRightOpenDoor extends DrawDoorTool
let hasLayerDown = j === 0 ? this.isDrawLayBrS[j + 1] : this.isDrawLayBrS[j];
let rowTemplate = this.GetRowTemplate(info, this.rowHeighs[j], hasLayerDown, this.isDrawLayBrS[j + 1]);
isWarnHingeRules = this.GetHingeTemp(info, rowTemplate) || isWarnHingeRules;
isWarnHingeRules = this.GetHingeTemp(info, rowTemplate, [leftOpenDirType, rightOpenDirType]) || isWarnHingeRules;
colTemp.Children.push(rowTemplate.Id);
//补层板
if (j < row - 1)
{
if (this.isDrawLayBrS[j + 1])
@ -86,37 +172,21 @@ export class DrawLeftRightOpenDoor extends DrawDoorTool
}
}
}
}
//添加占位空间或者层板
templateSpace.Children.push(colTemp.Id);
if (i < col - 1)
//添加占位空间或者立板 立板的话绑定左侧板
if (verTemp)
{
let verTemp = this.GetVerticalTemp(size.z, size.y - offset, thickness, !this.isDrawVerBrS[i], isAuto);
templateSpace.Children.push(verTemp.Id);
if (verTemp.Objects.length > 0)
{
verBoardIds.push(...verTemp.Objects);
let en = verTemp.Objects[0].Object as Board;
en.Name = verticalBoardName;
en.BoardProcessOption[EBoardKeyList.UpSealed] = lbSealedUp.toString();
en.BoardProcessOption[EBoardKeyList.DownSealed] = lbSealedDown.toString();
en.BoardProcessOption[EBoardKeyList.LeftSealed] = lbSealedLeft.toString();
en.BoardProcessOption[EBoardKeyList.RightSealed] = lbSealedRight.toString();
en.BoardProcessOption.highDrill = [lbDrillDown, lbDrillRight, lbDrillUp, lbDrillLeft];
let drillSet = new Set(en.BoardProcessOption.highDrill);
if (drillSet.size > 1)
en.BoardProcessOption.drillType = DrillType.More;
else if (drillSet.size === 1)
en.BoardProcessOption.drillType = en.BoardProcessOption.highDrill[0];
if (this.surroundOption && useBoardProcessOption)
{
en.BoardProcessOption[EBoardKeyList.RoomName] = this.surroundOption[EBoardKeyList.RoomName];
en.BoardProcessOption[EBoardKeyList.CabinetName] = this.surroundOption[EBoardKeyList.CabinetName];
en.BoardProcessOption[EBoardKeyList.Mat] = this.surroundOption[EBoardKeyList.Mat];
en.BoardProcessOption[EBoardKeyList.BrMat] = this.surroundOption[EBoardKeyList.BrMat];
en.BoardProcessOption[EBoardKeyList.Color] = this.surroundOption[EBoardKeyList.Color];
}
leftBoard = verTemp.Objects[0].Object as Board;
ZGParam = leftBoard.Thickness / 2 - this.option.midSpace / 2;
}
templateSpace.Children.push(verTemp.Id);
else
leftBoard = undefined;
}
}
@ -133,7 +203,7 @@ export class DrawLeftRightOpenDoor extends DrawDoorTool
await SetTemplatePositionAndSetParent(this.spaceParse, templateSpace);
let spaceAllBoards = this.getSpaceAllBoards(templateSpace.AllEntitys);
spaceAllBoards = this.getSpaceAllEnts(templateSpace.AllEntitys);
let needReUpdate = this.RelativeMetalsToBoard(spaceAllBoards, false);
if (needReUpdate)

120
src/Add-on/DrawBoard/DrawDoorDrawer/DrawUpDownOpenDoor.ts
Unescape View File

@ -1,4 +1,5 @@
import { Intent } from "@blueprintjs/core";
import { Vector3 } from "three";
import { app } from "../../../ApplicationServices/Application";
import { EBoardKeyList } from "../../../Common/BoardKeyList";
import { Board } from "../../../DatabaseServices/Entity/Board";
@ -8,6 +9,7 @@ import { TemplateSizeBoard } from "../../../DatabaseServices/Template/ProgramTem
import { SetTemplatePositionAndSetParent } from "../../../DatabaseServices/Template/TempateUtils";
import { TemplateRecord } from "../../../DatabaseServices/Template/TemplateRecord";
import { TemplateSplitType } from "../../../DatabaseServices/Template/TemplateType";
import { isParallelTo } from "../../../Geometry/GeUtils";
import { AppToaster } from "../../../UI/Components/Toaster";
import { DoorOpenDir, IDoorInfo } from "../../../UI/Store/DoorInterface";
import { DrillType } from "../../DrawDrilling/DrillType";
@ -37,10 +39,92 @@ export class DrawUpDownOpenDoor extends DrawDoorTool
cbHightDrillOption: { down: cbDrillDown, up: cbDrillUp, left: cbDrillLeft, right: cbDrillRight },
} = this.option;
//最上面层板
let topParallelToXBoard: Board;
//最下面层板
let bottomParallelToXBoard: Board;
let spaceBox = this.spaceParse.SpaceBox.clone();
const zNormal = new Vector3().setFromMatrixColumn(this.spaceParse.SpaceOCS, 2);
let spaceAllBoards = this.getSpaceAllEnts(templateSpace.AllEntitys);
//计算与空间X向量平行的侧板
for (let ent of spaceAllBoards)
{
if (ent instanceof Board)
{
const isParallelToZ = isParallelTo(zNormal, ent.Normal);
let entBox = ent.GetBoundingBoxInMtx(this.spaceParse.SpaceOCSInv);
if (entBox.min.z - spaceBox.max.z >= -1e-3)
{
if (!topParallelToXBoard && entBox.intersectsBox(spaceBox) && isParallelToZ)
topParallelToXBoard = ent;
}
else if (spaceBox.min.z - entBox.max.z >= -1e-3)
{
if (!bottomParallelToXBoard && entBox.intersectsBox(spaceBox) && zNormal)
bottomParallelToXBoard = ent;
}
}
}
//每块门板组所在的上下层板
let topBoard: Board = topParallelToXBoard;
let bottomBoard: Board = bottomParallelToXBoard;
let SGParam: number = this.option.topExt - this.option.topSpace;
let XGParam: number = this.option.bottomExt - this.option.bottomSpace;
for (let i = 0; i < row; i++)
{
let lValue = this.rowHeighs[i];
let rowTemp = this.GetRowTemplate(lValue, i);
let layerTemp: TemplateRecord;
//预先加载 补的层板
if (i < row - 1)
{
layerTemp = this.GetLayerTemp(size.y, size.x, thickness, !this.isDrawLayBrS[i + 1], isAuto);
if (layerTemp.Objects.length > 0)
{
layBoardIds.push(...layerTemp.Objects);
let en = layerTemp.Objects[0].Object as Board;
en.Name = layerBoardName;
en.BoardProcessOption[EBoardKeyList.UpSealed] = topBrSeal.toString();
en.BoardProcessOption[EBoardKeyList.DownSealed] = bottomBrSeal.toString();
en.BoardProcessOption[EBoardKeyList.LeftSealed] = leftBrSeal.toString();
en.BoardProcessOption[EBoardKeyList.RightSealed] = rightBrSeal.toString();
en.BoardProcessOption.highDrill = [cbDrillDown, cbDrillRight, cbDrillUp, cbDrillLeft];
let drillSet = new Set(en.BoardProcessOption.highDrill);
if (drillSet.size > 1)
en.BoardProcessOption.drillType = DrillType.More;
else if (drillSet.size === 1)
en.BoardProcessOption.drillType = en.BoardProcessOption.highDrill[0];
if (this.surroundOption && useBoardProcessOption)
{
en.BoardProcessOption[EBoardKeyList.RoomName] = this.surroundOption[EBoardKeyList.RoomName];
en.BoardProcessOption[EBoardKeyList.CabinetName] = this.surroundOption[EBoardKeyList.CabinetName];
en.BoardProcessOption[EBoardKeyList.Mat] = this.surroundOption[EBoardKeyList.Mat];
en.BoardProcessOption[EBoardKeyList.BrMat] = this.surroundOption[EBoardKeyList.BrMat];
en.BoardProcessOption[EBoardKeyList.Color] = this.surroundOption[EBoardKeyList.Color];
}
//使用补的层板当作上层板
topBoard = en;
SGParam = topBoard.Thickness / 2 - this.option.midSpace / 2;
}
else
topBoard = undefined;
}
else
{
topBoard = topParallelToXBoard;
SGParam = this.option.topExt - this.option.topSpace;
}
let topOpenDirType = this.GetHingeType(topBoard?.Thickness, SGParam);
let bottomOpenDirType = this.GetHingeType(bottomBoard?.Thickness, XGParam);
for (let j = 0; j < col; j++)
{
@ -51,7 +135,7 @@ export class DrawUpDownOpenDoor extends DrawDoorTool
let hasVerRight = j === col - 1 ? this.isDrawVerBrS[j - 1] : this.isDrawVerBrS[j];
let colTemplate = this.GetColTemplate(info, this.colWidths[j], hasVerLeft, hasVerRight);
isWarnHingeRules = this.GetHingeTemp(info, colTemplate) || isWarnHingeRules;
isWarnHingeRules = this.GetHingeTemp(info, colTemplate, [topOpenDirType, bottomOpenDirType]) || isWarnHingeRules;
rowTemp.Children.push(colTemplate.Id);
if (j < col - 1)
@ -88,36 +172,20 @@ export class DrawUpDownOpenDoor extends DrawDoorTool
}
}
//添加占位空间或者层板
templateSpace.Children.push(rowTemp.Id);
if (i < row - 1)
//添加占位空间或者层板 层板的话绑定上层板
if (layerTemp)
{
let layerTemp = this.GetLayerTemp(size.y, size.x, thickness, !this.isDrawLayBrS[i + 1], isAuto);
templateSpace.Children.push(layerTemp.Id);
if (layerTemp.Objects.length > 0)
{
layBoardIds.push(...layerTemp.Objects);
let en = layerTemp.Objects[0].Object as Board;
en.Name = layerBoardName;
en.BoardProcessOption[EBoardKeyList.UpSealed] = topBrSeal.toString();
en.BoardProcessOption[EBoardKeyList.DownSealed] = bottomBrSeal.toString();
en.BoardProcessOption[EBoardKeyList.LeftSealed] = leftBrSeal.toString();
en.BoardProcessOption[EBoardKeyList.RightSealed] = rightBrSeal.toString();
en.BoardProcessOption.highDrill = [cbDrillDown, cbDrillRight, cbDrillUp, cbDrillLeft];
let drillSet = new Set(en.BoardProcessOption.highDrill);
if (drillSet.size > 1)
en.BoardProcessOption.drillType = DrillType.More;
else if (drillSet.size === 1)
en.BoardProcessOption.drillType = en.BoardProcessOption.highDrill[0];
if (this.surroundOption && useBoardProcessOption)
{
en.BoardProcessOption[EBoardKeyList.RoomName] = this.surroundOption[EBoardKeyList.RoomName];
en.BoardProcessOption[EBoardKeyList.CabinetName] = this.surroundOption[EBoardKeyList.CabinetName];
en.BoardProcessOption[EBoardKeyList.Mat] = this.surroundOption[EBoardKeyList.Mat];
en.BoardProcessOption[EBoardKeyList.BrMat] = this.surroundOption[EBoardKeyList.BrMat];
en.BoardProcessOption[EBoardKeyList.Color] = this.surroundOption[EBoardKeyList.Color];
}
bottomBoard = layerTemp.Objects[0].Object as Board;
XGParam = bottomBoard.Thickness / 2 - this.option.midSpace / 2;
}
templateSpace.Children.push(layerTemp.Id);
else
bottomBoard = undefined;
}
}
@ -134,7 +202,7 @@ export class DrawUpDownOpenDoor extends DrawDoorTool
await SetTemplatePositionAndSetParent(this.spaceParse, templateSpace);
let spaceAllBoards = this.getSpaceAllBoards(templateSpace.AllEntitys);
spaceAllBoards = this.getSpaceAllEnts(templateSpace.AllEntitys);
let needReUpdate = this.RelativeMetalsToBoard(spaceAllBoards, true);
if (needReUpdate)

18
src/Common/CheckoutVaildValue.ts
Unescape View File

@ -699,6 +699,24 @@ export namespace CheckoutValid
}
return "";
}
case "noLid":
{
let val = safeEval(v, { BH: 18 });
if (isNaN(val))
return "数值不能为空且必须为数字";
if (val < 0)
return "数值必须大于等于0";
return "";
}
case "allLid":
{
let val = safeEval(v, { BH: 18 });
if (isNaN(val))
return "数值不能为空且必须为数字";
if (val < 0)
return "数值必须大于等于0";
return "";
}
default:
return "";
}

16
src/Editor/UserConfig.ts
Unescape View File

@ -44,7 +44,7 @@ export interface IChat
export class UserConfig implements IConfigStore
{
private readonly _version = 37; //🌟🌟每次更新必须向上添加一次版本号🌟🌟
private readonly _version = 38; //🌟🌟每次更新必须向上添加一次版本号🌟🌟
@observable designer = ""; //一键布局的设计师
_renderType: RenderType = RenderType.Wireframe;
@observable maxSize: IMaxSizeProps = {
@ -173,6 +173,11 @@ export class UserConfig implements IConfigStore
printResolution: 1450,
};
@observable templateDisplayCount: number = 100; //插入模板时显示的最大个数
//铰链类型规则
@observable hingeLidRule = {
noLid: "5",
allLid: "14"
};
constructor()
{
this.Init();
@ -273,6 +278,10 @@ export class UserConfig implements IConfigStore
printResolution: 1450,
});
this.templateDisplayCount = 100;
Object.assign(this.hingeLidRule, {
noLid: "5",
allLid: "14"
});
}
SaveConfig()
{
@ -328,6 +337,7 @@ export class UserConfig implements IConfigStore
show2DPathLine: this.show2DPathLine,
show2DPathObject: this.show2DPathObject,
templateDisplayCount: this.templateDisplayCount,
hingeLidRule: toJS(this.hingeLidRule)
}
};
}
@ -494,6 +504,10 @@ export class UserConfig implements IConfigStore
{
this.templateDisplayCount = config.option.templateDisplayCount;
}
if (config.option.version > 37)
{
Object.assign(this.hingeLidRule, config.option.hingeLidRule);
}
}
}

16
src/UI/Components/Modal/ModalStyle/OptionModal.less
Unescape View File

@ -110,4 +110,18 @@
}
}
}
}
}
#optionModal .hingeType {
label {
display: flex;
&>span:first-child {
width: 5rem;
}
input{
width: 4rem;
}
}
}

66
src/UI/Components/Modal/OptionModal/DrawConfigPanel.tsx
Unescape View File

@ -1,4 +1,4 @@
import { Card, Checkbox, Classes, H5, Label } from '@blueprintjs/core';
import { Card, Checkbox, Classes, H5, Label, Tooltip } from '@blueprintjs/core';
import { observable } from 'mobx';
import { observer } from 'mobx-react';
import * as React from 'react';
@ -6,6 +6,7 @@ import { UpdateCompositeEntityBoard } from '../../../../Add-on/ShowLines';
import { app } from '../../../../ApplicationServices/Application';
import { CheckObjectType } from '../../../../Common/CheckoutVaildValue';
import { ColorMaterial } from '../../../../Common/ColorPalette';
import { safeEval } from '../../../../Common/eval';
import { Board } from '../../../../DatabaseServices/Entity/Board';
import { CompositeEntity } from '../../../../DatabaseServices/Entity/CompositeEntity';
import { IMaxSizeProps, userConfig } from '../../../../Editor/UserConfig';
@ -25,6 +26,9 @@ export class DrawConfigPanel extends React.Component<IConfigProps, {}> {
cabinetSpacing: number = userConfig.cabinetSpacing;
private testModeSpacing: number = userConfig.testModeSpacing;
private printResolution = userConfig.printOption.printResolution;
private noLid = userConfig.hingeLidRule.noLid;
private allLid = userConfig.hingeLidRule.allLid;
_oldShowLine: boolean;
_oldShowOpenDirLine: boolean;
_toggleDrillingReactor = () =>
@ -60,7 +64,7 @@ export class DrawConfigPanel extends React.Component<IConfigProps, {}> {
}
public render()
{
const { kjlConfig, printOption } = userConfig;
const { kjlConfig, printOption, hingeLidRule } = userConfig;
return (
<Card>
<div className="flex drawconfig-1">
@ -177,6 +181,64 @@ export class DrawConfigPanel extends React.Component<IConfigProps, {}> {
}
</div>
<H5>铰链类型配置</H5>
<div className='hingeType' style={{ display: "flex", flexDirection: "column" }}>
<Tooltip content={"门板盖住侧板距离小于等于该数值时为无盖铰链，支持‘BH’表达式(BH/2)"} position='top'>
<Label className={Classes.INLINE}>
<span>无盖铰链</span>
<span style={{ width: "0.5rem" }}>≤</span>
<ToasterInput
type={CheckObjectType.CONF}
option={hingeLidRule}
optKey={"noLid"}
onChange={(e) => { hingeLidRule.noLid = e.target.value; }}
onBlur={(e, hasErr) =>
{
if (hasErr)
hingeLidRule.noLid = this.noLid;
else
{
let noLidValue = safeEval(e.target.value, { BH: 18 });
let allLidValue = safeEval(hingeLidRule.allLid, { BH: 18 });
if (noLidValue < allLidValue)
this.noLid = hingeLidRule.noLid;
else
hingeLidRule.noLid = this.noLid;
}
}}
/>
</Label>
</Tooltip>
<Tooltip content={"门板盖住侧板距离大于等于该数值时为全盖铰链，支持‘BH’表达式(BH/2)"} position='top'>
<Label className={Classes.INLINE}>
<span>全盖铰链</span>
<span style={{ width: "0.5rem" }}>≥</span>
<ToasterInput
type={CheckObjectType.CONF}
option={hingeLidRule}
optKey={"allLid"}
onChange={(e) => { hingeLidRule.allLid = e.target.value; }}
onBlur={(e, hasErr) =>
{
if (hasErr)
hingeLidRule.allLid = this.allLid;
else
{
let noLidValue = safeEval(hingeLidRule.noLid, { BH: 18 });
let allLidValue = safeEval(e.target.value, { BH: 18 });
if (noLidValue < allLidValue)
this.allLid = hingeLidRule.allLid;
else
hingeLidRule.allLid = this.allLid;
}
}}
/>
</Label>
</Tooltip>
</div>
<H5>柜子移动到0点(PM0)配置</H5>
<Label className={Classes.INLINE} >
<span style={{ width: "4rem" }}>柜子间距</span>

7
src/UI/Components/Template/TemplateComponent.tsx
Unescape View File

@ -754,10 +754,13 @@ export class TemplateManage extends React.Component<ITemplateManage, {}> {
continue;
}
let allEntitys: Entity[] = this.getSpaceAllEntitys(door);
this.TemplateDrawHingeTool = new TemplateDrawHingeTool();
let [isLROpen, isWarn] = await this.TemplateDrawHingeTool.addHingeToDoor(door, template);
let [isLROpen, isWarn] = await this.TemplateDrawHingeTool.addHingeToDoor(door, template, allEntitys);
if (isWarn) isWarnHingeRules = isWarn;
let allEntitys: Entity[] = this.getSpaceAllEntitys(door);
//获取包含铰链的空间内实体
allEntitys = this.getSpaceAllEntitys(door);
let needReUpdate = this.TemplateDrawHingeTool.RelativeMetalsToBoard(allEntitys, isLROpen, door);
if (needReUpdate)
await tempSpace.Root.UpdateTemplateTree();

192
src/UI/Components/Template/TemplateDrawHingeTool.ts
Unescape View File

@ -1,10 +1,12 @@
import { Box3, Vector3 } from "three";
import { IsBoxAndEntitysIntersect, RecordHingeTrSizeX, SetHingeType, SetNoPareTypeHigneName } from "../../../Add-on/DrawBoard/DrawDoorDrawer/DrawDoorTool";
import { Box3, Matrix4, Vector3 } from "three";
import { HingeType, IsBoxAndEntitysIntersect, RecordHingeTrSizeX } from "../../../Add-on/DrawBoard/DrawDoorDrawer/DrawDoorTool";
import { IsDoor, IsHandle, IsHinge } from "../../../Add-on/HideSelect/HideSelectUtils";
import { app } from "../../../ApplicationServices/Application";
import { EBoardKeyList } from "../../../Common/BoardKeyList";
import { Log } from "../../../Common/Log";
import { DuplicateRecordCloning } from "../../../Common/Status";
import { Intent } from "../../../Common/Toaster";
import { safeEval } from "../../../Common/eval";
import { Board } from "../../../DatabaseServices/Entity/Board";
import { BoardOpenDir, BoardType } from "../../../DatabaseServices/Entity/BoardInterface";
import { Entity } from "../../../DatabaseServices/Entity/Entity";
@ -13,6 +15,7 @@ import { HardwareCompositeEntity } from "../../../DatabaseServices/Hardware/Hard
import { ObjectId } from "../../../DatabaseServices/ObjectId";
import { TemplateParam } from "../../../DatabaseServices/Template/Param/TemplateParam";
import { TemplateRecord } from "../../../DatabaseServices/Template/TemplateRecord";
import { userConfig } from "../../../Editor/UserConfig";
import { Box3Ext } from "../../../Geometry/Box";
import { equaln, isParallelTo } from "../../../Geometry/GeUtils";
import { IHingeRule } from "../../Store/DoorDrawerStore/DoorStore";
@ -20,12 +23,13 @@ import { HingeStore } from "../../Store/DoorDrawerStore/HingeStore";
import { AppToaster } from "../Toaster";
const MOVE_COUNT = 9;//铰链避让尝试次数 超过后不在避让
const FUZZ = 1e-3;
export class TemplateDrawHingeTool
{
private hingeSet: Set<ObjectId> = new Set();
async addHingeToDoor(door: Board | HardwareCompositeEntity, hingeTemp: TemplateRecord): Promise<[boolean, boolean]>
async addHingeToDoor(door: Board | HardwareCompositeEntity, hingeTemp: TemplateRecord, allSpaceEnts: Entity[]): Promise<[boolean, boolean]>
{
let openDir = BoardOpenDir.None;
let height: number;
@ -69,7 +73,7 @@ export class TemplateDrawHingeTool
width = size.x;
}
if (openDir === BoardOpenDir.None) [false, false];
if (openDir === BoardOpenDir.None) return [false, false];
let handleSpace = new TemplateRecord().InitBaseParams();
handleSpace.Name = "铰链空间";
@ -101,6 +105,7 @@ export class TemplateDrawHingeTool
let hingeMap = new Set<number>;
let isWarn = false;
//判断铰链存在碰撞
const ParseRules = (i: number, count: number, dist: number, rule: IHingeRule) =>
{
@ -141,6 +146,7 @@ export class TemplateDrawHingeTool
const DrawHinge = (dist?: number, rule?: IHingeRule) =>
{
let hingeType = this.GetHingeType(door, openDir, allSpaceEnts, isLROpen);
for (let i = 0; i < count; i++)
{
if (hingestore.m_Option.useRule && !ParseRules(i, count, dist, rule)) continue;
@ -173,11 +179,13 @@ export class TemplateDrawHingeTool
for (let objId of temp.Objects)
{
if (objId.Object instanceof HardwareCompositeEntity)//|| objId.Object instanceof HardwareTopline
let hinge = objId.Object;
if (hinge instanceof HardwareCompositeEntity)//|| objId.Object instanceof HardwareTopline
{
objId.Object.HardwareOption[EBoardKeyList.RoomName] = rName;
objId.Object.HardwareOption[EBoardKeyList.BrMat] = bName;
objId.Object.HardwareOption[EBoardKeyList.CabinetName] = cName;
hinge.HardwareOption[EBoardKeyList.RoomName] = rName;
hinge.HardwareOption[EBoardKeyList.BrMat] = bName;
hinge.HardwareOption[EBoardKeyList.CabinetName] = cName;
hinge.HardwareOption.name = hingeType;
this.hingeSet.add(objId);
}
}
@ -303,6 +311,166 @@ export class TemplateDrawHingeTool
return [isLROpen, isWarn];
};
private GetHingeType(door: Entity, openDir: BoardOpenDir, allSpaceEnts: Entity[], isLROpen: boolean): HingeType
{
const Positioning = (door.Template.Object as TemplateRecord).Positioning;
if (!Positioning)
{
Log("存在无效门板!");
return;
}
const DoorSpaceBox = new Box3(new Vector3, Positioning.SpaceSize);
const DoorBox = DoorSpaceBox.clone().applyMatrix4(Positioning.SpaceCS);
let isParallelToXYEnts = allSpaceEnts.filter(ent =>
ent instanceof Board &&
isParallelTo(ent.Normal, new Vector3().setFromMatrixColumn(Positioning.SpaceCS, isLROpen ? 0 : 2)) &&
ent.BoundingBox.intersectsBox(DoorBox, 10)
) as Board[];
let ocsInv = new Matrix4().getInverse(Positioning.SpaceCS);
const hingeLidRule = userConfig.hingeLidRule;
if (openDir === BoardOpenDir.Left)
{
let minX = DoorSpaceBox.min.x;
for (let ent of isParallelToXYEnts)
{
let entBox = ent.GetBoundingBoxInMtx(ocsInv);
//防止关联无关侧板
if (DoorSpaceBox.min.z - entBox.max.z > -100 || entBox.min.z - DoorSpaceBox.max.z > -100) continue;
//盖过立板长度
let passDoorExtend = entBox.min.x - minX;
//无盖距离值
let noLid = safeEval(hingeLidRule.noLid, { BH: ent.Thickness });
//先判断半盖
if (minX - entBox.min.x > FUZZ && entBox.max.x - minX - noLid > FUZZ)
{
let doorExtend = entBox.max.x - minX;
//全盖距离值
let allLid = safeEval(hingeLidRule.allLid, { BH: ent.Thickness });
if (doorExtend - allLid < -FUZZ)
return "半盖铰链";
else
return "全盖铰链";
}
else if (passDoorExtend >= 0 && passDoorExtend < 30)
{
//盖过立板小于30的 认定为左侧板
return "全盖铰链";
}
}
return "无盖铰链";
}
else if (openDir === BoardOpenDir.Right)
{
let maxX = DoorSpaceBox.max.x;
for (let ent of isParallelToXYEnts)
{
let entBox = ent.GetBoundingBoxInMtx(ocsInv);
//防止关联无关侧板
if (DoorSpaceBox.min.z - entBox.max.z > -100 || entBox.min.z - DoorSpaceBox.max.z > -100) continue;
//盖过立板长度
let passDoorExtend = maxX - entBox.max.x;
//无盖距离值
let noLid = safeEval(hingeLidRule.noLid, { BH: ent.Thickness });
//先判断半盖
if (maxX - entBox.min.x - noLid > FUZZ && entBox.max.x - maxX > FUZZ)
{
let doorExtend = maxX - entBox.min.x;
//全盖距离值
let allLid = safeEval(hingeLidRule.allLid, { BH: ent.Thickness });
if (doorExtend - allLid < -FUZZ)
return "半盖铰链";
else
return "全盖铰链";
}
else if (passDoorExtend >= 0 && passDoorExtend < 30)
{
//盖过立板小于30的 认定为右侧板
return "全盖铰链";
}
}
return "无盖铰链";
}
else if (openDir === BoardOpenDir.Up)
{
let maxZ = DoorSpaceBox.max.z;
for (let ent of isParallelToXYEnts)
{
let entBox = ent.GetBoundingBoxInMtx(ocsInv);
//防止关联无关层板
if (DoorSpaceBox.min.x - entBox.max.x > -100 || entBox.min.x - DoorSpaceBox.max.x > -100) continue;
//盖过立板长度
let passDoorExtend = maxZ - entBox.max.z;
//无盖距离值
let noLid = safeEval(hingeLidRule.noLid, { BH: ent.Thickness });
//先判断半盖
if (maxZ - entBox.min.z - noLid > FUZZ && entBox.max.z - maxZ > FUZZ)
{
let doorExtend = maxZ - entBox.min.z;
//全盖距离值
let allLid = safeEval(hingeLidRule.allLid, { BH: ent.Thickness });
if (doorExtend - allLid < -FUZZ)
return "半盖铰链";
else
return "全盖铰链";
}
else if (passDoorExtend >= 0 && passDoorExtend < 30)
{
//盖过立板小于30的 认定为上层板
return "全盖铰链";
}
}
return "无盖铰链";
}
else if (openDir === BoardOpenDir.Down)
{
let minZ = DoorSpaceBox.min.z;
for (let ent of isParallelToXYEnts)
{
let entBox = ent.GetBoundingBoxInMtx(ocsInv);
//防止关联无关层板
if (DoorSpaceBox.min.x - entBox.max.x > -100 || entBox.min.x - DoorSpaceBox.max.x > -100) continue;
//盖过立板长度
let passDoorExtend = entBox.min.z - minZ;
//无盖距离值
let noLid = safeEval(hingeLidRule.noLid, { BH: ent.Thickness });
//先判断半盖
if (minZ - entBox.min.z > -FUZZ && entBox.max.z - minZ - noLid > FUZZ)
{
let doorExtend = entBox.max.z - minZ;
//全盖距离值
let allLid = safeEval(hingeLidRule.allLid, { BH: ent.Thickness });
if (doorExtend - allLid < -FUZZ)
return "半盖铰链";
else
return "全盖铰链";
}
else if (passDoorExtend >= 0 && passDoorExtend < 30)
{
//盖过立板小于30的 认定为下层板
return "全盖铰链";
}
}
return "无盖铰链";
}
};
//设置五金(拉手 铰链)和板的关联切割
RelativeMetalsToBoard(allEntitys: Entity[], isLROpen: boolean, door: Board | HardwareCompositeEntity)
{
@ -395,6 +563,8 @@ export class TemplateDrawHingeTool
outlinesCache.set(br, grooveOutlines);
}
const isParallelToX = isParallelTo(xNormal, br.Normal);
//门板/背板 不增加误差,防止误关联
if (IsBoxAndEntitysIntersect([otherEnt], [ironware], ZNormal))
{
@ -405,13 +575,13 @@ export class TemplateDrawHingeTool
//铰链避让
if (this.hingeSet.has(ironware.Id))
{
if (isParallelTo(xNormal, br.Normal))
if (isParallelToX)
{
if (!parseTypedHinges.has(ironware.Id))
{
parseTypedHinges.add(ironware.Id);
//设置铰链类型
SetHingeType(br, ironware);
// SetHingeType(br, ironware);
}
}
else if (isParallelTo(ironware.Normal, br.Normal) || !isDoor)
@ -471,7 +641,7 @@ export class TemplateDrawHingeTool
intent: Intent.DANGER,
});
SetNoPareTypeHigneName(parseTypedHinges, this.hingeSet);
// SetNoPareTypeHigneName(parseTypedHinges, this.hingeSet);
this.hingeSet.clear();
return needUpdate;
}

Write Preview
Loading…
Cancel
Save