brepjs 8.0.1 → 8.0.3

package/dist/loft-8asn63t4.cjs

@@ -0,0 +1,372 @@
+"use strict";
+const occtBoundary = require("./occtBoundary-DHtzU4tz.cjs");
+const vecOps = require("./vecOps-CjRL1jau.cjs");
+const cast = require("./cast-CqDc8oFW.cjs");
+const errors = require("./errors-DK1VAdP4.cjs");
+const shapeTypes = require("./shapeTypes-b_lhwQB7.cjs");
+const curveBuilders = require("./curveBuilders-BjtdNw1B.cjs");
+function buildLawFromProfile(extrusionLength, { profile, endFactor = 1 }) {
+  const oc = occtBoundary.getKernel().oc;
+  const r = shapeTypes.gcWithScope();
+  let law;
+  if (profile === "s-curve") {
+    law = r(new oc.Law_S());
+    law.Set_1(0, 1, extrusionLength, endFactor);
+  } else if (profile === "linear") {
+    law = r(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));
+}
+function weldShapes(facesOrShells) {
+  const sewn = occtBoundary.getKernel().sew(facesOrShells.map((s) => s.wrapped));
+  return errors.unwrap(cast.cast(errors.unwrap(cast.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]) {
+  const oc = occtBoundary.getKernel().oc;
+  const r = shapeTypes.gcWithScope();
+  const axis = r(occtBoundary.makeOcAx2(location, direction));
+  const cylinder = r(new oc.BRepPrimAPI_MakeCylinder_3(axis, radius, height));
+  return shapeTypes.createSolid(cylinder.Shape());
+}
+function makeSphere(radius) {
+  const oc = occtBoundary.getKernel().oc;
+  const r = shapeTypes.gcWithScope();
+  const sphereMaker = r(new oc.BRepPrimAPI_MakeSphere_1(radius));
+  return shapeTypes.createSolid(sphereMaker.Shape());
+}
+function makeCone(radius1, radius2, height, location = [0, 0, 0], direction = [0, 0, 1]) {
+  const oc = occtBoundary.getKernel().oc;
+  const r = shapeTypes.gcWithScope();
+  const axis = r(occtBoundary.makeOcAx2(location, direction));
+  const coneMaker = r(new oc.BRepPrimAPI_MakeCone_3(axis, radius1, radius2, height));
+  return shapeTypes.createSolid(coneMaker.Shape());
+}
+function makeTorus(majorRadius, minorRadius, location = [0, 0, 0], direction = [0, 0, 1]) {
+  const oc = occtBoundary.getKernel().oc;
+  const r = shapeTypes.gcWithScope();
+  const axis = r(occtBoundary.makeOcAx2(location, direction));
+  const torusMaker = r(new oc.BRepPrimAPI_MakeTorus_5(axis, majorRadius, minorRadius));
+  return shapeTypes.createSolid(torusMaker.Shape());
+}
+function makeEllipsoidTransform(x, y, z) {
+  const oc = occtBoundary.getKernel().oc;
+  const r = shapeTypes.gcWithScope();
+  const xyRatio = Math.sqrt(x * y / z);
+  const xzRatio = x / xyRatio;
+  const yzRatio = y / xyRatio;
+  const ax1 = r(occtBoundary.makeOcAx1([0, 0, 0], [0, 1, 0]));
+  const ax2 = r(occtBoundary.makeOcAx1([0, 0, 0], [0, 0, 1]));
+  const ax3 = r(occtBoundary.makeOcAx1([0, 0, 0], [1, 0, 0]));
+  const transform = new oc.gp_GTrsf_1();
+  transform.SetAffinity_1(ax1, xzRatio);
+  const xy = r(new oc.gp_GTrsf_1());
+  xy.SetAffinity_1(ax2, xyRatio);
+  const yz = r(new oc.gp_GTrsf_1());
+  yz.SetAffinity_1(ax3, yzRatio);
+  transform.Multiply(xy);
+  transform.Multiply(yz);
+  return {
+    transform,
+    applyToPoint(p) {
+      const r2 = shapeTypes.gcWithScope();
+      const coords = r2(p.XYZ());
+      transform.Transforms_1(coords);
+      return new oc.gp_Pnt_2(coords);
+    }
+  };
+}
+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) {
+  const oc = occtBoundary.getKernel().oc;
+  const r = shapeTypes.gcWithScope();
+  const sphere = r(new oc.gp_Sphere_1());
+  sphere.SetRadius(1);
+  const sphericalSurface = r(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(
+      cast.cast(r(new oc.BRepBuilderAPI_MakeShell_2(baseSurface.UReversed(), false)).Shell())
+    );
+    return errors.unwrap(makeSolid([shell]));
+  } finally {
+    baseSurface.delete();
+  }
+}
+function makeVertex(point) {
+  const oc = occtBoundary.getKernel().oc;
+  const r = shapeTypes.gcWithScope();
+  const pnt = r(occtBoundary.toOcPnt(point));
+  const vertexMaker = r(new oc.BRepBuilderAPI_MakeVertex(pnt));
+  return shapeTypes.createVertex(vertexMaker.Vertex());
+}
+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(
+      cast.downcast(offsetBuilder.Shape()),
+      (downcasted) => errors.andThen(cast.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) {
+  const r = shapeTypes.gcWithScope();
+  const oc = occtBoundary.getKernel().oc;
+  const shell = weldShapes(facesOrShells);
+  return errors.andThen(cast.cast(r(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);
+  });
+}
+const basicFaceExtrusion = (face, extrusionVec) => {
+  const oc = occtBoundary.getKernel().oc;
+  const [r, gc] = shapeTypes.localGC();
+  const vec = occtBoundary.toVec3(extrusionVec);
+  const ocVec = r(new oc.gp_Vec_4(vec[0], vec[1], vec[2]));
+  const solidBuilder = r(new oc.BRepPrimAPI_MakePrism_1(face.wrapped, ocVec, false, true));
+  const solid = shapeTypes.createSolid(errors.unwrap(cast.downcast(solidBuilder.Shape())));
+  gc();
+  return solid;
+};
+const revolution = (face, center = [0, 0, 0], direction = [0, 0, 1], angle = 360) => {
+  const oc = occtBoundary.getKernel().oc;
+  const [r, gc] = shapeTypes.localGC();
+  const centerVec = occtBoundary.toVec3(center);
+  const directionVec = occtBoundary.toVec3(direction);
+  const ax = r(occtBoundary.makeOcAx1(centerVec, directionVec));
+  const revolBuilder = r(new oc.BRepPrimAPI_MakeRevol_1(face.wrapped, ax, angle * vecOps.DEG2RAD, false));
+  const result = errors.andThen(cast.cast(revolBuilder.Shape()), (shape) => {
+    if (!cast.isShape3D(shape))
+      return errors.err(errors.typeCastError("REVOLUTION_NOT_3D", "Revolution did not produce a 3D shape"));
+    return errors.ok(shape);
+  });
+  gc();
+  return result;
+};
+function genericSweep(wire, spine, {
+  frenet = false,
+  auxiliarySpine,
+  law = null,
+  transitionMode = "right",
+  withContact,
+  support,
+  forceProfileSpineOthogonality,
+  mode: sweepMode,
+  tolerance,
+  boundTolerance,
+  angularTolerance,
+  maxDegree,
+  maxSegments
+} = {}, shellMode = false) {
+  if (sweepMode === "simple" && !shellMode) {
+    const kernel = occtBoundary.getKernel();
+    const resultOc = kernel.simplePipe(wire.wrapped, spine.wrapped);
+    const result = errors.andThen(cast.cast(resultOc), (shape2) => {
+      if (!cast.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 [r, gc] = shapeTypes.localGC();
+  const withCorrection = transitionMode === "round" ? true : !!forceProfileSpineOthogonality;
+  const sweepBuilder = r(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 = r(new oc.Message_ProgressRange_1());
+  sweepBuilder.Build(progress);
+  if (!sweepBuilder.IsDone()) {
+    gc();
+    return errors.err(errors.occtError("SWEEP_FAILED", "Sweep operation failed"));
+  }
+  if (!shellMode) {
+    sweepBuilder.MakeSolid();
+  }
+  const shape = errors.unwrap(cast.cast(sweepBuilder.Shape()));
+  if (!cast.isShape3D(shape)) {
+    gc();
+    return errors.err(errors.typeCastError("SWEEP_NOT_3D", "Sweep did not produce a 3D shape"));
+  }
+  if (shellMode) {
+    const startWire = errors.unwrap(cast.cast(sweepBuilder.FirstShape()));
+    const endWire = errors.unwrap(cast.cast(sweepBuilder.LastShape()));
+    if (!cast.isWire(startWire)) {
+      gc();
+      return errors.err(errors.typeCastError("SWEEP_START_NOT_WIRE", "Sweep did not produce a start Wire"));
+    }
+    if (!cast.isWire(endWire)) {
+      gc();
+      return errors.err(errors.typeCastError("SWEEP_END_NOT_WIRE", "Sweep did not produce an end Wire"));
+    }
+    gc();
+    return errors.ok([shape, startWire, endWire]);
+  }
+  gc();
+  return errors.ok(shape);
+}
+function complexExtrude(wire, center, normal, profileShape, shellMode = false) {
+  const [r, gc] = shapeTypes.localGC();
+  const centerVec = occtBoundary.toVec3(center);
+  const normalVec = occtBoundary.toVec3(normal);
+  const endVec = vecOps.vecAdd(centerVec, normalVec);
+  const mainSpineEdge = r(curveBuilders.makeLine(centerVec, endVec));
+  const spine = r(errors.unwrap(curveBuilders.assembleWire([mainSpineEdge])));
+  const law = profileShape ? r(errors.unwrap(buildLawFromProfile(vecOps.vecLength(normalVec), profileShape))) : null;
+  const result = shellMode ? genericSweep(wire, spine, { law }, shellMode) : genericSweep(wire, spine, { law }, shellMode);
+  gc();
+  return result;
+}
+function twistExtrude(wire, angleDegrees, center, normal, profileShape, shellMode = false) {
+  const [r, gc] = shapeTypes.localGC();
+  const centerVec = occtBoundary.toVec3(center);
+  const normalVec = occtBoundary.toVec3(normal);
+  const endVec = vecOps.vecAdd(centerVec, normalVec);
+  const mainSpineEdge = r(curveBuilders.makeLine(centerVec, endVec));
+  const spine = r(errors.unwrap(curveBuilders.assembleWire([mainSpineEdge])));
+  const extrusionLength = vecOps.vecLength(normalVec);
+  const pitch = 360 / angleDegrees * extrusionLength;
+  const radius = 1;
+  const auxiliarySpine = r(curveBuilders.makeHelix(pitch, extrusionLength, radius, centerVec, normalVec));
+  const law = profileShape ? r(errors.unwrap(buildLawFromProfile(extrusionLength, profileShape))) : null;
+  const result = shellMode ? genericSweep(wire, spine, { auxiliarySpine, law }, shellMode) : genericSweep(wire, spine, { auxiliarySpine, law }, shellMode);
+  gc();
+  return result;
+}
+const loft = (wires, { ruled = true, startPoint, endPoint } = {}, returnShell = false) => {
+  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 [r, gc] = shapeTypes.localGC();
+  const loftBuilder = r(new oc.BRepOffsetAPI_ThruSections(!returnShell, ruled, 1e-6));
+  if (startPoint) {
+    loftBuilder.AddVertex(r(makeVertex(occtBoundary.toVec3(startPoint))).wrapped);
+  }
+  wires.forEach((w) => loftBuilder.AddWire(w.wrapped));
+  if (endPoint) {
+    loftBuilder.AddVertex(r(makeVertex(occtBoundary.toVec3(endPoint))).wrapped);
+  }
+  const progress = r(new oc.Message_ProgressRange_1());
+  loftBuilder.Build(progress);
+  if (!loftBuilder.IsDone()) {
+    gc();
+    return errors.err(errors.occtError("LOFT_FAILED", "Loft operation failed"));
+  }
+  const result = errors.andThen(cast.cast(loftBuilder.Shape()), (shape) => {
+    if (!cast.isShape3D(shape))
+      return errors.err(errors.typeCastError("LOFT_NOT_3D", "Loft did not produce a 3D shape"));
+    return errors.ok(shape);
+  });
+  gc();
+  return result;
+};
+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;