brep-io-kernel 1.0.0-ci.9

package/src/features/sheetMetal/sheetMetalPipeline.js

@@ -0,0 +1,169 @@
+import { BREP } from "../../BREP/BREP.js";
+import { resolveProfileFace } from "./profileUtils.js";
+import { buildContourFlangeSolidFromParams } from "./SheetMetalContourFlangeFeature.js";
+import { buildSheetMetalCutoutSolids } from "./SheetMetalCutoutFeature.js";
+import { buildSheetMetalFlangeSolids } from "./SheetMetalFlangeFeature.js";
+import { SHEET_METAL_NODE_TYPES } from "./sheetMetalTree.js";
+import { resolvePlacementMode, toExtrudeDistances, tagTabFaceTypes } from "./sheetMetalTabUtils.js";
+import { buildFaceFromProfileGroups } from "./sheetMetalProfileUtils.js";
+
+export async function buildSheetMetalSolidFromTree(tree, context = {}) {
+  if (!tree || !Array.isArray(tree.nodes) || tree.nodes.length === 0) {
+    throw new Error("Sheet metal tree has no nodes to build.");
+  }
+
+  let current = null;
+  for (const node of tree.nodes) {
+    if (!node || !node.type) continue;
+    switch (node.type) {
+      case SHEET_METAL_NODE_TYPES.TAB:
+        current = buildTabSolid(node, context);
+        break;
+      case SHEET_METAL_NODE_TYPES.CONTOUR_FLANGE:
+        current = buildContourFlangeSolid(node, context);
+        break;
+      case SHEET_METAL_NODE_TYPES.FLANGE:
+        current = await applyFlangeNode(current, node, context);
+        break;
+      case SHEET_METAL_NODE_TYPES.CUTOUT:
+        current = await applyCutoutNode(current, node, context);
+        break;
+      default:
+        throw new Error(`Unsupported sheet metal node type: ${node.type}`);
+    }
+  }
+  if (!current) {
+    throw new Error("Sheet metal tree did not produce a solid.");
+  }
+  return current;
+}
+
+function buildTabSolid(node, context) {
+  const params = node.params || {};
+  let faceObj = resolveProfileFace(params.profileRef, context.partHistory);
+  if (!faceObj && params.profileGroups) {
+    faceObj = buildFaceFromProfileGroups(
+      params.profileGroups,
+      params.profileName || params.profileRef || "PROFILE",
+      params.profileEdges,
+    );
+  }
+  if (!faceObj) {
+    throw new Error("Sheet Metal Tab requires a valid FACE or SKETCH selection.");
+  }
+
+  const placement = resolvePlacementMode(params.placementMode, params.signedThickness);
+  const extrudeDistances = toExtrudeDistances(Math.abs(params.thickness), placement);
+
+  const sweep = new BREP.Sweep({
+    face: faceObj,
+    distance: extrudeDistances.distance,
+    distanceBack: extrudeDistances.distanceBack,
+    mode: "translate",
+    name: params.featureID || null,
+    omitBaseCap: false,
+  });
+  sweep.visualize();
+  tagTabFaceTypes(sweep);
+  return sweep;
+}
+
+function buildContourFlangeSolid(node, context) {
+  const params = node.params || {};
+  const buildParams = {
+    ...params,
+    path: params.pathRefs || params.path || params.profile,
+  };
+  const result = buildContourFlangeSolidFromParams(buildParams, context.partHistory);
+  return result.solid;
+}
+
+async function applyFlangeNode(current, node, context) {
+  if (!current) {
+    throw new Error("Sheet metal flange requires an existing solid.");
+  }
+  const params = node.params || {};
+  const faces = resolveFaceRefsOnSolid(current, params.faceRefs);
+  if (!faces.length) {
+    throw new Error("Sheet metal flange could not resolve any target faces on the current solid.");
+  }
+  const featureDefaults = {
+    longName: "Sheet Metal Flange",
+    logTag: "SheetMetalFlange",
+    baseType: params.baseType || "FLANGE",
+    defaultAngle: Number.isFinite(params.defaultAngle) ? params.defaultAngle : 90,
+    angleOverride: Number.isFinite(params.angleOverride) ? params.angleOverride : null,
+    defaultBendRadius: Number.isFinite(params.defaultBendRadius) ? params.defaultBendRadius : null,
+  };
+  const result = await buildSheetMetalFlangeSolids({
+    params,
+    partHistory: context.partHistory,
+    faces,
+    featureClass: featureDefaults,
+    applyMetadata: false,
+  });
+  return pickPrimarySolid(result?.added, current);
+}
+
+async function applyCutoutNode(current, node, context) {
+  if (!current) {
+    throw new Error("Sheet metal cutout requires an existing solid.");
+  }
+  ensureSolidVisualized(current);
+  const params = node.params || {};
+  const buildParams = {
+    ...params,
+    sheet: params.sheetRef || params.sheet,
+    profile: params.profileRef || params.profile,
+  };
+  const result = await buildSheetMetalCutoutSolids({
+    params: buildParams,
+    partHistory: context.partHistory,
+    sheetSolid: current,
+    applyMetadata: false,
+  });
+  return pickPrimarySolid(result?.added, current);
+}
+
+function ensureSolidVisualized(solid) {
+  try {
+    if (solid && typeof solid.visualize === "function") solid.visualize();
+  } catch { /* ignore */ }
+}
+
+function resolveFaceRefsOnSolid(solid, refs) {
+  const list = Array.isArray(refs) ? refs : (refs ? [refs] : []);
+  if (!solid || !list.length) return [];
+  ensureSolidVisualized(solid);
+  const out = [];
+  for (const ref of list) {
+    if (!ref) continue;
+    if (ref?.type === "FACE") {
+      out.push(ref);
+      continue;
+    }
+    const name = typeof ref === "string" ? ref : (ref?.name || ref?.id || null);
+    if (!name) continue;
+    let face = null;
+    if (typeof solid.getObjectByName === "function") {
+      face = solid.getObjectByName(name);
+    }
+    if (!face || face.type !== "FACE") {
+      const children = Array.isArray(solid.children) ? solid.children : [];
+      face = children.find((child) => child?.type === "FACE" && child?.name === name) || null;
+    }
+    if (face && face.type === "FACE") out.push(face);
+  }
+  return out;
+}
+
+function pickPrimarySolid(added, fallback) {
+  if (Array.isArray(added) && added.length) {
+    if (fallback?.name) {
+      const match = added.find((solid) => solid?.name === fallback.name);
+      if (match) return match;
+    }
+    return added[0];
+  }
+  return fallback;
+}

