brep-io-kernel 1.0.0-ci.10

package/src/features/remesh/RemeshFeature.js

@@ -0,0 +1,97 @@
+ 
+
+const inputParamsSchema = {
+  id: {
+    type: "string",
+    default_value: null,
+    hint: "unique identifier for the remesh feature",
+  },
+  targetSolid: {
+    type: "reference_selection",
+    selectionFilter: ["SOLID"],
+    multiple: false,
+    default_value: null,
+    hint: "Select a solid to remesh (clone is created)",
+  },
+  mode: {
+    type: "options",
+    options: ["Increase resolution", "Simplify"],
+    default_value: "Increase resolution",
+    hint: "Choose remeshing mode",
+  },
+  maxEdgeLength: {
+    type: "number",
+    step: 0.1,
+    default_value: 1,
+    hint: "Split edges longer than this length",
+  },
+  maxIterations: {
+    type: "number",
+    step: 1,
+    default_value: 10,
+    hint: "Maximum refinement passes",
+  },
+  tolerance: {
+    type: "number",
+    step: 0.1,
+    default_value: 0.1,
+    hint: "Simplify tolerance (used in Simplify mode)",
+  },
+};
+
+export class RemeshFeature {
+  static shortName = "RM";
+  static longName = "Remesh";
+  static inputParamsSchema = inputParamsSchema;
+
+  constructor() {
+    this.inputParams = {};
+    this.persistentData = {};
+  }
+
+  async run(partHistory) {
+    const scene = partHistory.scene;
+
+    // Resolve target solid
+    const targetEntry = Array.isArray(this.inputParams.targetSolid)
+      ? (this.inputParams.targetSolid[0] || null)
+      : (this.inputParams.targetSolid || null);
+    const target = (targetEntry && typeof targetEntry === 'object')
+      ? targetEntry
+      : (targetEntry ? await scene.getObjectByName(String(targetEntry)) : null);
+
+    if (!target || target.type !== 'SOLID') return { added: [], removed: [] };
+
+    const modeRaw = this.inputParams.mode || 'Increase resolution';
+    const mode = String(modeRaw).toLowerCase();
+
+    // Clone target to preserve original
+    const outSolid = target.clone();
+
+    if (mode === 'simplify') {
+      const T = Number(this.inputParams.tolerance);
+      const tol = Number.isFinite(T) && T >= 0 ? T : undefined;
+      try {
+        if (tol === undefined) outSolid.simplify();
+        else outSolid.simplify(tol);
+      } catch (e) {
+        console.warn('[RemeshFeature] Simplify failed; returning original clone.', e);
+      }
+    } else {
+      const L = Number(this.inputParams.maxEdgeLength);
+      const I = Number(this.inputParams.maxIterations);
+      const maxEdgeLength = (Number.isFinite(L) && L > 0) ? L : 1;
+      const maxIterations = (Number.isFinite(I) && I > 0) ? I : 10;
+      try { outSolid.remesh({ maxEdgeLength, maxIterations }); } catch (e) {
+        console.warn('[RemeshFeature] Remesh failed; returning original clone.', e);
+      }
+    }
+
+    // Name and visualize for UI
+    try { outSolid.name = `(${target.name || 'Solid'})`; } catch (_) {}
+    try { outSolid.visualize(); } catch (_) {}
+
+    try { target.__removeFlag = true; } catch {}
+    return { added: [outSolid], removed: [target] };
+  }
+}

package/src/features/revolve/RevolveFeature.js

@@ -0,0 +1,111 @@
+import { BREP } from "../../BREP/BREP.js";
+import { selectionHasSketch } from "../selectionUtils.js";
+
+const inputParamsSchema = {
+    id: {
+        type: "string",
+        default_value: null,
+        hint: "unique identifier for the revolve feature",
+    },
+    profile: {
+        type: "reference_selection",
+        selectionFilter: ["SKETCH", "FACE"],
+        multiple: false,
+        default_value: null,
+        hint: "Select the profile (face) to revolve",
+    },
+    consumeProfileSketch: {
+        type: "boolean",
+        default_value: true,
+        hint: "Remove the referenced sketch after creating the revolve. Turn off to keep it in the scene.",
+    },
+    axis: {
+        type: "reference_selection",
+        selectionFilter: ["EDGE"],
+        multiple: false,
+        default_value: null,
+        hint: "Select the axis to revolve about",
+    },
+    angle: {
+        type: "number",
+        default_value: 360,
+        hint: "Revolve angle",
+    },
+    resolution: {
+        type: "number",
+        default_value: 64,
+        hint: "Number of segments used for the revolve sweep",
+    },
+    boolean: {
+        type: "boolean_operation",
+        default_value: { targets: [], operation: 'NONE' },
+        hint: "Optional boolean operation with selected solids"
+    }
+};
+
+export class RevolveFeature {
+    static shortName = "R";
+    static longName = "Revolve";
+    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) {
+        const { profile, axis, angle, resolution } = this.inputParams;
+
+        // 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);
+        }
+        if (!faceObj || !faceObj.geometry) return { added: [], removed: [] };
+        // if the face is a child of a sketch we need to remove the sketch from the scene
+
+        const axisObj = Array.isArray(axis) ? (axis[0] || null) : (axis || null);
+        if (!axisObj) {
+            console.warn("RevolveFeature: no axis selected");
+            return { added: [], removed: [] };
+        }
+        if (!faceObj) {
+            console.warn("RevolveFeature: no profile face found");
+            return { added: [], removed: [] };
+        }
+
+        const removed = [];
+        const consumeSketch = this.inputParams?.consumeProfileSketch !== false;
+        if (consumeSketch && faceObj && faceObj.type === 'FACE' && faceObj.parent && faceObj.parent.type === 'SKETCH') {
+            removed.push(faceObj.parent);
+        }
+
+        const revolve = new BREP.Revolve({
+            face: faceObj,
+            axis: axisObj,
+            angle,
+            resolution,
+            name: this.inputParams.featureID,
+        });
+
+        // Weld slight numerical seams and build mesh
+        try { revolve.setEpsilon(1e-6); } catch { }
+        revolve.visualize();
+        const effects = await BREP.applyBooleanOperation(partHistory || {}, revolve, this.inputParams.boolean, this.inputParams.featureID);
+        const booleanRemoved = Array.isArray(effects.removed) ? effects.removed : [];
+        const removedArtifacts = [...removed, ...booleanRemoved];
+        // Flag removals (sketch parent + boolean effects)
+        try { for (const obj of removedArtifacts) { if (obj) obj.__removeFlag = true; } } catch { }
+        return {
+            added: Array.isArray(effects.added) ? effects.added : [],
+            removed: removedArtifacts,
+        };
+    }
+}

