brepjs 8.8.2 → 8.8.3

package/dist/loft-DTRcYrq2.js

@@ -0,0 +1,531 @@
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
+    var dispose, inner;
+    if (async) dispose = value[__knownSymbol("asyncDispose")];
+    if (dispose === void 0) {
+      dispose = value[__knownSymbol("dispose")];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") __typeError("Object not disposable");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  };
+  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
+  var next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0]) return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError) throw error;
+  };
+  return next();
+};
+import { g as getKernel, d as toOcPnt, c as makeOcAx2, m as makeOcAx1, a as toVec3 } from "./occtBoundary-DvBywHyU.js";
+import { D as DEG2RAD, v as vecAdd, g as vecLength } from "./vecOps-ZDdZWbwT.js";
+import { c as cast, d as downcast, a as isShape3D$1, b as isWire } from "./faceFns-q5CR9pOW.js";
+import { e as err, x as validationError, l as ok, u as unwrap, p as typeCastError, a as andThen, o as occtError } from "./errors-DJ92ermb.js";
+import { D as DisposalScope, k as isShell, t as createCompound, u as createVertex, v as createSolid, j as isShape3D, l as isSolid } from "./shapeTypes-Bi_9RZa2.js";
+import { a as makeLine, b as assembleWire, c as makeHelix } from "./surfaceBuilders-W9Y25CIb.js";
+function buildLawFromProfile(extrusionLength, { profile, endFactor = 1 }) {
+  var _stack = [];
+  try {
+    const oc = getKernel().oc;
+    const scope = __using(_stack, new DisposalScope());
+    let law;
+    if (profile === "s-curve") {
+      law = scope.register(new oc.Law_S());
+      law.Set_1(0, 1, extrusionLength, endFactor);
+    } else if (profile === "linear") {
+      law = scope.register(new oc.Law_Linear());
+      law.Set(0, 1, extrusionLength, endFactor);
+    } else {
+      return err(
+        validationError("UNSUPPORTED_PROFILE", `Unsupported extrusion profile: ${String(profile)}`)
+      );
+    }
+    return ok(law.Trim(0, extrusionLength, 1e-6));
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function weldShapes(facesOrShells) {
+  const sewn = getKernel().sew(facesOrShells.map((s) => s.wrapped));
+  return unwrap(cast(unwrap(downcast(sewn))));
+}
+function weldShellsAndFaces(facesOrShells, ignoreType = false) {
+  const shell = weldShapes(facesOrShells);
+  if (!ignoreType && !isShell(shell))
+    return err(typeCastError("WELD_NOT_SHELL", "Could not make a shell from faces and shells"));
+  return ok(shell);
+}
+function makeCylinder(radius, height, location = [0, 0, 0], direction = [0, 0, 1]) {
+  var _stack = [];
+  try {
+    const oc = getKernel().oc;
+    const scope = __using(_stack, new DisposalScope());
+    const axis = scope.register(makeOcAx2(location, direction));
+    const cylinder = scope.register(new oc.BRepPrimAPI_MakeCylinder_3(axis, radius, height));
+    return createSolid(cylinder.Shape());
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function makeSphere(radius) {
+  var _stack = [];
+  try {
+    const oc = getKernel().oc;
+    const scope = __using(_stack, new DisposalScope());
+    const sphereMaker = scope.register(new oc.BRepPrimAPI_MakeSphere_1(radius));
+    return createSolid(sphereMaker.Shape());
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function makeCone(radius1, radius2, height, location = [0, 0, 0], direction = [0, 0, 1]) {
+  var _stack = [];
+  try {
+    const oc = getKernel().oc;
+    const scope = __using(_stack, new DisposalScope());
+    const axis = scope.register(makeOcAx2(location, direction));
+    const coneMaker = scope.register(new oc.BRepPrimAPI_MakeCone_3(axis, radius1, radius2, height));
+    return createSolid(coneMaker.Shape());
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function makeTorus(majorRadius, minorRadius, location = [0, 0, 0], direction = [0, 0, 1]) {
+  var _stack = [];
+  try {
+    const oc = getKernel().oc;
+    const scope = __using(_stack, new DisposalScope());
+    const axis = scope.register(makeOcAx2(location, direction));
+    const torusMaker = scope.register(new oc.BRepPrimAPI_MakeTorus_5(axis, majorRadius, minorRadius));
+    return createSolid(torusMaker.Shape());
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function makeEllipsoidTransform(x, y, z) {
+  var _stack = [];
+  try {
+    const oc = getKernel().oc;
+    const scope = __using(_stack, new DisposalScope());
+    const xyRatio = Math.sqrt(x * y / z);
+    const xzRatio = x / xyRatio;
+    const yzRatio = y / xyRatio;
+    const ax1 = scope.register(makeOcAx1([0, 0, 0], [0, 1, 0]));
+    const ax2 = scope.register(makeOcAx1([0, 0, 0], [0, 0, 1]));
+    const ax3 = scope.register(makeOcAx1([0, 0, 0], [1, 0, 0]));
+    const transform = new oc.gp_GTrsf_1();
+    transform.SetAffinity_1(ax1, xzRatio);
+    const xy = scope.register(new oc.gp_GTrsf_1());
+    xy.SetAffinity_1(ax2, xyRatio);
+    const yz = scope.register(new oc.gp_GTrsf_1());
+    yz.SetAffinity_1(ax3, yzRatio);
+    transform.Multiply(xy);
+    transform.Multiply(yz);
+    return {
+      transform,
+      applyToPoint(p) {
+        var _stack2 = [];
+        try {
+          const scope2 = __using(_stack2, new DisposalScope());
+          const coords = scope2.register(p.XYZ());
+          transform.Transforms_1(coords);
+          return new oc.gp_Pnt_2(coords);
+        } catch (_2) {
+          var _error2 = _2, _hasError2 = true;
+        } finally {
+          __callDispose(_stack2, _error2, _hasError2);
+        }
+      }
+    };
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function convertToJSArray(arrayOfPoints) {
+  const newArray = [];
+  for (let row = arrayOfPoints.LowerRow(); row <= arrayOfPoints.UpperRow(); row++) {
+    const rowArr = [];
+    newArray.push(rowArr);
+    for (let c = arrayOfPoints.LowerCol(); c <= arrayOfPoints.UpperCol(); c++) {
+      const pnt = arrayOfPoints.Value(row, c);
+      rowArr.push(pnt);
+    }
+  }
+  return newArray;
+}
+function makeEllipsoid(aLength, bLength, cLength) {
+  var _stack = [];
+  try {
+    const oc = getKernel().oc;
+    const scope = __using(_stack, new DisposalScope());
+    const sphere = scope.register(new oc.gp_Sphere_1());
+    sphere.SetRadius(1);
+    const sphericalSurface = scope.register(new oc.Geom_SphericalSurface_2(sphere));
+    const baseSurface = oc.GeomConvert.SurfaceToBSplineSurface(sphericalSurface.UReversed()).get();
+    try {
+      const poles = convertToJSArray(baseSurface.Poles_2());
+      const ellipsoidTrsf = makeEllipsoidTransform(aLength, bLength, cLength);
+      poles.forEach((columns, rowIdx) => {
+        columns.forEach((value, colIdx) => {
+          const newPoint = ellipsoidTrsf.applyToPoint(value);
+          baseSurface.SetPole_1(rowIdx + 1, colIdx + 1, newPoint);
+          newPoint.delete();
+        });
+      });
+      ellipsoidTrsf.transform.delete();
+      const shell = unwrap(
+        cast(
+          scope.register(new oc.BRepBuilderAPI_MakeShell_2(baseSurface.UReversed(), false)).Shell()
+        )
+      );
+      return unwrap(makeSolid([shell]));
+    } finally {
+      baseSurface.delete();
+    }
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function makeVertex(point) {
+  var _stack = [];
+  try {
+    const oc = getKernel().oc;
+    const scope = __using(_stack, new DisposalScope());
+    const pnt = scope.register(toOcPnt(point));
+    const vertexMaker = scope.register(new oc.BRepBuilderAPI_MakeVertex(pnt));
+    return createVertex(vertexMaker.Vertex());
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function makeOffset(face, offset, tolerance = 1e-6) {
+  const oc = getKernel().oc;
+  const progress = new oc.Message_ProgressRange_1();
+  const offsetBuilder = new oc.BRepOffsetAPI_MakeOffsetShape();
+  try {
+    offsetBuilder.PerformByJoin(
+      face.wrapped,
+      offset,
+      tolerance,
+      oc.BRepOffset_Mode.BRepOffset_Skin,
+      false,
+      false,
+      oc.GeomAbs_JoinType.GeomAbs_Arc,
+      false,
+      progress
+    );
+    return andThen(
+      downcast(offsetBuilder.Shape()),
+      (downcasted) => andThen(cast(downcasted), (newShape) => {
+        if (!isShape3D(newShape))
+          return err(typeCastError("OFFSET_NOT_3D", "Could not offset to a 3d shape"));
+        return ok(newShape);
+      })
+    );
+  } finally {
+    offsetBuilder.delete();
+    progress.delete();
+  }
+}
+function makeCompound(shapeArray) {
+  const oc = getKernel().oc;
+  const builder = new oc.TopoDS_Builder();
+  const compound = new oc.TopoDS_Compound();
+  builder.MakeCompound(compound);
+  for (const s of shapeArray) {
+    builder.Add(compound, s.wrapped);
+  }
+  builder.delete();
+  return createCompound(compound);
+}
+function makeSolid(facesOrShells) {
+  var _stack = [];
+  try {
+    const scope = __using(_stack, new DisposalScope());
+    const oc = getKernel().oc;
+    const shell = weldShapes(facesOrShells);
+    return andThen(
+      cast(scope.register(new oc.ShapeFix_Solid_1()).SolidFromShell(shell.wrapped)),
+      (solid) => {
+        if (!isSolid(solid))
+          return err(
+            typeCastError("SOLID_BUILD_FAILED", "Could not make a solid of faces and shells")
+          );
+        return ok(solid);
+      }
+    );
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+const basicFaceExtrusion = (face, extrusionVec) => {
+  var _stack = [];
+  try {
+    const oc = getKernel().oc;
+    const scope = __using(_stack, new DisposalScope());
+    const vec = toVec3(extrusionVec);
+    const ocVec = scope.register(new oc.gp_Vec_4(vec[0], vec[1], vec[2]));
+    const solidBuilder = scope.register(
+      new oc.BRepPrimAPI_MakePrism_1(face.wrapped, ocVec, false, true)
+    );
+    const solid = createSolid(unwrap(downcast(solidBuilder.Shape())));
+    return solid;
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+};
+const revolution = (face, center = [0, 0, 0], direction = [0, 0, 1], angle = 360) => {
+  var _stack = [];
+  try {
+    const oc = getKernel().oc;
+    const scope = __using(_stack, new DisposalScope());
+    const centerVec = toVec3(center);
+    const directionVec = toVec3(direction);
+    const ax = scope.register(makeOcAx1(centerVec, directionVec));
+    const revolBuilder = scope.register(
+      new oc.BRepPrimAPI_MakeRevol_1(face.wrapped, ax, angle * DEG2RAD, false)
+    );
+    const result = andThen(cast(revolBuilder.Shape()), (shape) => {
+      if (!isShape3D$1(shape))
+        return err(typeCastError("REVOLUTION_NOT_3D", "Revolution did not produce a 3D shape"));
+      return ok(shape);
+    });
+    return result;
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+};
+function genericSweep(wire, spine, {
+  frenet = false,
+  auxiliarySpine,
+  law = null,
+  transitionMode = "right",
+  withContact,
+  support,
+  forceProfileSpineOthogonality,
+  mode: sweepMode,
+  tolerance,
+  boundTolerance,
+  angularTolerance,
+  maxDegree,
+  maxSegments
+} = {}, shellMode = false) {
+  var _stack = [];
+  try {
+    if (sweepMode === "simple" && !shellMode) {
+      const kernel = getKernel();
+      const resultOc = kernel.simplePipe(wire.wrapped, spine.wrapped);
+      const result = andThen(cast(resultOc), (shape2) => {
+        if (!isShape3D$1(shape2))
+          return err(typeCastError("SWEEP_NOT_3D", "Simple pipe did not produce a 3D shape"));
+        return ok(shape2);
+      });
+      return result;
+    }
+    const oc = getKernel().oc;
+    const scope = __using(_stack, new DisposalScope());
+    const withCorrection = transitionMode === "round" ? true : !!forceProfileSpineOthogonality;
+    const sweepBuilder = scope.register(new oc.BRepOffsetAPI_MakePipeShell(spine.wrapped));
+    if (tolerance !== void 0) {
+      sweepBuilder.SetTolerance(tolerance, boundTolerance ?? tolerance, angularTolerance ?? 1e-7);
+    }
+    if (maxDegree !== void 0) {
+      sweepBuilder.SetMaxDegree(maxDegree);
+    }
+    if (maxSegments !== void 0) {
+      sweepBuilder.SetMaxSegments(maxSegments);
+    }
+    {
+      const mode = {
+        transformed: oc.BRepBuilderAPI_TransitionMode.BRepBuilderAPI_Transformed,
+        round: oc.BRepBuilderAPI_TransitionMode.BRepBuilderAPI_RoundCorner,
+        right: oc.BRepBuilderAPI_TransitionMode.BRepBuilderAPI_RightCorner
+      }[transitionMode];
+      if (mode) sweepBuilder.SetTransitionMode(mode);
+    }
+    if (support) {
+      sweepBuilder.SetMode_4(support);
+    } else if (frenet) {
+      sweepBuilder.SetMode_1(frenet);
+    }
+    if (auxiliarySpine) {
+      sweepBuilder.SetMode_5(
+        auxiliarySpine.wrapped,
+        false,
+        oc.BRepFill_TypeOfContact.BRepFill_NoContact
+      );
+    }
+    if (!law) sweepBuilder.Add_1(wire.wrapped, !!withContact, withCorrection);
+    else sweepBuilder.SetLaw_1(wire.wrapped, law, !!withContact, withCorrection);
+    const progress = scope.register(new oc.Message_ProgressRange_1());
+    sweepBuilder.Build(progress);
+    if (!sweepBuilder.IsDone()) {
+      return err(occtError("SWEEP_FAILED", "Sweep operation failed"));
+    }
+    if (!shellMode) {
+      sweepBuilder.MakeSolid();
+    }
+    const shape = unwrap(cast(sweepBuilder.Shape()));
+    if (!isShape3D$1(shape)) {
+      return err(typeCastError("SWEEP_NOT_3D", "Sweep did not produce a 3D shape"));
+    }
+    if (shellMode) {
+      const startWire = unwrap(cast(sweepBuilder.FirstShape()));
+      const endWire = unwrap(cast(sweepBuilder.LastShape()));
+      if (!isWire(startWire)) {
+        return err(typeCastError("SWEEP_START_NOT_WIRE", "Sweep did not produce a start Wire"));
+      }
+      if (!isWire(endWire)) {
+        return err(typeCastError("SWEEP_END_NOT_WIRE", "Sweep did not produce an end Wire"));
+      }
+      return ok([shape, startWire, endWire]);
+    }
+    return ok(shape);
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function complexExtrude(wire, center, normal, profileShape, shellMode = false) {
+  var _stack = [];
+  try {
+    const scope = __using(_stack, new DisposalScope());
+    const centerVec = toVec3(center);
+    const normalVec = toVec3(normal);
+    const endVec = vecAdd(centerVec, normalVec);
+    const mainSpineEdge = scope.register(makeLine(centerVec, endVec));
+    const spine = scope.register(unwrap(assembleWire([mainSpineEdge])));
+    const law = profileShape ? scope.register(unwrap(buildLawFromProfile(vecLength(normalVec), profileShape))) : null;
+    const result = shellMode ? genericSweep(wire, spine, { law }, shellMode) : genericSweep(wire, spine, { law });
+    return result;
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function twistExtrude(wire, angleDegrees, center, normal, profileShape, shellMode = false) {
+  var _stack = [];
+  try {
+    const scope = __using(_stack, new DisposalScope());
+    const centerVec = toVec3(center);
+    const normalVec = toVec3(normal);
+    const endVec = vecAdd(centerVec, normalVec);
+    const mainSpineEdge = scope.register(makeLine(centerVec, endVec));
+    const spine = scope.register(unwrap(assembleWire([mainSpineEdge])));
+    const extrusionLength = vecLength(normalVec);
+    const pitch = 360 / angleDegrees * extrusionLength;
+    const radius = 1;
+    const auxiliarySpine = scope.register(
+      makeHelix(pitch, extrusionLength, radius, centerVec, normalVec)
+    );
+    const law = profileShape ? scope.register(unwrap(buildLawFromProfile(extrusionLength, profileShape))) : null;
+    const result = shellMode ? genericSweep(wire, spine, { auxiliarySpine, law }, shellMode) : genericSweep(wire, spine, { auxiliarySpine, law });
+    return result;
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+const loft = (wires, { ruled = true, startPoint, endPoint } = {}, returnShell = false) => {
+  var _stack = [];
+  try {
+    if (wires.length === 0 && !startPoint && !endPoint) {
+      return err(validationError("LOFT_EMPTY", "Loft requires at least one wire or start/end point"));
+    }
+    const oc = getKernel().oc;
+    const scope = __using(_stack, new DisposalScope());
+    const loftBuilder = scope.register(new oc.BRepOffsetAPI_ThruSections(!returnShell, ruled, 1e-6));
+    if (startPoint) {
+      loftBuilder.AddVertex(scope.register(makeVertex(toVec3(startPoint))).wrapped);
+    }
+    wires.forEach((w) => loftBuilder.AddWire(w.wrapped));
+    if (endPoint) {
+      loftBuilder.AddVertex(scope.register(makeVertex(toVec3(endPoint))).wrapped);
+    }
+    const progress = scope.register(new oc.Message_ProgressRange_1());
+    loftBuilder.Build(progress);
+    if (!loftBuilder.IsDone()) {
+      return err(occtError("LOFT_FAILED", "Loft operation failed"));
+    }
+    const result = andThen(cast(loftBuilder.Shape()), (shape) => {
+      if (!isShape3D$1(shape))
+        return err(typeCastError("LOFT_NOT_3D", "Loft did not produce a 3D shape"));
+      return ok(shape);
+    });
+    return result;
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+};
+export {
+  makeSolid as a,
+  basicFaceExtrusion as b,
+  complexExtrude as c,
+  makeCone as d,
+  makeCylinder as e,
+  makeEllipsoid as f,
+  genericSweep as g,
+  makeOffset as h,
+  makeSphere as i,
+  makeTorus as j,
+  makeVertex as k,
+  loft as l,
+  makeCompound as m,
+  buildLawFromProfile as n,
+  revolution as r,
+  twistExtrude as t,
+  weldShellsAndFaces as w
+};