brepjs 8.8.2 → 8.8.3

package/dist/surfaceBuilders-CLal3WlK.cjs

@@ -0,0 +1,429 @@
+"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-Cqfsau2c.cjs");
+const errors = require("./errors-NNmTtM5u.cjs");
+const shapeTypes = require("./shapeTypes-CWuX602K.cjs");
+const shapeFns = require("./shapeFns-D4CRxxmF.cjs");
+const faceFns = require("./faceFns-DNQss51F.cjs");
+function range(len) {
+  return Array.from(Array(len).keys());
+}
+function zip(arrays) {
+  const minLength = Math.min(...arrays.map((arr) => arr.length));
+  return range(minLength).map((i) => arrays.map((arr) => arr[i]));
+}
+function makeLine(v1, v2) {
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const p1 = scope.register(occtBoundary.toOcPnt(v1));
+    const p2 = scope.register(occtBoundary.toOcPnt(v2));
+    const maker = scope.register(new oc.BRepBuilderAPI_MakeEdge_3(p1, p2));
+    return shapeTypes.createEdge(maker.Edge());
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function makeCircle(radius, center = [0, 0, 0], normal = [0, 0, 1]) {
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const ax = scope.register(occtBoundary.makeOcAx2(center, normal));
+    const circleGp = scope.register(new oc.gp_Circ_2(ax, radius));
+    const edgeMaker = scope.register(new oc.BRepBuilderAPI_MakeEdge_8(circleGp));
+    return shapeTypes.createEdge(edgeMaker.Edge());
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function makeEllipse(majorRadius, minorRadius, center = [0, 0, 0], normal = [0, 0, 1], xDir) {
+  var _stack = [];
+  try {
+    if (minorRadius > majorRadius) {
+      return errors.err(
+        errors.validationError("ELLIPSE_RADII", "The minor radius must be smaller than the major one")
+      );
+    }
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const ax = scope.register(occtBoundary.makeOcAx2(center, normal, xDir));
+    const ellipseGp = scope.register(new oc.gp_Elips_2(ax, majorRadius, minorRadius));
+    const edgeMaker = scope.register(new oc.BRepBuilderAPI_MakeEdge_12(ellipseGp));
+    return errors.ok(shapeTypes.createEdge(edgeMaker.Edge()));
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function makeHelix(pitch, height, radius, center = [0, 0, 0], dir = [0, 0, 1], lefthand = false) {
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const angularStep = lefthand ? -2 * Math.PI : 2 * Math.PI;
+    const geomLine = scope.register(
+      new oc.Geom2d_Line_3(
+        scope.register(new oc.gp_Pnt2d_3(0, 0)),
+        scope.register(new oc.gp_Dir2d_4(angularStep, pitch))
+      )
+    );
+    const nTurns = height / pitch;
+    const uStart = scope.register(geomLine.Value(0));
+    const uStop = scope.register(geomLine.Value(nTurns * Math.sqrt((2 * Math.PI) ** 2 + pitch ** 2)));
+    const geomSeg = scope.register(new oc.GCE2d_MakeSegment_1(uStart, uStop));
+    const geomSurf = new oc.Geom_CylindricalSurface_1(scope.register(occtBoundary.makeOcAx3(center, dir)), radius);
+    const e = scope.register(
+      new oc.BRepBuilderAPI_MakeEdge_30(
+        scope.register(new oc.Handle_Geom2d_Curve_2(geomSeg.Value().get())),
+        scope.register(new oc.Handle_Geom_Surface_2(geomSurf))
+      )
+    ).Edge();
+    const w = scope.register(new oc.BRepBuilderAPI_MakeWire_2(e)).Wire();
+    oc.BRepLib.BuildCurves3d_2(w);
+    return shapeTypes.createWire(w);
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function makeThreePointArc(v1, v2, v3) {
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const p1 = scope.register(occtBoundary.toOcPnt(v1));
+    const p2 = scope.register(occtBoundary.toOcPnt(v2));
+    const p3 = scope.register(occtBoundary.toOcPnt(v3));
+    const arcMaker = scope.register(new oc.GC_MakeArcOfCircle_4(p1, p2, p3));
+    const circleGeom = scope.register(arcMaker.Value());
+    const curve = scope.register(new oc.Handle_Geom_Curve_2(circleGeom.get()));
+    const edgeMaker = scope.register(new oc.BRepBuilderAPI_MakeEdge_24(curve));
+    return shapeTypes.createEdge(edgeMaker.Edge());
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function makeEllipseArc(majorRadius, minorRadius, startAngle, endAngle, center = [0, 0, 0], normal = [0, 0, 1], xDir) {
+  var _stack = [];
+  try {
+    if (minorRadius > majorRadius) {
+      return errors.err(
+        errors.validationError("ELLIPSE_RADII", "The minor radius must be smaller than the major one")
+      );
+    }
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const ax = scope.register(occtBoundary.makeOcAx2(center, normal, xDir));
+    const ellipseGp = scope.register(new oc.gp_Elips_2(ax, majorRadius, minorRadius));
+    const edgeMaker = scope.register(
+      new oc.BRepBuilderAPI_MakeEdge_13(ellipseGp, startAngle, endAngle)
+    );
+    return errors.ok(shapeTypes.createEdge(edgeMaker.Edge()));
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function makeBSplineApproximation(points, { tolerance = 1e-3, smoothing = null, degMax = 6, degMin = 1 } = {}) {
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const pnts = scope.register(new oc.TColgp_Array1OfPnt_2(1, points.length));
+    points.forEach((point, index) => {
+      pnts.SetValue(index + 1, scope.register(occtBoundary.toOcPnt(point)));
+    });
+    let splineBuilder;
+    if (smoothing) {
+      splineBuilder = scope.register(
+        new oc.GeomAPI_PointsToBSpline_5(
+          pnts,
+          smoothing[0],
+          smoothing[1],
+          smoothing[2],
+          degMax,
+          oc.GeomAbs_Shape.GeomAbs_C2,
+          tolerance
+        )
+      );
+    } else {
+      splineBuilder = scope.register(
+        new oc.GeomAPI_PointsToBSpline_2(
+          pnts,
+          degMin,
+          degMax,
+          oc.GeomAbs_Shape.GeomAbs_C2,
+          tolerance
+        )
+      );
+    }
+    if (!splineBuilder.IsDone()) {
+      return errors.err(errors.occtError("BSPLINE_FAILED", "B-spline approximation failed"));
+    }
+    const splineGeom = scope.register(splineBuilder.Curve());
+    const curve = scope.register(new oc.Handle_Geom_Curve_2(splineGeom.get()));
+    return errors.ok(shapeTypes.createEdge(new oc.BRepBuilderAPI_MakeEdge_24(curve).Edge()));
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function makeBezierCurve(points) {
+  var _stack = [];
+  try {
+    if (points.length < 2) {
+      return errors.err(
+        errors.validationError(
+          "BEZIER_MIN_POINTS",
+          `Need at least 2 points for a Bezier curve, got ${points.length}`,
+          void 0,
+          {
+            pointCount: points.length
+          }
+        )
+      );
+    }
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const arrayOfPoints = scope.register(new oc.TColgp_Array1OfPnt_2(1, points.length));
+    points.forEach((p, i) => {
+      arrayOfPoints.SetValue(i + 1, scope.register(occtBoundary.toOcPnt(p)));
+    });
+    const bezCurve = new oc.Geom_BezierCurve_1(arrayOfPoints);
+    const curve = scope.register(new oc.Handle_Geom_Curve_2(bezCurve));
+    const edgeMaker = scope.register(new oc.BRepBuilderAPI_MakeEdge_24(curve));
+    return errors.ok(shapeTypes.createEdge(edgeMaker.Edge()));
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function makeTangentArc(startPoint, startTgt, endPoint) {
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const circleGeom = scope.register(
+      new oc.GC_MakeArcOfCircle_5(
+        scope.register(occtBoundary.toOcPnt(startPoint)),
+        scope.register(occtBoundary.toOcVec(startTgt)),
+        scope.register(occtBoundary.toOcPnt(endPoint))
+      ).Value()
+    );
+    const curve = scope.register(new oc.Handle_Geom_Curve_2(circleGeom.get()));
+    const edgeMaker = scope.register(new oc.BRepBuilderAPI_MakeEdge_24(curve));
+    return shapeTypes.createEdge(edgeMaker.Edge());
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function assembleWire(listOfEdges) {
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const wireBuilder = scope.register(new oc.BRepBuilderAPI_MakeWire_1());
+    listOfEdges.forEach((e) => {
+      if (shapeTypes.isEdge(e)) {
+        wireBuilder.Add_1(e.wrapped);
+      }
+      if (shapeTypes.isWire(e)) {
+        wireBuilder.Add_2(e.wrapped);
+      }
+    });
+    const progress = scope.register(new oc.Message_ProgressRange_1());
+    wireBuilder.Build(progress);
+    const res = wireBuilder.Error();
+    if (res !== oc.BRepBuilderAPI_WireError.BRepBuilderAPI_WireDone) {
+      const errorNames = /* @__PURE__ */ new Map([
+        [oc.BRepBuilderAPI_WireError.BRepBuilderAPI_EmptyWire, "empty wire"],
+        [oc.BRepBuilderAPI_WireError.BRepBuilderAPI_NonManifoldWire, "non manifold wire"],
+        [oc.BRepBuilderAPI_WireError.BRepBuilderAPI_DisconnectedWire, "disconnected wire"]
+      ]);
+      return errors.err(
+        errors.occtError(
+          "WIRE_BUILD_FAILED",
+          `Failed to build the wire, ${errorNames.get(res) || "unknown error"}`
+        )
+      );
+    }
+    return errors.ok(shapeTypes.createWire(wireBuilder.Wire()));
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function makeFace(wire, holes) {
+  const oc = occtBoundary.getKernel().oc;
+  const faceBuilder = new oc.BRepBuilderAPI_MakeFace_15(wire.wrapped, false);
+  holes?.forEach((hole) => {
+    faceBuilder.Add(hole.wrapped);
+  });
+  if (!faceBuilder.IsDone()) {
+    faceBuilder.delete();
+    return errors.err(
+      errors.occtError("FACE_BUILD_FAILED", "Failed to build the face. Your wire might be non planar.")
+    );
+  }
+  const face = faceBuilder.Face();
+  faceBuilder.delete();
+  return errors.ok(shapeTypes.createFace(face));
+}
+function fill(face) {
+  const outer = faceFns.outerWire(face);
+  return makeFace(outer);
+}
+function makeNewFaceWithinFace(originFace, wire) {
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const surface = scope.register(oc.BRep_Tool.Surface_2(originFace.wrapped));
+    const faceBuilder = scope.register(
+      new oc.BRepBuilderAPI_MakeFace_21(surface, wire.wrapped, true)
+    );
+    const face = faceBuilder.Face();
+    return shapeTypes.createFace(face);
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function makeNonPlanarFace(wire) {
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const faceBuilder = scope.register(
+      new oc.BRepOffsetAPI_MakeFilling(3, 15, 2, false, 1e-5, 1e-4, 0.01, 0.1, 8, 9)
+    );
+    shapeFns.getEdges(wire).forEach((edge) => {
+      faceBuilder.Add_1(
+        edge.wrapped,
+        oc.GeomAbs_Shape.GeomAbs_C0,
+        true
+      );
+    });
+    const progress = scope.register(new oc.Message_ProgressRange_1());
+    faceBuilder.Build(progress);
+    return errors.andThen(faceFns.cast(faceBuilder.Shape()), (newFace) => {
+      if (!shapeTypes.isFace(newFace)) {
+        return errors.err(errors.occtError("FACE_BUILD_FAILED", "Failed to create a face"));
+      }
+      return errors.ok(newFace);
+    });
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function addHolesInFace(face, holes) {
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const faceMaker = scope.register(new oc.BRepBuilderAPI_MakeFace_2(face.wrapped));
+    holes.forEach((wire) => {
+      faceMaker.Add(wire.wrapped);
+    });
+    const builtFace = scope.register(faceMaker.Face());
+    const fixer = scope.register(new oc.ShapeFix_Face_2(builtFace));
+    fixer.FixOrientation_1();
+    const newFace = fixer.Face();
+    return shapeTypes.createFace(newFace);
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function makePolygon(points) {
+  if (points.length < 3)
+    return errors.err(
+      errors.validationError("POLYGON_MIN_POINTS", "You need at least 3 points to make a polygon")
+    );
+  const edges = zip([points, [...points.slice(1), points[0]]]).map(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- zip returns untyped pairs
+    ([p1, p2]) => makeLine(p1, p2)
+  );
+  return errors.andThen(assembleWire(edges), (wire) => makeFace(wire));
+}
+exports.addHolesInFace = addHolesInFace;
+exports.assembleWire = assembleWire;
+exports.fill = fill;
+exports.makeBSplineApproximation = makeBSplineApproximation;
+exports.makeBezierCurve = makeBezierCurve;
+exports.makeCircle = makeCircle;
+exports.makeEllipse = makeEllipse;
+exports.makeEllipseArc = makeEllipseArc;
+exports.makeFace = makeFace;
+exports.makeHelix = makeHelix;
+exports.makeLine = makeLine;
+exports.makeNewFaceWithinFace = makeNewFaceWithinFace;
+exports.makeNonPlanarFace = makeNonPlanarFace;
+exports.makePolygon = makePolygon;
+exports.makeTangentArc = makeTangentArc;
+exports.makeThreePointArc = makeThreePointArc;
+exports.zip = zip;