package/src/features/selectionUtils.js

@@ -0,0 +1,118 @@
+export function resolveSelectionObject(selection, partHistory) {
+  if (!selection) return null;
+  if (typeof selection === 'string') {
+    if (partHistory && typeof partHistory.getObjectByName === 'function') {
+      return partHistory.getObjectByName(selection);
+    }
+    const scene = partHistory?.scene;
+    if (scene && typeof scene.getObjectByName === 'function') {
+      return scene.getObjectByName(selection);
+    }
+    return null;
+  }
+  return selection;
+}
+
+function getFeatureEntryId(entry) {
+  if (!entry || typeof entry !== 'object') return null;
+  const params = entry.inputParams || {};
+  const rawId = params.id ?? params.featureID ?? entry.id ?? null;
+  if (rawId == null) return null;
+  return String(rawId);
+}
+
+function isSketchFeatureType(type, partHistory) {
+  const raw = type == null ? '' : String(type).trim();
+  if (!raw) return false;
+  const upper = raw.toUpperCase();
+  if (upper === 'S' || upper === 'SKETCH' || upper === 'SKETCHFEATURE') return true;
+
+  const registry = partHistory?.featureRegistry;
+  if (!registry || typeof registry.getSafe !== 'function') return false;
+  const cls = registry.getSafe(raw);
+  if (!cls) return false;
+  const shortName = String(cls.shortName || '').toUpperCase();
+  const longName = String(cls.longName || '').toUpperCase();
+  const className = String(cls.name || '').toUpperCase();
+  if (shortName === 'S' || longName.includes('SKETCH') || className.includes('SKETCH')) return true;
+  if (shortName === 'SP' || className.includes('SPLINE')) return true;
+  if (shortName === 'IMAGE' || className.includes('IMAGETOFACE')) return true;
+  return false;
+}
+
+function isSketchFeatureId(partHistory, refName) {
+  if (!partHistory || !Array.isArray(partHistory.features)) return false;
+  const target = String(refName);
+  for (const entry of partHistory.features) {
+    const entryId = getFeatureEntryId(entry);
+    if (entryId !== target) continue;
+    if (isSketchFeatureType(entry?.type, partHistory)) return true;
+  }
+  return false;
+}
+
+export function selectionHasSketch(selection, partHistory) {
+  const list = Array.isArray(selection) ? selection : [selection];
+  for (const item of list) {
+    if (!item) continue;
+    if (typeof item === 'string') {
+      const raw = item.trim();
+      if (!raw) continue;
+      const base = raw.split(/[:|\[]/, 1)[0];
+      if (base && isSketchFeatureId(partHistory, base)) return true;
+    }
+    const obj = resolveSelectionObject(item, partHistory);
+    if (!obj) continue;
+    if (obj.type === 'SKETCH') return true;
+    if (obj.parent && obj.parent.type === 'SKETCH') return true;
+    if (obj.name) {
+      const base = String(obj.name).split(/[:|\[]/, 1)[0];
+      if (base && isSketchFeatureId(partHistory, base)) return true;
+    }
+  }
+  return false;
+}
+
+export function normalizeSelectionName(value) {
+  if (value == null) return null;
+
+  if (typeof value === 'string') {
+    const trimmed = value.trim();
+    if (!trimmed) return null;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed && typeof parsed === 'object') {
+        const parsedName = typeof parsed.name === 'string' ? parsed.name.trim() : '';
+        if (parsedName) return parsedName;
+        const parsedId = typeof parsed.id === 'string' ? parsed.id.trim() : '';
+        if (parsedId) return parsedId;
+      }
+    } catch { /* not JSON */ }
+    return trimmed;
+  }
+
+  if (typeof value === 'object') {
+    if (typeof value.name === 'string' && value.name.trim()) return value.name.trim();
+    if (typeof value.id === 'string' && value.id.trim()) return value.id.trim();
+    if (Array.isArray(value.path)) {
+      const joined = value.path.filter(Boolean).map(String).join(' > ');
+      if (joined) return joined;
+    }
+  }
+
+  const asString = String(value);
+  return asString.trim() || null;
+}
+
+export function normalizeSelectionList(values) {
+  if (!Array.isArray(values)) return [];
+  const seen = new Set();
+  const out = [];
+  for (const item of values) {
+    const normalized = normalizeSelectionName(item);
+    if (!normalized || seen.has(normalized)) continue;
+    seen.add(normalized);
+    out.push(normalized);
+  }
+  return out;
+}