brep-io-kernel 1.0.0-ci.9

package/src/features/spline/splineUtils.js

@@ -0,0 +1,218 @@
+import { BREP } from "../../BREP/BREP.js";
+const THREE = BREP.THREE;
+
+export const DEFAULT_RESOLUTION = 24;
+
+const ensurePoint = (point, fallbackId, fallbackPosition, index = 0) => {
+  const positionSource = Array.isArray(point?.position)
+    ? point.position
+    : Array.isArray(fallbackPosition)
+      ? fallbackPosition
+      : [0, 0, 0];
+  const position = [
+    Number(positionSource[0]) || 0,
+    Number(positionSource[1]) || 0,
+    Number(positionSource[2]) || 0,
+  ];
+
+  // Ensure forward and backward extension distances
+  const forwardDistance = typeof point?.forwardDistance === "number" 
+    ? Math.max(0, Number(point.forwardDistance)) 
+    : 1.0; // Default forward distance
+
+  const backwardDistance = typeof point?.backwardDistance === "number" 
+    ? Math.max(0, Number(point.backwardDistance)) 
+    : 1.0; // Default backward distance
+
+  const flipDirection = typeof point?.flipDirection === "boolean" 
+    ? point.flipDirection 
+    : false;
+
+  // Store complete transformation matrix (position + rotation)
+  // Default to identity rotation (pointing along X-axis)
+  const rotation = Array.isArray(point?.rotation) && point.rotation.length === 9
+    ? point.rotation.slice() // Copy existing rotation matrix
+    : [1, 0, 0, 0, 1, 0, 0, 0, 1]; // Default identity rotation (X-axis forward)
+
+  return {
+    id: String(point?.id ?? fallbackId ?? `pt-${Math.random().toString(36).slice(2)}`),
+    position,
+    rotation, // 3x3 rotation matrix stored as flat array
+    forwardDistance,
+    backwardDistance,
+    flipDirection,
+  };
+};
+
+export function normalizeSplineData(rawSpline) {
+  let spline = rawSpline;
+  if (!spline || typeof spline !== "object") {
+    spline = null;
+  }
+
+  let points = Array.isArray(spline?.points) ? spline.points : null;
+  if (!points || points.length < 2) {
+    points = [
+      { 
+        id: "p0", 
+        position: [0, 0, 0],
+        rotation: [1, 0, 0, 0, 1, 0, 0, 0, 1], // Identity matrix
+        forwardDistance: 1.0,
+        backwardDistance: 1.0,
+        flipDirection: false
+      },
+      { 
+        id: "p1", 
+        position: [5, 0, 0],
+        rotation: [1, 0, 0, 0, 1, 0, 0, 0, 1], // Identity matrix
+        forwardDistance: 1.0,
+        backwardDistance: 1.0,
+        flipDirection: false
+      },
+    ];
+  }
+
+  const normalizedPoints = points.map((pt, index) =>
+    ensurePoint(pt, `p${index}`, null, index)
+  );
+
+  return {
+    points: normalizedPoints,
+  };
+}
+
+const hermitePoint = (p0, p1, t0, t1, t) => {
+  const t2 = t * t;
+  const t3 = t2 * t;
+  const h00 = 2 * t3 - 3 * t2 + 1;
+  const h10 = t3 - 2 * t2 + t;
+  const h01 = -2 * t3 + 3 * t2;
+  const h11 = t3 - t2;
+
+  const out = new THREE.Vector3();
+  out
+    .addScaledVector(p0, h00)
+    .addScaledVector(t0, h10)
+    .addScaledVector(p1, h01)
+    .addScaledVector(t1, h11);
+  return out;
+};
+
+export function buildHermitePolyline(spline, resolution = DEFAULT_RESOLUTION, bendRadius = 1.0) {
+  const pointsData = Array.isArray(spline?.points) ? spline.points : [];
+  
+  if (pointsData.length < 2) {
+    return { positions: [], polyline: [] };
+  }
+
+  const samplesPerSegment = Math.max(4, Math.floor(resolution));
+  const positions = [];
+  const polyline = [];
+
+  // Clamp bend radius to reasonable range
+  const clampedBendRadius = Math.max(0.1, Math.min(5.0, Number(bendRadius) || 1.0));
+
+  // Helper function to calculate extension point
+  const calculateExtensionPoint = (anchor, pointData, isForward) => {
+    const rotation = pointData.rotation || [1, 0, 0, 0, 1, 0, 0, 0, 1];
+    let direction = new THREE.Vector3(rotation[0], rotation[1], rotation[2]);
+    
+    if (pointData.flipDirection) {
+      direction.multiplyScalar(-1);
+    }
+    
+    const distance = isForward ? pointData.forwardDistance : pointData.backwardDistance;
+    const extensionDir = isForward ? direction : direction.clone().multiplyScalar(-1);
+    
+    return anchor.clone().add(extensionDir.multiplyScalar(distance));
+  };
+
+  // Helper function to add straight line segment with specified number of samples
+  const addStraightSegment = (start, end, samples) => {
+    for (let i = 0; i <= samples; i++) {
+      const t = i / samples;
+      const point = start.clone().lerp(end, t);
+      positions.push(point.x, point.y, point.z);
+      polyline.push([point.x, point.y, point.z]);
+    }
+  };
+
+  // Convert control points to THREE.Vector3
+  const anchors = pointsData.map(
+    (pt) =>
+      new THREE.Vector3(
+        Number(pt.position?.[0]) || 0,
+        Number(pt.position?.[1]) || 0,
+        Number(pt.position?.[2]) || 0,
+      )
+  );
+
+  // Build the complete spline with straight and curved segments
+  for (let i = 0; i < pointsData.length - 1; i++) {
+    const currentAnchor = anchors[i];
+    const nextAnchor = anchors[i + 1];
+    const currentData = pointsData[i];
+    const nextData = pointsData[i + 1];
+
+    // Calculate extension points
+    const currentForwardExt = calculateExtensionPoint(currentAnchor, currentData, true);
+    const nextBackwardExt = calculateExtensionPoint(nextAnchor, nextData, false);
+
+    // Use minimal samples for straight segments and maximum for curves
+    const straightSamples = Math.max(1, Math.floor(samplesPerSegment * 0.15)); // Only 15% for straight parts
+    const curvedSamples = Math.max(6, samplesPerSegment - (2 * straightSamples)); // Much more samples for smoother curves
+
+    // Segment 1: Straight line from current anchor to its forward extension point
+    if (i === 0) {
+      // For the first segment, include the starting point
+      addStraightSegment(currentAnchor, currentForwardExt, straightSamples);
+    } else {
+      // Skip the first point to avoid duplication
+      for (let j = 1; j <= straightSamples; j++) {
+        const t = j / straightSamples;
+        const point = currentAnchor.clone().lerp(currentForwardExt, t);
+        positions.push(point.x, point.y, point.z);
+        polyline.push([point.x, point.y, point.z]);
+      }
+    }
+
+    // Segment 2: Curved hermite interpolation from current forward extension to next backward extension
+    // Create tangent vectors for the curved segment
+    const currentExtDirection = currentForwardExt.clone().sub(currentAnchor).normalize();
+    const nextExtDirection = nextAnchor.clone().sub(nextBackwardExt).normalize();
+    
+    // Calculate tangent scale based on user-controlled bend radius
+    const extDistance = currentForwardExt.distanceTo(nextBackwardExt);
+    const avgExtDistance = (currentData.forwardDistance + nextData.backwardDistance) * 0.5;
+    
+    // Use the bend radius to control curve smoothness
+    // Lower bend radius = tighter curves, higher bend radius = smoother curves
+    const baseScale = Math.max(extDistance * 0.3, avgExtDistance * 0.5); // Much more conservative base
+    const tangentScale = baseScale * clampedBendRadius;
+    
+    const t0 = currentExtDirection.multiplyScalar(tangentScale);
+    const t1 = nextExtDirection.multiplyScalar(tangentScale);
+
+    // Add the curved segment (skip first point to avoid duplication)
+    for (let j = 1; j <= curvedSamples; j++) {
+      const t = j / curvedSamples;
+      const point = hermitePoint(currentForwardExt, nextBackwardExt, t0, t1, t);
+      positions.push(point.x, point.y, point.z);
+      polyline.push([point.x, point.y, point.z]);
+    }
+
+    // Segment 3: Straight line from next backward extension to next anchor
+    for (let j = 1; j <= straightSamples; j++) {
+      const t = j / straightSamples;
+      const point = nextBackwardExt.clone().lerp(nextAnchor, t);
+      positions.push(point.x, point.y, point.z);
+      polyline.push([point.x, point.y, point.z]);
+    }
+  }
+
+  return { positions, polyline };
+}
+
+export function cloneSplineData(spline) {
+  return JSON.parse(JSON.stringify(spline || null));
+}

