brepjs 8.0.2 → 8.0.3

package/dist/curveFns-BoG_iA07.cjs

@@ -0,0 +1,375 @@
+"use strict";
+const occtBoundary = require("./occtBoundary-DHtzU4tz.cjs");
+const shapeTypes = require("./shapeTypes-b_lhwQB7.cjs");
+const vecOps = require("./vecOps-CjRL1jau.cjs");
+const cast = require("./cast-CqDc8oFW.cjs");
+const errors = require("./errors-DK1VAdP4.cjs");
+let CURVE_TYPES_MAP = null;
+const getCurveTypesMap = (refresh) => {
+  if (CURVE_TYPES_MAP && !refresh) return CURVE_TYPES_MAP;
+  const oc = occtBoundary.getKernel().oc;
+  const ga = oc.GeomAbs_CurveType;
+  CURVE_TYPES_MAP = /* @__PURE__ */ new Map([
+    [ga.GeomAbs_Line, "LINE"],
+    [ga.GeomAbs_Circle, "CIRCLE"],
+    [ga.GeomAbs_Ellipse, "ELLIPSE"],
+    [ga.GeomAbs_Hyperbola, "HYPERBOLA"],
+    [ga.GeomAbs_Parabola, "PARABOLA"],
+    [ga.GeomAbs_BezierCurve, "BEZIER_CURVE"],
+    [ga.GeomAbs_BSplineCurve, "BSPLINE_CURVE"],
+    [ga.GeomAbs_OffsetCurve, "OFFSET_CURVE"],
+    [ga.GeomAbs_OtherCurve, "OTHER_CURVE"]
+  ]);
+  return CURVE_TYPES_MAP;
+};
+const findCurveType = (type) => {
+  let shapeType = getCurveTypesMap().get(type);
+  if (!shapeType) shapeType = getCurveTypesMap(true).get(type);
+  if (!shapeType) return errors.err(errors.typeCastError("UNKNOWN_CURVE_TYPE", "Unknown curve type"));
+  return errors.ok(shapeType);
+};
+function clone(shape) {
+  return shapeTypes.castShape(errors.unwrap(cast.downcast(shape.wrapped)));
+}
+function toBREP(shape) {
+  const oc = occtBoundary.getKernel().oc;
+  return oc.BRepToolsWrapper.Write(shape.wrapped);
+}
+function getHashCode(shape) {
+  return shape.wrapped.HashCode(vecOps.HASH_CODE_MAX);
+}
+function isEmpty(shape) {
+  return shape.wrapped.IsNull();
+}
+function isSameShape(a, b) {
+  return a.wrapped.IsSame(b.wrapped);
+}
+function isEqualShape(a, b) {
+  return a.wrapped.IsEqual(b.wrapped);
+}
+function simplify(shape) {
+  const oc = occtBoundary.getKernel().oc;
+  const r = shapeTypes.gcWithScope();
+  const upgrader = r(new oc.ShapeUpgrade_UnifySameDomain_2(shape.wrapped, true, true, false));
+  upgrader.Build();
+  return shapeTypes.castShape(upgrader.Shape());
+}
+function translate(shape, v) {
+  const oc = occtBoundary.getKernel().oc;
+  const trsf = new oc.gp_Trsf_1();
+  const vec = occtBoundary.toOcVec(v);
+  trsf.SetTranslation_1(vec);
+  const transformer = new oc.BRepBuilderAPI_Transform_2(shape.wrapped, trsf, true);
+  const result = shapeTypes.castShape(transformer.Shape());
+  transformer.delete();
+  trsf.delete();
+  vec.delete();
+  return result;
+}
+function rotate(shape, angle, position = [0, 0, 0], direction = [0, 0, 1]) {
+  const oc = occtBoundary.getKernel().oc;
+  const trsf = new oc.gp_Trsf_1();
+  const ax1 = occtBoundary.makeOcAx1(position, direction);
+  trsf.SetRotation_1(ax1, angle * vecOps.DEG2RAD);
+  const transformer = new oc.BRepBuilderAPI_Transform_2(shape.wrapped, trsf, true);
+  const result = shapeTypes.castShape(transformer.Shape());
+  transformer.delete();
+  trsf.delete();
+  ax1.delete();
+  return result;
+}
+function mirror(shape, planeNormal = [0, 1, 0], planeOrigin = [0, 0, 0]) {
+  const oc = occtBoundary.getKernel().oc;
+  const trsf = new oc.gp_Trsf_1();
+  const ax2 = occtBoundary.makeOcAx2(planeOrigin, planeNormal);
+  trsf.SetMirror_3(ax2);
+  const transformer = new oc.BRepBuilderAPI_Transform_2(shape.wrapped, trsf, true);
+  const result = shapeTypes.castShape(transformer.Shape());
+  transformer.delete();
+  trsf.delete();
+  ax2.delete();
+  return result;
+}
+function scale(shape, factor, center = [0, 0, 0]) {
+  const oc = occtBoundary.getKernel().oc;
+  const trsf = new oc.gp_Trsf_1();
+  const pnt = occtBoundary.toOcPnt(center);
+  trsf.SetScale(pnt, factor);
+  const transformer = new oc.BRepBuilderAPI_Transform_2(shape.wrapped, trsf, true);
+  const result = shapeTypes.castShape(transformer.Shape());
+  transformer.delete();
+  trsf.delete();
+  pnt.delete();
+  return result;
+}
+const topoCache = /* @__PURE__ */ new WeakMap();
+function getOrCreateCache(shape) {
+  let entry = topoCache.get(shape.wrapped);
+  if (!entry) {
+    entry = {};
+    topoCache.set(shape.wrapped, entry);
+  }
+  return entry;
+}
+function getEdges(shape) {
+  const cache = getOrCreateCache(shape);
+  if (cache.edges) return cache.edges;
+  const edges = Array.from(cast.iterTopo(shape.wrapped, "edge")).map(
+    (e) => shapeTypes.castShape(errors.unwrap(cast.downcast(e)))
+  );
+  cache.edges = edges;
+  return edges;
+}
+function getFaces(shape) {
+  const cache = getOrCreateCache(shape);
+  if (cache.faces) return cache.faces;
+  const faces = Array.from(cast.iterTopo(shape.wrapped, "face")).map(
+    (e) => shapeTypes.castShape(errors.unwrap(cast.downcast(e)))
+  );
+  cache.faces = faces;
+  return faces;
+}
+function getWires(shape) {
+  const cache = getOrCreateCache(shape);
+  if (cache.wires) return cache.wires;
+  const wires = Array.from(cast.iterTopo(shape.wrapped, "wire")).map(
+    (e) => shapeTypes.castShape(errors.unwrap(cast.downcast(e)))
+  );
+  cache.wires = wires;
+  return wires;
+}
+function getVertices(shape) {
+  return Array.from(cast.iterTopo(shape.wrapped, "vertex")).map(
+    (e) => shapeTypes.castShape(errors.unwrap(cast.downcast(e)))
+  );
+}
+function* iterEdges(shape) {
+  for (const e of cast.iterTopo(shape.wrapped, "edge")) {
+    yield shapeTypes.castShape(errors.unwrap(cast.downcast(e)));
+  }
+}
+function* iterFaces(shape) {
+  for (const f of cast.iterTopo(shape.wrapped, "face")) {
+    yield shapeTypes.castShape(errors.unwrap(cast.downcast(f)));
+  }
+}
+function* iterWires(shape) {
+  for (const w of cast.iterTopo(shape.wrapped, "wire")) {
+    yield shapeTypes.castShape(errors.unwrap(cast.downcast(w)));
+  }
+}
+function* iterVertices(shape) {
+  for (const v of cast.iterTopo(shape.wrapped, "vertex")) {
+    yield shapeTypes.castShape(errors.unwrap(cast.downcast(v)));
+  }
+}
+function getBounds(shape) {
+  const oc = occtBoundary.getKernel().oc;
+  const bbox = new oc.Bnd_Box_1();
+  oc.BRepBndLib.Add(shape.wrapped, bbox, true);
+  const xMin = { current: 0 };
+  const yMin = { current: 0 };
+  const zMin = { current: 0 };
+  const xMax = { current: 0 };
+  const yMax = { current: 0 };
+  const zMax = { current: 0 };
+  bbox.Get(xMin, yMin, zMin, xMax, yMax, zMax);
+  bbox.delete();
+  return {
+    xMin: xMin.current,
+    xMax: xMax.current,
+    yMin: yMin.current,
+    yMax: yMax.current,
+    zMin: zMin.current,
+    zMax: zMax.current
+  };
+}
+function describe(shape) {
+  return {
+    kind: shapeTypes.getShapeKind(shape),
+    faceCount: getFaces(shape).length,
+    edgeCount: getEdges(shape).length,
+    wireCount: getWires(shape).length,
+    vertexCount: getVertices(shape).length,
+    valid: occtBoundary.getKernel().isValid(shape.wrapped),
+    bounds: getBounds(shape)
+  };
+}
+function vertexPosition(vertex) {
+  const oc = occtBoundary.getKernel().oc;
+  const pnt = oc.BRep_Tool.Pnt(vertex.wrapped);
+  const result = [pnt.X(), pnt.Y(), pnt.Z()];
+  pnt.delete();
+  return result;
+}
+function getAdaptor(shape) {
+  const oc = occtBoundary.getKernel().oc;
+  const st = shape.wrapped.ShapeType();
+  const e = oc.TopAbs_ShapeEnum;
+  if (st === e.TopAbs_WIRE) {
+    return new oc.BRepAdaptor_CompCurve_2(shape.wrapped, false);
+  }
+  return new oc.BRepAdaptor_Curve_2(shape.wrapped);
+}
+function mapParam(adaptor, t) {
+  const first = Number(adaptor.FirstParameter());
+  const last = Number(adaptor.LastParameter());
+  return first + (last - first) * t;
+}
+function getCurveType(shape) {
+  const r = shapeTypes.gcWithScope();
+  const adaptor = r(getAdaptor(shape));
+  const technicalType = adaptor.GetType && adaptor.GetType();
+  return errors.unwrap(findCurveType(technicalType));
+}
+function curveStartPoint(shape) {
+  const r = shapeTypes.gcWithScope();
+  const adaptor = r(getAdaptor(shape));
+  const pnt = r(adaptor.Value(adaptor.FirstParameter()));
+  return [pnt.X(), pnt.Y(), pnt.Z()];
+}
+function curveEndPoint(shape) {
+  const r = shapeTypes.gcWithScope();
+  const adaptor = r(getAdaptor(shape));
+  const pnt = r(adaptor.Value(adaptor.LastParameter()));
+  return [pnt.X(), pnt.Y(), pnt.Z()];
+}
+function curvePointAt(shape, position = 0.5) {
+  const r = shapeTypes.gcWithScope();
+  const adaptor = r(getAdaptor(shape));
+  const pnt = r(adaptor.Value(mapParam(adaptor, position)));
+  return [pnt.X(), pnt.Y(), pnt.Z()];
+}
+function curveTangentAt(shape, position = 0.5) {
+  const oc = occtBoundary.getKernel().oc;
+  const r = shapeTypes.gcWithScope();
+  const adaptor = r(getAdaptor(shape));
+  const param = mapParam(adaptor, position);
+  const tmpPnt = r(new oc.gp_Pnt_1());
+  const tmpVec = r(new oc.gp_Vec_1());
+  adaptor.D1(param, tmpPnt, tmpVec);
+  return [tmpVec.X(), tmpVec.Y(), tmpVec.Z()];
+}
+function curveLength(shape) {
+  const oc = occtBoundary.getKernel().oc;
+  const r = shapeTypes.gcWithScope();
+  const props = r(new oc.GProp_GProps_1());
+  oc.BRepGProp.LinearProperties(shape.wrapped, props, true, false);
+  return props.Mass();
+}
+function curveIsClosed(shape) {
+  const r = shapeTypes.gcWithScope();
+  const adaptor = r(getAdaptor(shape));
+  return adaptor.IsClosed();
+}
+function curveIsPeriodic(shape) {
+  const r = shapeTypes.gcWithScope();
+  const adaptor = r(getAdaptor(shape));
+  return adaptor.IsPeriodic();
+}
+function curvePeriod(shape) {
+  const adaptor = getAdaptor(shape);
+  const result = adaptor.Period();
+  adaptor.delete();
+  return result;
+}
+function getOrientation(shape) {
+  const oc = occtBoundary.getKernel().oc;
+  const orient = shape.wrapped.Orientation_1();
+  return orient === oc.TopAbs_Orientation.TopAbs_FORWARD ? "forward" : "backward";
+}
+function flipOrientation(shape) {
+  return shapeTypes.castShape(shape.wrapped.Reversed());
+}
+function interpolateCurve(points, options = {}) {
+  if (points.length < 2) {
+    return errors.err(errors.typeCastError("INTERPOLATE_MIN_POINTS", "Interpolation requires at least 2 points"));
+  }
+  try {
+    const result = occtBoundary.getKernel().interpolatePoints(points, options);
+    const cast2 = shapeTypes.castShape(result);
+    if (!shapeTypes.isEdge(cast2)) {
+      return errors.err(errors.typeCastError("INTERPOLATE_NOT_EDGE", "Interpolation did not produce an edge"));
+    }
+    return errors.ok(cast2);
+  } catch (e) {
+    return errors.err(
+      errors.typeCastError(
+        "INTERPOLATE_FAILED",
+        `Interpolation failed: ${e instanceof Error ? e.message : String(e)}`
+      )
+    );
+  }
+}
+function approximateCurve(points, options = {}) {
+  if (points.length < 2) {
+    return errors.err(errors.typeCastError("APPROXIMATE_MIN_POINTS", "Approximation requires at least 2 points"));
+  }
+  try {
+    const result = occtBoundary.getKernel().approximatePoints(points, options);
+    const cast2 = shapeTypes.castShape(result);
+    if (!shapeTypes.isEdge(cast2)) {
+      return errors.err(errors.typeCastError("APPROXIMATE_NOT_EDGE", "Approximation did not produce an edge"));
+    }
+    return errors.ok(cast2);
+  } catch (e) {
+    return errors.err(
+      errors.typeCastError(
+        "APPROXIMATE_FAILED",
+        `Approximation failed: ${e instanceof Error ? e.message : String(e)}`
+      )
+    );
+  }
+}
+function offsetWire2D(wire, offset, kind = "arc") {
+  const oc = occtBoundary.getKernel().oc;
+  const joinTypes = {
+    arc: oc.GeomAbs_JoinType.GeomAbs_Arc,
+    intersection: oc.GeomAbs_JoinType.GeomAbs_Intersection,
+    tangent: oc.GeomAbs_JoinType.GeomAbs_Tangent
+  };
+  const resultShape = occtBoundary.getKernel().offsetWire2D(wire.wrapped, offset, joinTypes[kind]);
+  const wrapped = shapeTypes.castShape(resultShape);
+  if (!shapeTypes.isWire(wrapped)) {
+    wrapped[Symbol.dispose]();
+    return errors.err(errors.typeCastError("OFFSET_NOT_WIRE", "Offset did not produce a Wire"));
+  }
+  return errors.ok(wrapped);
+}
+exports.approximateCurve = approximateCurve;
+exports.clone = clone;
+exports.curveEndPoint = curveEndPoint;
+exports.curveIsClosed = curveIsClosed;
+exports.curveIsPeriodic = curveIsPeriodic;
+exports.curveLength = curveLength;
+exports.curvePeriod = curvePeriod;
+exports.curvePointAt = curvePointAt;
+exports.curveStartPoint = curveStartPoint;
+exports.curveTangentAt = curveTangentAt;
+exports.describe = describe;
+exports.findCurveType = findCurveType;
+exports.flipOrientation = flipOrientation;
+exports.getBounds = getBounds;
+exports.getCurveType = getCurveType;
+exports.getEdges = getEdges;
+exports.getFaces = getFaces;
+exports.getHashCode = getHashCode;
+exports.getOrientation = getOrientation;
+exports.getVertices = getVertices;
+exports.getWires = getWires;
+exports.interpolateCurve = interpolateCurve;
+exports.isEmpty = isEmpty;
+exports.isEqualShape = isEqualShape;
+exports.isSameShape = isSameShape;
+exports.iterEdges = iterEdges;
+exports.iterFaces = iterFaces;
+exports.iterVertices = iterVertices;
+exports.iterWires = iterWires;
+exports.mirror = mirror;
+exports.offsetWire2D = offsetWire2D;
+exports.rotate = rotate;
+exports.scale = scale;
+exports.simplify = simplify;
+exports.toBREP = toBREP;
+exports.translate = translate;
+exports.vertexPosition = vertexPosition;