package/src/features/sheetMetal/sheetMetalProfileUtils.js

@@ -0,0 +1,216 @@
+import { BREP } from "../../BREP/BREP.js";
+
+export function cloneProfileGroups(faceObj) {
+  const groups = Array.isArray(faceObj?.userData?.profileGroups)
+    ? faceObj.userData.profileGroups
+    : null;
+  if (!groups || groups.length === 0) return null;
+
+  const clonePoint = (pt, dims) => {
+    if (!Array.isArray(pt)) return null;
+    const out = [];
+    for (let i = 0; i < dims; i++) {
+      const val = Number(pt[i]);
+      if (!Number.isFinite(val)) return null;
+      out.push(val);
+    }
+    return out;
+  };
+
+  const clonePointList = (list, dims) => {
+    if (!Array.isArray(list)) return [];
+    const out = [];
+    for (const pt of list) {
+      const next = clonePoint(pt, dims);
+      if (next) out.push(next);
+    }
+    return out;
+  };
+
+  const cloneNestedList = (list, dims) => {
+    if (!Array.isArray(list)) return [];
+    const out = [];
+    for (const entry of list) {
+      const next = clonePointList(entry, dims);
+      if (next.length) out.push(next);
+    }
+    return out;
+  };
+
+  const out = [];
+  for (const group of groups) {
+    const contour2D = clonePointList(group?.contour2D, 2);
+    const holes2D = cloneNestedList(group?.holes2D, 2);
+    const contourW = clonePointList(group?.contourW, 3);
+    const holesW = cloneNestedList(group?.holesW, 3);
+    if (contour2D.length < 3 || contourW.length !== contour2D.length) continue;
+    out.push({ contour2D, holes2D, contourW, holesW });
+  }
+
+  return out.length ? out : null;
+}
+
+export function collectProfileEdges(faceObj) {
+  const edges = Array.isArray(faceObj?.edges) ? faceObj.edges : null;
+  if (!edges || edges.length === 0) return null;
+  const out = [];
+  const THREE = BREP.THREE;
+  for (const edge of edges) {
+    const name = typeof edge?.name === "string" ? edge.name : null;
+    const polyline = Array.isArray(edge?.userData?.polylineLocal)
+      ? edge.userData.polylineLocal
+      : null;
+    if (!name || !polyline || polyline.length < 2) continue;
+    const pts = [];
+    const isWorld = edge?.userData?.polylineWorld === true;
+    for (const pt of polyline) {
+      if (!Array.isArray(pt) || pt.length < 3) continue;
+      let x = Number(pt[0]);
+      let y = Number(pt[1]);
+      let z = Number(pt[2]);
+      if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z)) continue;
+      if (!isWorld && edge?.matrixWorld) {
+        const v = new THREE.Vector3(x, y, z).applyMatrix4(edge.matrixWorld);
+        x = v.x;
+        y = v.y;
+        z = v.z;
+      }
+      pts.push([x, y, z]);
+    }
+    if (pts.length < 2) continue;
+    out.push({
+      name,
+      polyline: pts,
+      polylineWorld: true,
+    });
+  }
+  return out.length ? out : null;
+}
+
+export function buildFaceFromProfileGroups(profileGroups, profileName, profileEdges) {
+  const groups = normalizeProfileGroups(profileGroups);
+  if (!groups.length) return null;
+  const THREE = BREP.THREE;
+  const triPositions = [];
+  const boundaryLoopsWorld = [];
+  const sanitizedGroups = [];
+
+  for (const group of groups) {
+    const contour2D = group.contour2D;
+    const holes2D = group.holes2D;
+    const contourW = group.contourW;
+    const holesW = group.holesW;
+    if (contour2D.length < 3 || contourW.length !== contour2D.length) continue;
+
+    const contourV2 = contour2D.map((p) => new THREE.Vector2(p[0], p[1]));
+    const holesV2 = holes2D.map((hole) => hole.map((p) => new THREE.Vector2(p[0], p[1])));
+    const tris = THREE.ShapeUtils.triangulateShape(contourV2, holesV2);
+    const allW = contourW.concat(...holesW);
+    for (const tri of tris) {
+      const a = allW[tri[0]];
+      const b = allW[tri[1]];
+      const c = allW[tri[2]];
+      if (!a || !b || !c) continue;
+      triPositions.push(a[0], a[1], a[2], b[0], b[1], b[2], c[0], c[1], c[2]);
+    }
+
+    boundaryLoopsWorld.push({ pts: contourW.map((pt) => pt.slice()), isHole: false });
+    for (const hole of holesW) {
+      boundaryLoopsWorld.push({ pts: hole.map((pt) => pt.slice()), isHole: true });
+    }
+    sanitizedGroups.push({
+      contour2D: contour2D.map((pt) => pt.slice()),
+      holes2D: holes2D.map((hole) => hole.map((pt) => pt.slice())),
+      contourW: contourW.map((pt) => pt.slice()),
+      holesW: holesW.map((hole) => hole.map((pt) => pt.slice())),
+    });
+  }
+
+  if (!triPositions.length) return null;
+
+  const geom = new THREE.BufferGeometry();
+  geom.setAttribute("position", new THREE.Float32BufferAttribute(triPositions, 3));
+  geom.computeVertexNormals();
+  geom.computeBoundingSphere();
+
+  const face = new BREP.Face(geom);
+  face.name = (typeof profileName === "string" && profileName.trim()) ? profileName.trim() : "PROFILE";
+  face.userData = face.userData || {};
+  face.userData.faceName = face.name;
+  face.userData.boundaryLoopsWorld = boundaryLoopsWorld;
+  face.userData.profileGroups = sanitizedGroups;
+  const edges = buildProfileEdges(profileEdges);
+  if (edges.length) face.edges = edges;
+  return face;
+}
+
+function normalizeProfileGroups(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  const toPoint = (pt, dims) => {
+    if (!Array.isArray(pt) || pt.length < dims) return null;
+    const vals = [];
+    for (let i = 0; i < dims; i++) {
+      const n = Number(pt[i]);
+      if (!Number.isFinite(n)) return null;
+      vals.push(n);
+    }
+    return vals;
+  };
+  const toPointList = (list, dims) => {
+    if (!Array.isArray(list)) return [];
+    const arr = [];
+    for (const pt of list) {
+      const next = toPoint(pt, dims);
+      if (next) arr.push(next);
+    }
+    return arr;
+  };
+  const toNestedList = (list, dims) => {
+    if (!Array.isArray(list)) return [];
+    const arr = [];
+    for (const entry of list) {
+      const next = toPointList(entry, dims);
+      if (next.length) arr.push(next);
+    }
+    return arr;
+  };
+  for (const group of raw) {
+    if (!group) continue;
+    const contour2D = toPointList(group.contour2D, 2);
+    const holes2D = toNestedList(group.holes2D, 2);
+    const contourW = toPointList(group.contourW, 3);
+    const holesW = toNestedList(group.holesW, 3);
+    if (contour2D.length < 3 || contourW.length !== contour2D.length) continue;
+    out.push({ contour2D, holes2D, contourW, holesW });
+  }
+  return out;
+}
+
+function buildProfileEdges(edgeDefs) {
+  if (!Array.isArray(edgeDefs)) return [];
+  const edges = [];
+  for (const def of edgeDefs) {
+    const name = typeof def?.name === "string" ? def.name : null;
+    const polyline = Array.isArray(def?.polyline) ? def.polyline : null;
+    if (!name || !polyline || polyline.length < 2) continue;
+    const pts = [];
+    for (const pt of polyline) {
+      if (!Array.isArray(pt) || pt.length < 3) continue;
+      const x = Number(pt[0]);
+      const y = Number(pt[1]);
+      const z = Number(pt[2]);
+      if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z)) continue;
+      pts.push([x, y, z]);
+    }
+    if (pts.length < 2) continue;
+    edges.push({
+      name,
+      userData: {
+        polylineLocal: pts,
+        polylineWorld: true,
+      },
+    });
+  }
+  return edges;
+}

