brepjs 8.0.1 → 8.0.3

package/dist/loft-jIkZRqHm.js

@@ -0,0 +1,373 @@
+import { g as getKernel, b as toOcPnt, m as makeOcAx2, e as makeOcAx1, a as toVec3 } from "./occtBoundary-DYsksDtE.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 "./cast-BEg1mN7n.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-wGhcJMpB.js";
+import { p as gcWithScope, j as isShell, q as createCompound, r as createVertex, s as createSolid, h as isShape3D, k as isSolid, t as localGC } from "./shapeTypes-i7VwMRwc.js";
+import { m as makeLine, a as assembleWire, b as makeHelix } from "./curveBuilders-U26XDfxg.js";
+function buildLawFromProfile(extrusionLength, { profile, endFactor = 1 }) {
+  const oc = getKernel().oc;
+  const r = 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 err(
+      validationError("UNSUPPORTED_PROFILE", `Unsupported extrusion profile: ${String(profile)}`)
+    );
+  }
+  return ok(law.Trim(0, extrusionLength, 1e-6));
+}
+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]) {
+  const oc = getKernel().oc;
+  const r = gcWithScope();
+  const axis = r(makeOcAx2(location, direction));
+  const cylinder = r(new oc.BRepPrimAPI_MakeCylinder_3(axis, radius, height));
+  return createSolid(cylinder.Shape());
+}
+function makeSphere(radius) {
+  const oc = getKernel().oc;
+  const r = gcWithScope();
+  const sphereMaker = r(new oc.BRepPrimAPI_MakeSphere_1(radius));
+  return createSolid(sphereMaker.Shape());
+}
+function makeCone(radius1, radius2, height, location = [0, 0, 0], direction = [0, 0, 1]) {
+  const oc = getKernel().oc;
+  const r = gcWithScope();
+  const axis = r(makeOcAx2(location, direction));
+  const coneMaker = r(new oc.BRepPrimAPI_MakeCone_3(axis, radius1, radius2, height));
+  return createSolid(coneMaker.Shape());
+}
+function makeTorus(majorRadius, minorRadius, location = [0, 0, 0], direction = [0, 0, 1]) {
+  const oc = getKernel().oc;
+  const r = gcWithScope();
+  const axis = r(makeOcAx2(location, direction));
+  const torusMaker = r(new oc.BRepPrimAPI_MakeTorus_5(axis, majorRadius, minorRadius));
+  return createSolid(torusMaker.Shape());
+}
+function makeEllipsoidTransform(x, y, z) {
+  const oc = getKernel().oc;
+  const r = gcWithScope();
+  const xyRatio = Math.sqrt(x * y / z);
+  const xzRatio = x / xyRatio;
+  const yzRatio = y / xyRatio;
+  const ax1 = r(makeOcAx1([0, 0, 0], [0, 1, 0]));
+  const ax2 = r(makeOcAx1([0, 0, 0], [0, 0, 1]));
+  const ax3 = r(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 = 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 = getKernel().oc;
+  const r = 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 = unwrap(
+      cast(r(new oc.BRepBuilderAPI_MakeShell_2(baseSurface.UReversed(), false)).Shell())
+    );
+    return unwrap(makeSolid([shell]));
+  } finally {
+    baseSurface.delete();
+  }
+}
+function makeVertex(point) {
+  const oc = getKernel().oc;
+  const r = gcWithScope();
+  const pnt = r(toOcPnt(point));
+  const vertexMaker = r(new oc.BRepBuilderAPI_MakeVertex(pnt));
+  return createVertex(vertexMaker.Vertex());
+}
+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) {
+  const r = gcWithScope();
+  const oc = getKernel().oc;
+  const shell = weldShapes(facesOrShells);
+  return andThen(cast(r(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);
+  });
+}
+const basicFaceExtrusion = (face, extrusionVec) => {
+  const oc = getKernel().oc;
+  const [r, gc] = localGC();
+  const vec = 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 = createSolid(unwrap(downcast(solidBuilder.Shape())));
+  gc();
+  return solid;
+};
+const revolution = (face, center = [0, 0, 0], direction = [0, 0, 1], angle = 360) => {
+  const oc = getKernel().oc;
+  const [r, gc] = localGC();
+  const centerVec = toVec3(center);
+  const directionVec = toVec3(direction);
+  const ax = r(makeOcAx1(centerVec, directionVec));
+  const revolBuilder = r(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);
+  });
+  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 = 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 [r, gc] = 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 err(occtError("SWEEP_FAILED", "Sweep operation failed"));
+  }
+  if (!shellMode) {
+    sweepBuilder.MakeSolid();
+  }
+  const shape = unwrap(cast(sweepBuilder.Shape()));
+  if (!isShape3D$1(shape)) {
+    gc();
+    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)) {
+      gc();
+      return err(typeCastError("SWEEP_START_NOT_WIRE", "Sweep did not produce a start Wire"));
+    }
+    if (!isWire(endWire)) {
+      gc();
+      return err(typeCastError("SWEEP_END_NOT_WIRE", "Sweep did not produce an end Wire"));
+    }
+    gc();
+    return ok([shape, startWire, endWire]);
+  }
+  gc();
+  return ok(shape);
+}
+function complexExtrude(wire, center, normal, profileShape, shellMode = false) {
+  const [r, gc] = localGC();
+  const centerVec = toVec3(center);
+  const normalVec = toVec3(normal);
+  const endVec = vecAdd(centerVec, normalVec);
+  const mainSpineEdge = r(makeLine(centerVec, endVec));
+  const spine = r(unwrap(assembleWire([mainSpineEdge])));
+  const law = profileShape ? r(unwrap(buildLawFromProfile(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] = localGC();
+  const centerVec = toVec3(center);
+  const normalVec = toVec3(normal);
+  const endVec = vecAdd(centerVec, normalVec);
+  const mainSpineEdge = r(makeLine(centerVec, endVec));
+  const spine = r(unwrap(assembleWire([mainSpineEdge])));
+  const extrusionLength = vecLength(normalVec);
+  const pitch = 360 / angleDegrees * extrusionLength;
+  const radius = 1;
+  const auxiliarySpine = r(makeHelix(pitch, extrusionLength, radius, centerVec, normalVec));
+  const law = profileShape ? r(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 err(validationError("LOFT_EMPTY", "Loft requires at least one wire or start/end point"));
+  }
+  const oc = getKernel().oc;
+  const [r, gc] = localGC();
+  const loftBuilder = r(new oc.BRepOffsetAPI_ThruSections(!returnShell, ruled, 1e-6));
+  if (startPoint) {
+    loftBuilder.AddVertex(r(makeVertex(toVec3(startPoint))).wrapped);
+  }
+  wires.forEach((w) => loftBuilder.AddWire(w.wrapped));
+  if (endPoint) {
+    loftBuilder.AddVertex(r(makeVertex(toVec3(endPoint))).wrapped);
+  }
+  const progress = r(new oc.Message_ProgressRange_1());
+  loftBuilder.Build(progress);
+  if (!loftBuilder.IsDone()) {
+    gc();
+    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);
+  });
+  gc();
+  return result;
+};
+export {
+  makeCone as a,
+  makeCylinder as b,
+  makeEllipsoid as c,
+  makeOffset as d,
+  makeSolid as e,
+  makeSphere as f,
+  makeTorus as g,
+  makeVertex as h,
+  basicFaceExtrusion as i,
+  genericSweep as j,
+  complexExtrude as k,
+  loft as l,
+  makeCompound as m,
+  buildLawFromProfile as n,
+  revolution as r,
+  twistExtrude as t,
+  weldShellsAndFaces as w
+};

