brepjs 8.2.0 → 8.4.0

package/dist/{occtBoundary-BFAaUtA7.cjs → occtBoundary-CocN2VKx.cjs}

@@ -1042,7 +1042,7 @@ function makeWire(oc, edges) {
   progress.delete();
   return wire;
 }
-function makeFace(oc, wire, planar = true) {
+function makeFace$1(oc, wire, planar = true) {
   if (planar) {
     const builder2 = new oc.BRepBuilderAPI_MakeFace_15(wire, false);
     const face = builder2.Face();
@@ -1441,6 +1441,412 @@ function approximatePoints(oc, points, options = {}) {
   splineBuilder.delete();
   return edge;
 }
+function sub(a, b) {
+  return { x: a.x - b.x, y: a.y - b.y, z: a.z - b.z };
+}
+function cross(a, b) {
+  return {
+    x: a.y * b.z - a.z * b.y,
+    y: a.z * b.x - a.x * b.z,
+    z: a.x * b.y - a.y * b.x
+  };
+}
+function dot(a, b) {
+  return a.x * b.x + a.y * b.y + a.z * b.z;
+}
+function lengthVec(v) {
+  return Math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
+}
+function distSq(a, b) {
+  const dx = a.x - b.x;
+  const dy = a.y - b.y;
+  const dz = a.z - b.z;
+  return dx * dx + dy * dy + dz * dz;
+}
+function at(arr, i) {
+  const v = arr[i];
+  if (v === void 0) throw new Error(`Index ${i} out of bounds`);
+  return v;
+}
+function atN(arr, i) {
+  const v = arr[i];
+  if (v === void 0) throw new Error(`Index ${i} out of bounds`);
+  return v;
+}
+function makeFace(points, a, b, c) {
+  const normal = cross(sub(at(points, b), at(points, a)), sub(at(points, c), at(points, a)));
+  const len = lengthVec(normal);
+  const n = len > 1e-14 ? { x: normal.x / len, y: normal.y / len, z: normal.z / len } : normal;
+  return {
+    a,
+    b,
+    c,
+    normal: n,
+    offset: dot(n, at(points, a)),
+    alive: true,
+    outsidePoints: []
+  };
+}
+function signedDist(face, point) {
+  return dot(face.normal, point) - face.offset;
+}
+function deduplicatePoints(points, tolerance) {
+  const tolSq = tolerance * tolerance;
+  const result = [];
+  for (const p of points) {
+    let isDuplicate = false;
+    for (const q of result) {
+      if (distSq(p, q) < tolSq) {
+        isDuplicate = true;
+        break;
+      }
+    }
+    if (!isDuplicate) result.push(p);
+  }
+  return result;
+}
+function findInitialTetrahedron(points) {
+  const n = points.length;
+  if (n < 4) return null;
+  let i0 = 0;
+  let i1 = 1;
+  let maxDist = distSq(at(points, 0), at(points, 1));
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      const d = distSq(at(points, i), at(points, j));
+      if (d > maxDist) {
+        maxDist = d;
+        i0 = i;
+        i1 = j;
+      }
+    }
+  }
+  if (maxDist < 1e-20) return null;
+  const lineDir = sub(at(points, i1), at(points, i0));
+  let i2 = -1;
+  let maxLineDist = -1;
+  for (let i = 0; i < n; i++) {
+    if (i === i0 || i === i1) continue;
+    const v = sub(at(points, i), at(points, i0));
+    const c = cross(lineDir, v);
+    const d = dot(c, c);
+    if (d > maxLineDist) {
+      maxLineDist = d;
+      i2 = i;
+    }
+  }
+  if (i2 === -1 || maxLineDist < 1e-20) return null;
+  const planeNormal = cross(
+    sub(at(points, i1), at(points, i0)),
+    sub(at(points, i2), at(points, i0))
+  );
+  const planeLen = lengthVec(planeNormal);
+  if (planeLen < 1e-14) return null;
+  const pn = {
+    x: planeNormal.x / planeLen,
+    y: planeNormal.y / planeLen,
+    z: planeNormal.z / planeLen
+  };
+  const planeOffset = dot(pn, at(points, i0));
+  let i3 = -1;
+  let maxPlaneDist = -1;
+  for (let i = 0; i < n; i++) {
+    if (i === i0 || i === i1 || i === i2) continue;
+    const d = Math.abs(dot(pn, at(points, i)) - planeOffset);
+    if (d > maxPlaneDist) {
+      maxPlaneDist = d;
+      i3 = i;
+    }
+  }
+  if (i3 === -1 || maxPlaneDist < 1e-14) return null;
+  const sd = dot(pn, at(points, i3)) - planeOffset;
+  if (sd > 0) {
+    return [i0, i2, i1, i3];
+  }
+  return [i0, i1, i2, i3];
+}
+function quickHull(inputPoints, tolerance) {
+  const points = deduplicatePoints(inputPoints, tolerance);
+  if (points.length < 4) {
+    throw new Error(
+      points.length === 0 ? "No points provided for convex hull" : "Fewer than 4 non-coincident points; cannot form a 3D convex hull"
+    );
+  }
+  const tet = findInitialTetrahedron(points);
+  if (tet === null) {
+    throw new Error("All points are coplanar; cannot form a 3D convex hull");
+  }
+  const [t0, t1, t2, t3] = tet;
+  const centroid = {
+    x: (at(points, t0).x + at(points, t1).x + at(points, t2).x + at(points, t3).x) / 4,
+    y: (at(points, t0).y + at(points, t1).y + at(points, t2).y + at(points, t3).y) / 4,
+    z: (at(points, t0).z + at(points, t1).z + at(points, t2).z + at(points, t3).z) / 4
+  };
+  function makeOutwardFace(a, b, c) {
+    const face = makeFace(points, a, b, c);
+    const faceCenter = {
+      x: (at(points, a).x + at(points, b).x + at(points, c).x) / 3,
+      y: (at(points, a).y + at(points, b).y + at(points, c).y) / 3,
+      z: (at(points, a).z + at(points, b).z + at(points, c).z) / 3
+    };
+    const toCentroid = sub(centroid, faceCenter);
+    if (dot(face.normal, toCentroid) > 0) {
+      return makeFace(points, a, c, b);
+    }
+    return face;
+  }
+  const faces = [
+    makeOutwardFace(t0, t1, t2),
+    makeOutwardFace(t0, t2, t3),
+    makeOutwardFace(t0, t3, t1),
+    makeOutwardFace(t1, t3, t2)
+  ];
+  const tetSet = /* @__PURE__ */ new Set([t0, t1, t2, t3]);
+  const epsilon = 1e-10;
+  for (let i = 0; i < points.length; i++) {
+    if (tetSet.has(i)) continue;
+    for (const face of faces) {
+      if (signedDist(face, at(points, i)) > epsilon) {
+        face.outsidePoints.push(i);
+        break;
+      }
+    }
+  }
+  for (let iteration = 0; iteration < points.length * 4; iteration++) {
+    let currentFace = null;
+    for (const face of faces) {
+      if (face.alive && face.outsidePoints.length > 0) {
+        currentFace = face;
+        break;
+      }
+    }
+    if (currentFace === null) break;
+    let furthestIdx = atN(currentFace.outsidePoints, 0);
+    let furthestDist = signedDist(currentFace, at(points, furthestIdx));
+    for (let i = 1; i < currentFace.outsidePoints.length; i++) {
+      const idx = atN(currentFace.outsidePoints, i);
+      const d = signedDist(currentFace, at(points, idx));
+      if (d > furthestDist) {
+        furthestDist = d;
+        furthestIdx = idx;
+      }
+    }
+    const visibleFaces = [];
+    for (const face of faces) {
+      if (face.alive && signedDist(face, at(points, furthestIdx)) > epsilon) {
+        visibleFaces.push(face);
+      }
+    }
+    const edgeCount = /* @__PURE__ */ new Map();
+    for (const face of visibleFaces) {
+      const edges = [
+        [face.a, face.b],
+        [face.b, face.c],
+        [face.c, face.a]
+      ];
+      for (const [ea, eb] of edges) {
+        const key = ea < eb ? `${ea}-${eb}` : `${eb}-${ea}`;
+        const entry = edgeCount.get(key);
+        if (entry) {
+          entry.count++;
+        } else {
+          edgeCount.set(key, { a: ea, b: eb, count: 1 });
+        }
+      }
+    }
+    const horizonEdges = [];
+    for (const entry of edgeCount.values()) {
+      if (entry.count === 1) {
+        horizonEdges.push({ a: entry.a, b: entry.b });
+      }
+    }
+    const orphanedPoints = [];
+    for (const face of visibleFaces) {
+      for (const idx of face.outsidePoints) {
+        if (idx !== furthestIdx) {
+          orphanedPoints.push(idx);
+        }
+      }
+      face.alive = false;
+      face.outsidePoints = [];
+    }
+    const newFaces = [];
+    for (const edge of horizonEdges) {
+      const newFaceObj = makeFace(points, edge.a, edge.b, furthestIdx);
+      newFaces.push(newFaceObj);
+      faces.push(newFaceObj);
+    }
+    for (const idx of orphanedPoints) {
+      for (const face of newFaces) {
+        if (signedDist(face, at(points, idx)) > epsilon) {
+          face.outsidePoints.push(idx);
+          break;
+        }
+      }
+    }
+  }
+  const resultFaces = [];
+  for (const face of faces) {
+    if (face.alive) {
+      resultFaces.push([face.a, face.b, face.c]);
+    }
+  }
+  return { faces: resultFaces, points };
+}
+function extractVertices(oc, shapes, tolerance) {
+  const vertices = [];
+  const meshDeflection = Math.max(tolerance, 1);
+  for (const shape of shapes) {
+    const mesh2 = new oc.BRepMesh_IncrementalMesh_2(
+      shape,
+      meshDeflection,
+      false,
+      meshDeflection * 0.5,
+      false
+    );
+    const progress = new oc.Message_ProgressRange_1();
+    mesh2.Perform(progress);
+    progress.delete();
+    mesh2.delete();
+    const explorer = new oc.TopExp_Explorer_2(
+      shape,
+      oc.TopAbs_ShapeEnum.TopAbs_FACE,
+      oc.TopAbs_ShapeEnum.TopAbs_SHAPE
+    );
+    while (explorer.More()) {
+      const face = oc.TopoDS.Face_1(explorer.Current());
+      const location = new oc.TopLoc_Location_1();
+      const tri = oc.BRep_Tool.Triangulation(face, location, 0);
+      if (!tri.IsNull()) {
+        const trsf = location.Transformation();
+        const nbNodes = tri.get().NbNodes();
+        for (let i = 1; i <= nbNodes; i++) {
+          const node = tri.get().Node(i);
+          const transformed = node.Transformed(trsf);
+          vertices.push({
+            x: transformed.X(),
+            y: transformed.Y(),
+            z: transformed.Z()
+          });
+          transformed.delete();
+          node.delete();
+        }
+        trsf.delete();
+      }
+      location.delete();
+      explorer.Next();
+    }
+    explorer.delete();
+  }
+  return vertices;
+}
+function buildTriFace(oc, pa, pb, pc) {
+  const gpA = new oc.gp_Pnt_3(pa.x, pa.y, pa.z);
+  const gpB = new oc.gp_Pnt_3(pb.x, pb.y, pb.z);
+  const gpC = new oc.gp_Pnt_3(pc.x, pc.y, pc.z);
+  const e1 = new oc.BRepBuilderAPI_MakeEdge_3(gpA, gpB);
+  const e2 = new oc.BRepBuilderAPI_MakeEdge_3(gpB, gpC);
+  const e3 = new oc.BRepBuilderAPI_MakeEdge_3(gpC, gpA);
+  const wireBuilder = new oc.BRepBuilderAPI_MakeWire_1();
+  wireBuilder.Add_1(e1.Edge());
+  wireBuilder.Add_1(e2.Edge());
+  wireBuilder.Add_1(e3.Edge());
+  let face = null;
+  if (wireBuilder.IsDone()) {
+    const makeFaceBuilder = new oc.BRepBuilderAPI_MakeFace_15(wireBuilder.Wire(), false);
+    if (makeFaceBuilder.IsDone()) {
+      face = makeFaceBuilder.Face();
+    }
+    makeFaceBuilder.delete();
+  }
+  wireBuilder.delete();
+  e1.delete();
+  e2.delete();
+  e3.delete();
+  gpA.delete();
+  gpB.delete();
+  gpC.delete();
+  return face;
+}
+function reconstructBrep(oc, hullResult, tolerance) {
+  const { faces: hullFaces, points } = hullResult;
+  const ocFaces = [];
+  for (const [ia, ib, ic] of hullFaces) {
+    const face = buildTriFace(oc, at(points, ia), at(points, ib), at(points, ic));
+    if (face !== null) {
+      ocFaces.push(face);
+    }
+  }
+  if (ocFaces.length < 4) {
+    throw new Error(`hull: only ${ocFaces.length} faces built, need at least 4 for a solid`);
+  }
+  const sewTolerance = Math.max(tolerance, 1e-4);
+  const sewing = new oc.BRepBuilderAPI_Sewing(sewTolerance, true, true, true, false);
+  for (const face of ocFaces) {
+    sewing.Add(face);
+  }
+  const sewProgress = new oc.Message_ProgressRange_1();
+  sewing.Perform(sewProgress);
+  sewProgress.delete();
+  const sewn = sewing.SewedShape();
+  sewing.delete();
+  const shellExplorer = new oc.TopExp_Explorer_2(
+    sewn,
+    oc.TopAbs_ShapeEnum.TopAbs_SHELL,
+    oc.TopAbs_ShapeEnum.TopAbs_SHAPE
+  );
+  if (shellExplorer.More()) {
+    const shell2 = oc.TopoDS.Shell_1(shellExplorer.Current());
+    shellExplorer.delete();
+    const solidMaker = new oc.BRepBuilderAPI_MakeSolid_1();
+    solidMaker.Add(shell2);
+    const solidProgress = new oc.Message_ProgressRange_1();
+    solidMaker.Build(solidProgress);
+    solidProgress.delete();
+    if (solidMaker.IsDone()) {
+      const solid = solidMaker.Solid();
+      solidMaker.delete();
+      shell2.delete();
+      const props = new oc.GProp_GProps_1();
+      oc.BRepGProp.VolumeProperties_1(solid, props, false, false, false);
+      const vol = props.Mass();
+      props.delete();
+      if (vol < 0) {
+        solid.Complement();
+      }
+      return solid;
+    }
+    shell2.delete();
+    solidMaker.delete();
+    return sewn;
+  }
+  shellExplorer.delete();
+  return sewn;
+}
+function hull(oc, shapes, tolerance) {
+  if (shapes.length === 0) {
+    throw new Error("hull: no shapes provided");
+  }
+  const vertices = extractVertices(oc, shapes, tolerance);
+  if (vertices.length < 4) {
+    throw new Error("hull: fewer than 4 vertices extracted from input shapes");
+  }
+  const hullResult = quickHull(vertices, tolerance);
+  if (hullResult.faces.length < 4) {
+    throw new Error("hull: degenerate hull (fewer than 4 faces)");
+  }
+  return reconstructBrep(oc, hullResult, tolerance);
+}
+function hullFromPoints(oc, points, tolerance) {
+  if (points.length < 4) {
+    throw new Error("hullFromPoints: fewer than 4 points");
+  }
+  const hullResult = quickHull(points, tolerance);
+  if (hullResult.faces.length < 4) {
+    throw new Error("hullFromPoints: degenerate hull (fewer than 4 faces)");
+  }
+  return reconstructBrep(oc, hullResult, tolerance);
+}
 class OCCTAdapter {
   oc;
   constructor(oc) {
@@ -1465,6 +1871,17 @@ class OCCTAdapter {
   cutAll(shape, tools, options = {}) {
     return cutAll(this.oc, shape, tools, options);
   }
+  // --- Convex hull ---
+  hull(shapes, tolerance) {
+    return hull(this.oc, shapes, tolerance);
+  }
+  hullFromPoints(points, tolerance) {
+    return hullFromPoints(
+      this.oc,
+      points.map((p) => ({ x: p.x, y: p.y, z: p.z })),
+      tolerance
+    );
+  }
   // --- Shape construction (delegates to constructorOps.ts) ---
   makeVertex(x, y, z) {
     return makeVertex(this.oc, x, y, z);
@@ -1476,7 +1893,7 @@ class OCCTAdapter {
     return makeWire(this.oc, edges);
   }
   makeFace(wire, planar = true) {
-    return makeFace(this.oc, wire, planar);
+    return makeFace$1(this.oc, wire, planar);
   }
   makeBox(width, height, depth) {
     return makeBox(this.oc, width, height, depth);