package/src/features/sweep/SweepFeature.js

@@ -0,0 +1,110 @@
+import { BREP } from "../../BREP/BREP.js";
+import { selectionHasSketch } from "../selectionUtils.js";
+
+const inputParamsSchema = {
+  id: {
+    type: "string",
+    default_value: null,
+    hint: "unique identifier for the sweep feature",
+  },
+  profile: {
+    type: "reference_selection",
+    selectionFilter: ["SKETCH", "FACE"],
+    multiple: false,
+    default_value: null,
+    hint: "Select the profile to sweep",
+  },
+  consumeProfileSketch: {
+    type: "boolean",
+    default_value: true,
+    hint: "Remove the referenced sketch after creating the sweep. Turn off to keep it in the scene.",
+  },
+  path: {
+    type: "reference_selection",
+    selectionFilter: ["EDGE"],
+    multiple: true,
+    default_value: null,
+    hint: "Select one or more edges to define the sweep path (connected edges are chained)",
+  },
+  orientationMode: {
+    type: "options",
+    options: ["translate", "pathAlign"],
+    default_value: "translate",
+    hint: "Sweep orientation mode: 'translate' (fixed) or 'pathAlign' (profile aligns and rotates with path)",
+  },
+  twistAngle: {
+    type: "number",
+    default_value: 0,
+    hint: "Twist angle for the sweep",
+  },
+  boolean: {
+    type: "boolean_operation",
+    default_value: { targets: [], operation: 'NONE' },
+    hint: "Optional boolean operation with selected solids"
+  }
+};
+
+export class SweepFeature {
+  static shortName = "SW";
+  static longName = "Sweep";
+  static inputParamsSchema = inputParamsSchema;
+
+  constructor() {
+    this.inputParams = {};
+    this.persistentData = {};
+  }
+
+  uiFieldsTest(context) {
+    const params = this.inputParams || context?.params || {};
+    const partHistory = context?.history || null;
+    return selectionHasSketch(params.profile, partHistory) ? [] : ["consumeProfileSketch"];
+  }
+
+  async run(partHistory) {
+    // actual code to create the sweep feature.
+    const { profile, path, twistAngle, orientationMode } = this.inputParams;
+
+    // Require a valid path edge; sweep now only follows a path
+    const pathArr = Array.isArray(path) ? path.filter(Boolean) : (path ? [path] : []);
+    if (!pathArr.length) {
+      throw new Error('Sweep requires a path edge selection. Please select an EDGE to sweep along.');
+    }
+
+    // Resolve profile object: accept FACE or SKETCH group object
+    const obj = Array.isArray(profile) ? (profile[0] || null) : (profile || null);
+    let faceObj = obj;
+    if (obj && obj.type === 'SKETCH') {
+      faceObj = obj.children.find(ch => ch.type === 'FACE') || obj.children.find(ch => ch.userData?.faceName);
+    }
+
+    const removed = [];
+    // if the face is a child of a sketch we need to remove the sketch from the scene
+    const consumeSketch = this.inputParams?.consumeProfileSketch !== false;
+    if (consumeSketch && faceObj && faceObj.type === 'FACE' && faceObj.parent && faceObj.parent.type === 'SKETCH') {
+      removed.push(faceObj.parent);
+    }
+
+    const twistAngleNum = Number(twistAngle);
+
+    // Create the sweep solid
+    const sweep = new BREP.Sweep({
+      face: faceObj,
+      sweepPathEdges: pathArr,
+      mode: (orientationMode === 'pathAlign') ? 'pathAlign' : 'translate',
+      twistAngle: Number.isFinite(twistAngleNum) ? twistAngleNum : 0,
+      name: this.inputParams.featureID
+    });
+
+    sweep.collapseTinyTriangles(0.1);
+    sweep.simplify(0.1);
+
+
+    // Build and show the solid. Let errors surface so we can debug if needed.
+    sweep.visualize();
+
+    // Apply optional boolean operation via shared helper
+    const effects = await BREP.applyBooleanOperation(partHistory || {}, sweep, this.inputParams.boolean, this.inputParams.featureID);
+    effects.removed = [...removed, ...effects.removed];
+    return effects;
+  }
+}

