brepjs 8.8.2 → 8.8.4

package/dist/loft-Bhnw5Rfr.cjs

@@ -0,0 +1,530 @@
+"use strict";
+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();
+};
+const occtBoundary = require("./occtBoundary-CN_uQJtA.cjs");
+const vecOps = require("./vecOps-CjRL1jau.cjs");
+const faceFns = require("./faceFns-B8xnZw-f.cjs");
+const errors = require("./errors-BYb4tL5h.cjs");
+const shapeTypes = require("./shapeTypes-sXITvFkF.cjs");
+const surfaceBuilders = require("./surfaceBuilders-hupjYn0W.cjs");
+function buildLawFromProfile(extrusionLength, { profile, endFactor = 1 }) {
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.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 errors.err(
+        errors.validationError("UNSUPPORTED_PROFILE", `Unsupported extrusion profile: ${String(profile)}`)
+      );
+    }
+    return errors.ok(law.Trim(0, extrusionLength, 1e-6));
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function weldShapes(facesOrShells) {
+  const sewn = occtBoundary.getKernel().sew(facesOrShells.map((s) => s.wrapped));
+  return errors.unwrap(faceFns.cast(errors.unwrap(faceFns.downcast(sewn))));
+}
+function weldShellsAndFaces(facesOrShells, ignoreType = false) {
+  const shell = weldShapes(facesOrShells);
+  if (!ignoreType && !shapeTypes.isShell(shell))
+    return errors.err(errors.typeCastError("WELD_NOT_SHELL", "Could not make a shell from faces and shells"));
+  return errors.ok(shell);
+}
+function makeCylinder(radius, height, location = [0, 0, 0], direction = [0, 0, 1]) {
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const axis = scope.register(occtBoundary.makeOcAx2(location, direction));
+    const cylinder = scope.register(new oc.BRepPrimAPI_MakeCylinder_3(axis, radius, height));
+    return shapeTypes.createSolid(cylinder.Shape());
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function makeSphere(radius) {
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const sphereMaker = scope.register(new oc.BRepPrimAPI_MakeSphere_1(radius));
+    return shapeTypes.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 = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const axis = scope.register(occtBoundary.makeOcAx2(location, direction));
+    const coneMaker = scope.register(new oc.BRepPrimAPI_MakeCone_3(axis, radius1, radius2, height));
+    return shapeTypes.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 = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const axis = scope.register(occtBoundary.makeOcAx2(location, direction));
+    const torusMaker = scope.register(new oc.BRepPrimAPI_MakeTorus_5(axis, majorRadius, minorRadius));
+    return shapeTypes.createSolid(torusMaker.Shape());
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function makeEllipsoidTransform(x, y, z) {
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const xyRatio = Math.sqrt(x * y / z);
+    const xzRatio = x / xyRatio;
+    const yzRatio = y / xyRatio;
+    const ax1 = scope.register(occtBoundary.makeOcAx1([0, 0, 0], [0, 1, 0]));
+    const ax2 = scope.register(occtBoundary.makeOcAx1([0, 0, 0], [0, 0, 1]));
+    const ax3 = scope.register(occtBoundary.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 shapeTypes.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 = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.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 = errors.unwrap(
+        faceFns.cast(
+          scope.register(new oc.BRepBuilderAPI_MakeShell_2(baseSurface.UReversed(), false)).Shell()
+        )
+      );
+      return errors.unwrap(makeSolid([shell]));
+    } finally {
+      baseSurface.delete();
+    }
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function makeVertex(point) {
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const pnt = scope.register(occtBoundary.toOcPnt(point));
+    const vertexMaker = scope.register(new oc.BRepBuilderAPI_MakeVertex(pnt));
+    return shapeTypes.createVertex(vertexMaker.Vertex());
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function makeOffset(face, offset, tolerance = 1e-6) {
+  const oc = occtBoundary.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 errors.andThen(
+      faceFns.downcast(offsetBuilder.Shape()),
+      (downcasted) => errors.andThen(faceFns.cast(downcasted), (newShape) => {
+        if (!shapeTypes.isShape3D(newShape))
+          return errors.err(errors.typeCastError("OFFSET_NOT_3D", "Could not offset to a 3d shape"));
+        return errors.ok(newShape);
+      })
+    );
+  } finally {
+    offsetBuilder.delete();
+    progress.delete();
+  }
+}
+function makeCompound(shapeArray) {
+  const oc = occtBoundary.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 shapeTypes.createCompound(compound);
+}
+function makeSolid(facesOrShells) {
+  var _stack = [];
+  try {
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const oc = occtBoundary.getKernel().oc;
+    const shell = weldShapes(facesOrShells);
+    return errors.andThen(
+      faceFns.cast(scope.register(new oc.ShapeFix_Solid_1()).SolidFromShell(shell.wrapped)),
+      (solid) => {
+        if (!shapeTypes.isSolid(solid))
+          return errors.err(
+            errors.typeCastError("SOLID_BUILD_FAILED", "Could not make a solid of faces and shells")
+          );
+        return errors.ok(solid);
+      }
+    );
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+const basicFaceExtrusion = (face, extrusionVec) => {
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const vec = occtBoundary.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 = shapeTypes.createSolid(errors.unwrap(faceFns.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 = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const centerVec = occtBoundary.toVec3(center);
+    const directionVec = occtBoundary.toVec3(direction);
+    const ax = scope.register(occtBoundary.makeOcAx1(centerVec, directionVec));
+    const revolBuilder = scope.register(
+      new oc.BRepPrimAPI_MakeRevol_1(face.wrapped, ax, angle * vecOps.DEG2RAD, false)
+    );
+    const result = errors.andThen(faceFns.cast(revolBuilder.Shape()), (shape) => {
+      if (!faceFns.isShape3D(shape))
+        return errors.err(errors.typeCastError("REVOLUTION_NOT_3D", "Revolution did not produce a 3D shape"));
+      return errors.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 = occtBoundary.getKernel();
+      const resultOc = kernel.simplePipe(wire.wrapped, spine.wrapped);
+      const result = errors.andThen(faceFns.cast(resultOc), (shape2) => {
+        if (!faceFns.isShape3D(shape2))
+          return errors.err(errors.typeCastError("SWEEP_NOT_3D", "Simple pipe did not produce a 3D shape"));
+        return errors.ok(shape2);
+      });
+      return result;
+    }
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.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 errors.err(errors.occtError("SWEEP_FAILED", "Sweep operation failed"));
+    }
+    if (!shellMode) {
+      sweepBuilder.MakeSolid();
+    }
+    const shape = errors.unwrap(faceFns.cast(sweepBuilder.Shape()));
+    if (!faceFns.isShape3D(shape)) {
+      return errors.err(errors.typeCastError("SWEEP_NOT_3D", "Sweep did not produce a 3D shape"));
+    }
+    if (shellMode) {
+      const startWire = errors.unwrap(faceFns.cast(sweepBuilder.FirstShape()));
+      const endWire = errors.unwrap(faceFns.cast(sweepBuilder.LastShape()));
+      if (!faceFns.isWire(startWire)) {
+        return errors.err(errors.typeCastError("SWEEP_START_NOT_WIRE", "Sweep did not produce a start Wire"));
+      }
+      if (!faceFns.isWire(endWire)) {
+        return errors.err(errors.typeCastError("SWEEP_END_NOT_WIRE", "Sweep did not produce an end Wire"));
+      }
+      return errors.ok([shape, startWire, endWire]);
+    }
+    return errors.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 shapeTypes.DisposalScope());
+    const centerVec = occtBoundary.toVec3(center);
+    const normalVec = occtBoundary.toVec3(normal);
+    const endVec = vecOps.vecAdd(centerVec, normalVec);
+    const mainSpineEdge = scope.register(surfaceBuilders.makeLine(centerVec, endVec));
+    const spine = scope.register(errors.unwrap(surfaceBuilders.assembleWire([mainSpineEdge])));
+    const law = profileShape ? scope.register(errors.unwrap(buildLawFromProfile(vecOps.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 shapeTypes.DisposalScope());
+    const centerVec = occtBoundary.toVec3(center);
+    const normalVec = occtBoundary.toVec3(normal);
+    const endVec = vecOps.vecAdd(centerVec, normalVec);
+    const mainSpineEdge = scope.register(surfaceBuilders.makeLine(centerVec, endVec));
+    const spine = scope.register(errors.unwrap(surfaceBuilders.assembleWire([mainSpineEdge])));
+    const extrusionLength = vecOps.vecLength(normalVec);
+    const pitch = 360 / angleDegrees * extrusionLength;
+    const radius = 1;
+    const auxiliarySpine = scope.register(
+      surfaceBuilders.makeHelix(pitch, extrusionLength, radius, centerVec, normalVec)
+    );
+    const law = profileShape ? scope.register(errors.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 errors.err(errors.validationError("LOFT_EMPTY", "Loft requires at least one wire or start/end point"));
+    }
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const loftBuilder = scope.register(new oc.BRepOffsetAPI_ThruSections(!returnShell, ruled, 1e-6));
+    if (startPoint) {
+      loftBuilder.AddVertex(scope.register(makeVertex(occtBoundary.toVec3(startPoint))).wrapped);
+    }
+    wires.forEach((w) => loftBuilder.AddWire(w.wrapped));
+    if (endPoint) {
+      loftBuilder.AddVertex(scope.register(makeVertex(occtBoundary.toVec3(endPoint))).wrapped);
+    }
+    const progress = scope.register(new oc.Message_ProgressRange_1());
+    loftBuilder.Build(progress);
+    if (!loftBuilder.IsDone()) {
+      return errors.err(errors.occtError("LOFT_FAILED", "Loft operation failed"));
+    }
+    const result = errors.andThen(faceFns.cast(loftBuilder.Shape()), (shape) => {
+      if (!faceFns.isShape3D(shape))
+        return errors.err(errors.typeCastError("LOFT_NOT_3D", "Loft did not produce a 3D shape"));
+      return errors.ok(shape);
+    });
+    return result;
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+};
+exports.basicFaceExtrusion = basicFaceExtrusion;
+exports.buildLawFromProfile = buildLawFromProfile;
+exports.complexExtrude = complexExtrude;
+exports.genericSweep = genericSweep;
+exports.loft = loft;
+exports.makeCompound = makeCompound;
+exports.makeCone = makeCone;
+exports.makeCylinder = makeCylinder;
+exports.makeEllipsoid = makeEllipsoid;
+exports.makeOffset = makeOffset;
+exports.makeSolid = makeSolid;
+exports.makeSphere = makeSphere;
+exports.makeTorus = makeTorus;
+exports.makeVertex = makeVertex;
+exports.revolution = revolution;
+exports.twistExtrude = twistExtrude;
+exports.weldShellsAndFaces = weldShellsAndFaces;