package/dist/{measurement-C5JGCuUP.js → measurement-DWv8kK6J.js}

@@ -1,6 +1,6 @@
-import { g as getKernel, s as surfaceCurvature } from "./occtBoundary-CwegMzqc.js";
-import { n as gcWithScope } from "./shapeTypes-BlSElW8z.js";
-import { u as uvBounds } from "./faceFns-DHu-2JpA.js";
+import { g as getKernel, s as surfaceCurvature } from "./occtBoundary-DYsksDtE.js";
+import { p as gcWithScope } from "./shapeTypes-i7VwMRwc.js";
+import { u as uvBounds } from "./faceFns-CyokaCDr.js";
 function assertShapeNotNull(shape, fn) {
   if (shape.wrapped.IsNull()) {
     throw new Error(`${fn}: shape is a null shape`);

package/dist/{measurement-fxm_pW7x.cjs → measurement-lRLwaoqD.cjs}

@@ -1,7 +1,7 @@
 "use strict";
-const occtBoundary = require("./occtBoundary-du8_ex-p.cjs");
-const shapeTypes = require("./shapeTypes-DKhwEnUM.cjs");
-const faceFns = require("./faceFns-BwK7FP7N.cjs");
+const occtBoundary = require("./occtBoundary-DHtzU4tz.cjs");
+const shapeTypes = require("./shapeTypes-b_lhwQB7.cjs");
+const faceFns = require("./faceFns-DcSCjDG0.cjs");
 function assertShapeNotNull(shape, fn) {
   if (shape.wrapped.IsNull()) {
     throw new Error(`${fn}: shape is a null shape`);

package/dist/measurement.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const measurement = require("./measurement-fxm_pW7x.cjs");
+const measurement = require("./measurement-lRLwaoqD.cjs");
 exports.createDistanceQuery = measurement.createDistanceQuery;
 exports.measureArea = measurement.measureArea;
 exports.measureDistance = measurement.measureDistance;

package/dist/measurement.js

@@ -1,4 +1,4 @@
-import { d, m, g, h, i, a, c, b } from "./measurement-C5JGCuUP.js";
+import { d, m, g, h, i, a, c, b } from "./measurement-DWv8kK6J.js";
 export {
   d as createDistanceQuery,
   m as measureArea,

package/dist/{meshFns-BhrZGi6w.cjs → meshFns-DWuLC3fk.cjs}

@@ -1,5 +1,5 @@
 "use strict";
-const occtBoundary = require("./occtBoundary-du8_ex-p.cjs");
+const occtBoundary = require("./occtBoundary-DHtzU4tz.cjs");
 const errors = require("./errors-DK1VAdP4.cjs");
 function buildMeshCacheKey(tolerance, angularTolerance, skipNormals) {
   return `${tolerance}:${angularTolerance}:${skipNormals}`;
@@ -71,6 +71,24 @@ function createMeshCache() {
     }
   };
 }
+function shapeHasTriangulation(oc, shape) {
+  const explorer = new oc.TopExp_Explorer_2(
+    shape,
+    oc.TopAbs_ShapeEnum.TopAbs_FACE,
+    oc.TopAbs_ShapeEnum.TopAbs_SHAPE
+  );
+  let hasTri = false;
+  if (explorer.More()) {
+    const face = oc.TopoDS.Face_1(explorer.Current());
+    const loc = new oc.TopLoc_Location_1();
+    const tri = oc.BRep_Tool.Triangulation(face, loc, 0);
+    hasTri = !tri.IsNull();
+    loc.delete();
+    tri.delete();
+  }
+  explorer.delete();
+  return hasTri;
+}
 function mesh(shape, {
   tolerance = 1e-3,
   angularTolerance = 0.1,
@@ -159,14 +177,16 @@ function exportSTL(shape, {
   binary = false
 } = {}) {
   const oc = occtBoundary.getKernel().oc;
-  const mesher = new oc.BRepMesh_IncrementalMesh_2(
-    shape.wrapped,
-    tolerance,
-    false,
-    angularTolerance,
-    false
-  );
-  mesher.delete();
+  if (!shapeHasTriangulation(oc, shape.wrapped)) {
+    const mesher = new oc.BRepMesh_IncrementalMesh_2(
+      shape.wrapped,
+      tolerance,
+      false,
+      angularTolerance,
+      false
+    );
+    mesher.delete();
+  }
   const filename = occtBoundary.uniqueIOFilename("_blob", "stl");
   const done = oc.StlAPI.Write(shape.wrapped, filename, !binary);
   if (done) {

package/dist/{meshFns-AqAjTTVl.js → meshFns-DgAIL1B-.js}

@@ -1,4 +1,4 @@
-import { g as getKernel, u as uniqueIOFilename } from "./occtBoundary-CwegMzqc.js";
+import { g as getKernel, u as uniqueIOFilename } from "./occtBoundary-DYsksDtE.js";
 import { l as ok, e as err, i as ioError } from "./errors-wGhcJMpB.js";
 function buildMeshCacheKey(tolerance, angularTolerance, skipNormals) {
   return `${tolerance}:${angularTolerance}:${skipNormals}`;
@@ -70,6 +70,24 @@ function createMeshCache() {
     }
   };
 }
+function shapeHasTriangulation(oc, shape) {
+  const explorer = new oc.TopExp_Explorer_2(
+    shape,
+    oc.TopAbs_ShapeEnum.TopAbs_FACE,
+    oc.TopAbs_ShapeEnum.TopAbs_SHAPE
+  );
+  let hasTri = false;
+  if (explorer.More()) {
+    const face = oc.TopoDS.Face_1(explorer.Current());
+    const loc = new oc.TopLoc_Location_1();
+    const tri = oc.BRep_Tool.Triangulation(face, loc, 0);
+    hasTri = !tri.IsNull();
+    loc.delete();
+    tri.delete();
+  }
+  explorer.delete();
+  return hasTri;
+}
 function mesh(shape, {
   tolerance = 1e-3,
   angularTolerance = 0.1,
@@ -158,14 +176,16 @@ function exportSTL(shape, {
   binary = false
 } = {}) {
   const oc = getKernel().oc;
-  const mesher = new oc.BRepMesh_IncrementalMesh_2(
-    shape.wrapped,
-    tolerance,
-    false,
-    angularTolerance,
-    false
-  );
-  mesher.delete();
+  if (!shapeHasTriangulation(oc, shape.wrapped)) {
+    const mesher = new oc.BRepMesh_IncrementalMesh_2(
+      shape.wrapped,
+      tolerance,
+      false,
+      angularTolerance,
+      false
+    );
+    mesher.delete();
+  }
   const filename = uniqueIOFilename("_blob", "stl");
   const done = oc.StlAPI.Write(shape.wrapped, filename, !binary);
   if (done) {