package/src/features/transform/TransformFeature.js

@@ -0,0 +1,152 @@
+import { BREP } from "../../BREP/BREP.js";
+const THREE = BREP.THREE;
+
+const inputParamsSchema = {
+    id: {
+    type: "string",
+    default_value: null,
+    hint: "unique identifier for the loft feature",
+  },
+  solids: {
+    type: "reference_selection",
+    selectionFilter: ["SOLID"],
+    multiple: true,
+    default_value: [],
+    hint: "Select solids to transform",
+  },
+  space: {
+    type: "options",
+    options: ["WORLD", "LOCAL"],
+    default_value: "WORLD",
+    hint: "Interpret translation/rotation in WORLD or LOCAL space",
+  },
+  pivot: {
+    type: "options",
+    options: ["ORIGIN", "BBOX_CENTER"],
+    default_value: "ORIGIN",
+    hint: "Pivot point for rotation/scale",
+  },
+  translate: {
+    type: "vec3",
+    default_value: [0, 0, 0],
+    hint: "Translation [x,y,z]",
+  },
+  rotateEulerDeg: {
+    type: "vec3",
+    default_value: [0, 0, 0],
+    hint: "Rotation in degrees [rx,ry,rz] about pivot (XYZ order)",
+  },
+  scale: {
+    type: "vec3",
+    default_value: [1, 1, 1],
+    hint: "Non-uniform scale [sx,sy,sz] about pivot",
+    step: 0.1,
+    uniformToggle: true,
+    uniformDefault: true,
+    uniformLockLabel: 'Uniform scale',
+  },
+  copy: {
+    type: "boolean",
+    default_value: false,
+    label: "Copy",
+    hint: "Create a new transformed copy; keep the original",
+  },
+};
+
+export class TransformFeature {
+  static shortName = "XFORM";
+  static longName = "Transform";
+  static inputParamsSchema = inputParamsSchema;
+
+  constructor() {
+    this.inputParams = {};
+    this.persistentData = {};
+  }
+
+  async run(partHistory) {
+    const solids = Array.isArray(this.inputParams.solids) ? this.inputParams.solids.filter(s => s && s.type === 'SOLID') : [];
+    if (!solids.length) return { added: [], removed: [] };
+
+    const space = (this.inputParams.space || 'WORLD').toUpperCase();
+    const pivot = (this.inputParams.pivot || 'ORIGIN').toUpperCase();
+    const t = toVec3(this.inputParams.translate, 0, 0, 0);
+    const rDeg = toVec3(this.inputParams.rotateEulerDeg, 0, 0, 0);
+    const s = toVec3(this.inputParams.scale, 1, 1, 1);
+    const copy = !!this.inputParams.copy;
+    const replace = !copy;
+
+    const out = [];
+    const removed = [];
+    for (const src of solids) {
+      const dst = src.clone();
+
+      // Compute pivot point in world
+      const pivotPoint = (pivot === 'BBOX_CENTER') ? bboxCenterWorld(src) : new THREE.Vector3(0, 0, 0);
+
+      // Build rotation and scale in requested space
+      const eulerRad = new THREE.Euler(
+        THREE.MathUtils.degToRad(rDeg.x),
+        THREE.MathUtils.degToRad(rDeg.y),
+        THREE.MathUtils.degToRad(rDeg.z),
+        'XYZ'
+      );
+      const quat = new THREE.Quaternion().setFromEuler(eulerRad);
+      const scl = new THREE.Vector3(s.x, s.y, s.z);
+
+      // Construct matrix with pivot: T * Tr(pivot) * R * S * Tr(-pivot)
+      const M = new THREE.Matrix4();
+      const Tpivot = new THREE.Matrix4().makeTranslation(pivotPoint.x, pivotPoint.y, pivotPoint.z);
+      const Tnp = new THREE.Matrix4().makeTranslation(-pivotPoint.x, -pivotPoint.y, -pivotPoint.z);
+      const RS = new THREE.Matrix4().compose(new THREE.Vector3(0, 0, 0), quat, scl);
+      const Tmove = new THREE.Matrix4().makeTranslation(t.x, t.y, t.z);
+
+      if (space === 'LOCAL') {
+        // Translate in local space of src: convert local move to world by applying src's world matrix
+        const localDir = new THREE.Vector3(t.x, t.y, t.z).applyMatrix3(new THREE.Matrix3().setFromMatrix4(src.matrixWorld));
+        Tmove.setPosition(localDir);
+      }
+
+      M.multiply(Tmove).multiply(Tpivot).multiply(RS).multiply(Tnp);
+
+      dst.bakeTransform(M); // bake into geometry arrays
+      if (replace) {
+        // Keep the original name when replacing
+        dst.name = src.name || dst.name || 'Solid';
+      } else {
+        // Name copies with _COPY suffix
+        const base = src.name || 'Solid';
+        dst.name = `${base}_${this.inputParams.id}`;
+      }
+      dst.visualize();
+
+      if (replace) {
+        try { src.__removeFlag = true; } catch {}
+        removed.push(src);
+      }
+      out.push(dst);
+    }
+    return { added: out, removed };
+  }
+}
+
+function toVec3(v, dx, dy, dz) {
+  if (Array.isArray(v)) return new THREE.Vector3(v[0] ?? dx, v[1] ?? dy, v[2] ?? dz);
+  if (v && typeof v === 'object') return new THREE.Vector3(v.x ?? dx, v.y ?? dy, v.z ?? dz);
+  return new THREE.Vector3(dx, dy, dz);
+}
+
+function bboxCenterWorld(solid) {
+  const mesh = solid.getMesh();
+  try {
+    const vp = mesh.vertProperties;
+    if (!vp || vp.length < 3) return new THREE.Vector3(0, 0, 0);
+    const bbMin = new THREE.Vector3(+Infinity, +Infinity, +Infinity);
+    const bbMax = new THREE.Vector3(-Infinity, -Infinity, -Infinity);
+    for (let i = 0; i < vp.length; i += 3) {
+      const x = vp[i + 0], y = vp[i + 1], z = vp[i + 2];
+      bbMin.x = Math.min(bbMin.x, x); bbMin.y = Math.min(bbMin.y, y); bbMin.z = Math.min(bbMin.z, z);
+      bbMax.x = Math.max(bbMax.x, x); bbMax.y = Math.max(bbMax.y, y); bbMax.z = Math.max(bbMax.z, z);
+    }
+    return bbMin.add(bbMax).multiplyScalar(0.5);
+  } finally { try { if (mesh && typeof mesh.delete === 'function') mesh.delete(); } catch {} }
+}