package/src/features/sheetMetal/sheetMetalTabUtils.js

@@ -0,0 +1,29 @@
+import { setSheetMetalFaceTypeMetadata, SHEET_METAL_FACE_TYPES } from "./sheetMetalFaceTypes.js";
+
+export function resolvePlacementMode(requested, signedThickness) {
+  const normalized = String(requested || "").toLowerCase();
+  if (normalized === "forward" || normalized === "reverse" || normalized === "midplane") {
+    return normalized;
+  }
+  return signedThickness < 0 ? "reverse" : "forward";
+}
+
+export function toExtrudeDistances(thickness, placementMode) {
+  if (placementMode === "reverse") return { distance: 0, distanceBack: thickness };
+  if (placementMode === "midplane") {
+    const half = thickness / 2;
+    return { distance: half, distanceBack: half };
+  }
+  return { distance: thickness, distanceBack: 0 };
+}
+
+export function tagTabFaceTypes(sweep) {
+  if (!sweep || typeof sweep.getFaceNames !== "function") return;
+  const faceNames = sweep.getFaceNames();
+  const startFaces = faceNames.filter((name) => name.endsWith("_START"));
+  const endFaces = faceNames.filter((name) => name.endsWith("_END"));
+  const thicknessFaces = faceNames.filter((name) => name.endsWith("_SW"));
+  setSheetMetalFaceTypeMetadata(sweep, startFaces, SHEET_METAL_FACE_TYPES.A);
+  setSheetMetalFaceTypeMetadata(sweep, endFaces, SHEET_METAL_FACE_TYPES.B);
+  setSheetMetalFaceTypeMetadata(sweep, thicknessFaces, SHEET_METAL_FACE_TYPES.THICKNESS);
+}

package/src/features/sheetMetal/sheetMetalTree.js

@@ -0,0 +1,210 @@
+import { normalizeSelectionList, normalizeSelectionName } from "../selectionUtils.js";
+
+export const SHEET_METAL_NODE_TYPES = {
+  TAB: "TAB",
+  CONTOUR_FLANGE: "CONTOUR_FLANGE",
+  FLANGE: "FLANGE",
+  CUTOUT: "CUTOUT",
+};
+
+export function createSheetMetalTree(nodes = []) {
+  return {
+    version: 1,
+    nodes: Array.isArray(nodes) ? nodes.slice() : [],
+  };
+}
+
+export function cloneSheetMetalTree(tree) {
+  if (!tree || typeof tree !== "object") return createSheetMetalTree();
+  const cloneValue = (value) => {
+    if (Array.isArray(value)) return value.map(cloneValue);
+    if (value && typeof value === "object") {
+      const out = {};
+      for (const [key, val] of Object.entries(value)) {
+        out[key] = cloneValue(val);
+      }
+      return out;
+    }
+    return value;
+  };
+  const nodes = Array.isArray(tree.nodes)
+    ? tree.nodes.map((node) => ({
+        ...node,
+        params: node?.params ? cloneValue(node.params) : null,
+      }))
+    : [];
+  return {
+    version: tree.version ?? 1,
+    nodes,
+  };
+}
+
+export function appendSheetMetalNode(tree, node) {
+  const next = cloneSheetMetalTree(tree);
+  next.nodes.push(node);
+  return next;
+}
+
+export function createSheetMetalTabNode({
+  featureID,
+  profileRef,
+  profileName,
+  profileGroups,
+  profileEdges,
+  thickness,
+  placementMode,
+  bendRadius,
+  neutralFactor,
+  signedThickness,
+  consumeProfileSketch,
+}) {
+  const resolvedProfile = normalizeSelectionName(
+    Array.isArray(profileRef) ? (profileRef[0] || null) : profileRef
+  );
+  const baseName = profileName || "TAB";
+  const tag = featureID ? `${featureID}` : `SM.TAB:${baseName}`;
+  return {
+    type: SHEET_METAL_NODE_TYPES.TAB,
+    id: tag,
+    params: {
+      featureID: featureID || null,
+      profileRef: resolvedProfile || null,
+      profileName: baseName,
+      profileGroups: Array.isArray(profileGroups) ? profileGroups : null,
+      profileEdges: Array.isArray(profileEdges) ? profileEdges : null,
+      thickness,
+      placementMode,
+      bendRadius,
+      neutralFactor,
+      signedThickness,
+      consumeProfileSketch,
+    },
+  };
+}
+
+export function createSheetMetalContourFlangeNode({
+  featureID,
+  pathRefs,
+  distance,
+  thickness,
+  signedThickness,
+  signedDistance,
+  reverseSheetSide,
+  sheetSide,
+  bendRadius,
+  neutralFactor,
+  consumePathSketch,
+}) {
+  const refs = normalizeSelectionList(
+    Array.isArray(pathRefs) ? pathRefs : (pathRefs ? [pathRefs] : [])
+  );
+  const tag = featureID ? `${featureID}` : "SM.CF";
+  return {
+    type: SHEET_METAL_NODE_TYPES.CONTOUR_FLANGE,
+    id: tag,
+    params: {
+      featureID: featureID || null,
+      pathRefs: refs,
+      distance,
+      thickness,
+      signedThickness,
+      signedDistance,
+      reverseSheetSide,
+      sheetSide,
+      bendRadius,
+      neutralFactor,
+      consumePathSketch,
+    },
+  };
+}
+
+export function createSheetMetalFlangeNode({
+  featureID,
+  faceRefs,
+  useOppositeCenterline,
+  flangeLength,
+  flangeLengthReference,
+  angle,
+  inset,
+  reliefWidth,
+  bendRadius,
+  offset,
+  debugSkipUnion,
+  baseType,
+  defaultAngle,
+  angleOverride,
+  defaultBendRadius,
+}) {
+  const refs = normalizeSelectionList(
+    Array.isArray(faceRefs) ? faceRefs : (faceRefs ? [faceRefs] : [])
+  );
+  const tag = featureID ? `${featureID}` : "SM.F";
+  return {
+    type: SHEET_METAL_NODE_TYPES.FLANGE,
+    id: tag,
+    params: {
+      featureID: featureID || null,
+      faceRefs: refs,
+      useOppositeCenterline,
+      flangeLength,
+      flangeLengthReference,
+      angle,
+      inset,
+      reliefWidth,
+      bendRadius,
+      offset,
+      debugSkipUnion,
+      baseType: baseType || null,
+      defaultAngle,
+      angleOverride,
+      defaultBendRadius,
+    },
+  };
+}
+
+export function createSheetMetalCutoutNode({
+  featureID,
+  sheetRef,
+  profileRef,
+  profileFaceName,
+  profileGroups,
+  profileEdges,
+  consumeProfileSketch,
+  forwardDistance,
+  backDistance,
+  keepTool,
+  debugCutter,
+}) {
+  const sheetName = normalizeSelectionName(
+    Array.isArray(sheetRef) ? (sheetRef[0] || null) : sheetRef
+  );
+  const profileRefName = normalizeSelectionName(
+    Array.isArray(profileRef) ? (profileRef[0] || null) : profileRef
+  );
+  const tag = featureID ? `${featureID}` : "SM.CUTOUT";
+  return {
+    type: SHEET_METAL_NODE_TYPES.CUTOUT,
+    id: tag,
+    params: {
+      featureID: featureID || null,
+      sheetRef: sheetName || null,
+      profileRef: profileRefName || null,
+      profileName: profileFaceName || profileRefName || null,
+      profileGroups: Array.isArray(profileGroups) ? profileGroups : null,
+      profileEdges: Array.isArray(profileEdges) ? profileEdges : null,
+      consumeProfileSketch,
+      forwardDistance,
+      backDistance,
+      keepTool,
+      debugCutter,
+    },
+  };
+}
+
+export function getSheetMetalBaseNode(tree) {
+  if (!tree || !Array.isArray(tree.nodes)) return null;
+  return tree.nodes.find((node) => (
+    node?.type === SHEET_METAL_NODE_TYPES.TAB
+    || node?.type === SHEET_METAL_NODE_TYPES.CONTOUR_FLANGE
+  )) || null;
+}