lbrnts 0.0.7 → 0.0.8

package/dist/index.d.ts

@@ -91,6 +91,7 @@ interface CutSettingInit {
     angle?: number;
     overScanning?: number;
     lineAngle?: number;
+    crossHatch?: boolean;
 }
 declare class CutSetting extends LightBurnBaseElement {
     private _type;
@@ -115,6 +116,7 @@ declare class CutSetting extends LightBurnBaseElement {
     private _angle?;
     private _overScanning?;
     private _lineAngle?;
+    private _crossHatch?;
     constructor(init?: CutSettingInit);
     get type(): string;
     set type(value: string);
@@ -160,6 +162,8 @@ declare class CutSetting extends LightBurnBaseElement {
     set overScanning(value: number | undefined);
     get lineAngle(): number | undefined;
     set lineAngle(value: number | undefined);
+    get crossHatch(): boolean | undefined;
+    set crossHatch(value: boolean | undefined);
     getXmlAttributes(): Record<string, string | number | boolean | undefined>;
     getChildren(): LightBurnBaseElement[];
     static fromXmlJson(node: XmlJsonElement): CutSetting;

package/dist/index.js

@@ -293,6 +293,7 @@ var CutSetting = class _CutSetting extends LightBurnBaseElement {
   _angle;
   _overScanning;
   _lineAngle;
+  _crossHatch;
   constructor(init) {
     super();
     this.token = "CutSetting";
@@ -321,6 +322,7 @@ var CutSetting = class _CutSetting extends LightBurnBaseElement {
       if (init.overScanning !== void 0)
         this._overScanning = init.overScanning;
       if (init.lineAngle !== void 0) this._lineAngle = init.lineAngle;
+      if (init.crossHatch !== void 0) this._crossHatch = init.crossHatch;
     }
   }
   get type() {
@@ -455,6 +457,12 @@ var CutSetting = class _CutSetting extends LightBurnBaseElement {
   set lineAngle(value) {
     this._lineAngle = value;
   }
+  get crossHatch() {
+    return this._crossHatch;
+  }
+  set crossHatch(value) {
+    this._crossHatch = value;
+  }
   getXmlAttributes() {
     return {
       type: this._type
@@ -483,7 +491,8 @@ var CutSetting = class _CutSetting extends LightBurnBaseElement {
       "interval",
       "angle",
       "overScanning",
-      "lineAngle"
+      "lineAngle",
+      "crossHatch"
     ];
     for (const prop of props) {
       const value = this[`_${prop}`];
@@ -523,6 +532,7 @@ var CutSetting = class _CutSetting extends LightBurnBaseElement {
     cs.angle = num(getChildValue("angle"), void 0);
     cs.overScanning = num(getChildValue("overScanning"), void 0);
     cs.lineAngle = num(getChildValue("lineAngle"), void 0);
+    cs.crossHatch = boolish(getChildValue("crossHatch"), void 0);
     return cs;
   }
 };
@@ -1238,6 +1248,28 @@ function collectShapes(root) {
   return out;
 }
 
+// lib/svg-gen/collect-cut-settings.ts
+function collectCutSettings(root) {
+  const settings = /* @__PURE__ */ new Map();
+  const processElement = (el) => {
+    if (el instanceof CutSetting && el.index !== void 0) {
+      settings.set(el.index, el);
+    } else if (el instanceof LightBurnProject) {
+      for (const child of el.children) {
+        if (child instanceof CutSetting && child.index !== void 0) {
+          settings.set(child.index, child);
+        }
+      }
+    }
+  };
+  if (Array.isArray(root)) {
+    root.forEach(processElement);
+  } else {
+    processElement(root);
+  }
+  return settings;
+}
+
 // lib/svg-gen/options.ts
 var DEFAULT_OPTIONS = {
   margin: 10
@@ -1354,7 +1386,7 @@ var bitmapRenderer = {
       corners.map((p) => apply(xform, p))
     );
   },
-  toSvg: (bmp) => {
+  toSvg: (bmp, _cutSettings) => {
     const xform = bmp.xform ? arrayToMatrix(bmp.xform) : identity();
     const transform = matToSvg(xform);
     const w = bmp.w || 0;
@@ -1372,6 +1404,122 @@ var bitmapRenderer = {
   }
 };
 
+// lib/svg-gen/fill-patterns.ts
+function generateScanLines(bbox, settings, color) {
+  const lines = [];
+  const angleRad = settings.angle * Math.PI / 180;
+  const primaryLines = generateLinesAtAngle(
+    bbox,
+    settings.interval,
+    angleRad,
+    color
+  );
+  lines.push(...primaryLines);
+  if (settings.crossHatch) {
+    const perpAngle = angleRad + Math.PI / 2;
+    const crossLines = generateLinesAtAngle(
+      bbox,
+      settings.interval,
+      perpAngle,
+      color
+    );
+    lines.push(...crossLines);
+  }
+  return lines;
+}
+function generateLinesAtAngle(bbox, interval, angle, color) {
+  const lines = [];
+  const diagonal = Math.sqrt(
+    Math.pow(bbox.maxX - bbox.minX, 2) + Math.pow(bbox.maxY - bbox.minY, 2)
+  );
+  const dx = Math.cos(angle);
+  const dy = Math.sin(angle);
+  const px = -Math.sin(angle);
+  const py = Math.cos(angle);
+  const cx = (bbox.minX + bbox.maxX) / 2;
+  const cy = (bbox.minY + bbox.maxY) / 2;
+  const numLines = Math.ceil(diagonal / interval) + 2;
+  for (let i = -numLines / 2; i <= numLines / 2; i++) {
+    const offset = i * interval;
+    const startX = cx + px * offset - dx * diagonal;
+    const startY = cy + py * offset - dy * diagonal;
+    const endX = cx + px * offset + dx * diagonal;
+    const endY = cy + py * offset + dy * diagonal;
+    const clipped = clipLineToBBox(
+      startX,
+      startY,
+      endX,
+      endY,
+      bbox.minX,
+      bbox.minY,
+      bbox.maxX,
+      bbox.maxY
+    );
+    if (clipped) {
+      lines.push(
+        leaf("line", {
+          x1: String(clipped.x1),
+          y1: String(clipped.y1),
+          x2: String(clipped.x2),
+          y2: String(clipped.y2),
+          stroke: color,
+          "stroke-width": "0.1",
+          "stroke-opacity": "0.8"
+        })
+      );
+    }
+  }
+  return lines;
+}
+function clipLineToBBox(x1, y1, x2, y2, minX, minY, maxX, maxY) {
+  const INSIDE = 0;
+  const LEFT = 1;
+  const RIGHT = 2;
+  const BOTTOM = 4;
+  const TOP = 8;
+  function computeOutCode(x, y) {
+    let code = INSIDE;
+    if (x < minX) code |= LEFT;
+    else if (x > maxX) code |= RIGHT;
+    if (y < minY) code |= BOTTOM;
+    else if (y > maxY) code |= TOP;
+    return code;
+  }
+  let outcode1 = computeOutCode(x1, y1);
+  let outcode2 = computeOutCode(x2, y2);
+  while (true) {
+    if (!(outcode1 | outcode2)) {
+      return { x1, y1, x2, y2 };
+    } else if (outcode1 & outcode2) {
+      return null;
+    }
+    const outcodeOut = outcode1 ? outcode1 : outcode2;
+    let x, y;
+    if (outcodeOut & TOP) {
+      x = x1 + (x2 - x1) * (maxY - y1) / (y2 - y1);
+      y = maxY;
+    } else if (outcodeOut & BOTTOM) {
+      x = x1 + (x2 - x1) * (minY - y1) / (y2 - y1);
+      y = minY;
+    } else if (outcodeOut & RIGHT) {
+      y = y1 + (y2 - y1) * (maxX - x1) / (x2 - x1);
+      x = maxX;
+    } else {
+      y = y1 + (y2 - y1) * (minX - x1) / (x2 - x1);
+      x = minX;
+    }
+    if (outcodeOut === outcode1) {
+      x1 = x;
+      y1 = y;
+      outcode1 = computeOutCode(x1, y1);
+    } else {
+      x2 = x;
+      y2 = y;
+      outcode2 = computeOutCode(x2, y2);
+    }
+  }
+}
+
 // lib/svg-gen/palette.ts
 var LIGHTBURN_COLORS = {
   0: "#000000",
@@ -1448,12 +1596,30 @@ var ellipseRenderer = {
       extremes.map((p) => apply(xform, p))
     );
   },
-  toSvg: (el) => {
+  toSvg: (el, cutSettings) => {
     const xform = el.xform ? arrayToMatrix(el.xform) : identity();
     const transform = matToSvg(xform);
     const rx = el.rx || 0;
     const ry = el.ry || 0;
     const stroke = colorForCutIndex(el.cutIndex);
+    const children = [];
+    const cutSetting = el.cutIndex !== void 0 ? cutSettings.get(el.cutIndex) : void 0;
+    const shouldShowFill = cutSetting && (cutSetting.type === "Scan" || cutSetting.type === "Scan+Cut");
+    if (shouldShowFill && cutSetting) {
+      const localBBox = {
+        minX: -rx,
+        minY: -ry,
+        maxX: rx,
+        maxY: ry
+      };
+      const fillSettings = {
+        interval: cutSetting.interval || 0.1,
+        angle: cutSetting.angle || 0,
+        crossHatch: cutSetting.crossHatch || false
+      };
+      const fillLines = generateScanLines(localBBox, fillSettings, stroke);
+      children.push(...fillLines);
+    }
     const child = rx === ry ? leaf("circle", {
       cx: "0",
       cy: "0",
@@ -1468,7 +1634,8 @@ var ellipseRenderer = {
       fill: "none",
       stroke
     });
-    return g({ transform }, [child]);
+    children.push(child);
+    return g({ transform }, children);
   }
 };
 
@@ -1478,10 +1645,10 @@ var groupRenderer = {
   bbox: (grp) => {
     return grp.children.filter((c) => c instanceof ShapeBase).reduce((bb, c) => boxUnion(bb, bboxOfShape(c)), emptyBox());
   },
-  toSvg: (grp) => {
+  toSvg: (grp, cutSettings) => {
     const xform = grp.xform ? arrayToMatrix(grp.xform) : identity();
     const transform = matToSvg(xform);
-    const children = grp.children.filter((c) => c instanceof ShapeBase).map(svgForShape);
+    const children = grp.children.filter((c) => c instanceof ShapeBase).map((c) => svgForShape(c, cutSettings));
     return g({ transform }, children);
   }
 };
@@ -1494,10 +1661,11 @@ var pathRenderer = {
     const pts = p.verts.map((v) => apply(xform, { x: v.x, y: v.y }));
     return addPts(emptyBox(), pts);
   },
-  toSvg: (p) => {
+  toSvg: (p, cutSettings) => {
     const xform = p.xform ? arrayToMatrix(p.xform) : identity();
     const transform = matToSvg(xform);
     const stroke = colorForCutIndex(p.cutIndex);
+    const children = [];
     let d = "";
     for (let i = 0; i < p.prims.length; i++) {
       const prim = p.prims[i];
@@ -1519,14 +1687,46 @@ var pathRenderer = {
     if (d.length > 0 && p.isClosed) {
       d += " Z";
     }
-    return g({ transform }, [
+    const cutSetting = p.cutIndex !== void 0 ? cutSettings.get(p.cutIndex) : void 0;
+    const shouldShowFill = p.isClosed && cutSetting && (cutSetting.type === "Scan" || cutSetting.type === "Scan+Cut");
+    if (shouldShowFill && cutSetting) {
+      const bbox = addPts(
+        emptyBox(),
+        p.verts.map((v) => ({ x: v.x, y: v.y }))
+      );
+      const fillSettings = {
+        interval: cutSetting.interval || 0.1,
+        angle: cutSetting.angle || 0,
+        crossHatch: cutSetting.crossHatch || false
+      };
+      const fillLines = generateScanLines(bbox, fillSettings, stroke);
+      const clipId = `clip-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+      const clipPath = {
+        name: "clipPath",
+        type: "element",
+        value: "",
+        attributes: { id: clipId },
+        children: [leaf("path", { d })]
+      };
+      const clippedGroup = {
+        name: "g",
+        type: "element",
+        value: "",
+        attributes: { "clip-path": `url(#${clipId})` },
+        children: fillLines
+      };
+      children.push(clipPath);
+      children.push(clippedGroup);
+    }
+    children.push(
       leaf("path", {
         d,
         fill: "none",
         stroke,
         "stroke-width": "0.1"
       })
-    ]);
+    );
+    return g({ transform }, children);
   }
 };
 
@@ -1548,14 +1748,32 @@ var rectRenderer = {
       corners.map((p) => apply(xform, p))
     );
   },
-  toSvg: (rect) => {
+  toSvg: (rect, cutSettings) => {
     const xform = rect.xform ? arrayToMatrix(rect.xform) : identity();
     const transform = matToSvg(xform);
     const w = rect.w || 0;
     const h = rect.h || 0;
     const cr = rect.cr || 0;
     const stroke = colorForCutIndex(rect.cutIndex);
-    return g({ transform }, [
+    const children = [];
+    const cutSetting = rect.cutIndex !== void 0 ? cutSettings.get(rect.cutIndex) : void 0;
+    const shouldShowFill = cutSetting && (cutSetting.type === "Scan" || cutSetting.type === "Scan+Cut");
+    if (shouldShowFill && cutSetting) {
+      const localBBox = {
+        minX: 0,
+        minY: 0,
+        maxX: w,
+        maxY: h
+      };
+      const fillSettings = {
+        interval: cutSetting.interval || 0.1,
+        angle: cutSetting.angle || 0,
+        crossHatch: cutSetting.crossHatch || false
+      };
+      const fillLines = generateScanLines(localBBox, fillSettings, stroke);
+      children.push(...fillLines);
+    }
+    children.push(
       leaf("rect", {
         x: "0",
         y: "0",
@@ -1566,7 +1784,8 @@ var rectRenderer = {
         fill: "none",
         stroke
       })
-    ]);
+    );
+    return g({ transform }, children);
   }
 };
 
@@ -1586,7 +1805,7 @@ var textRenderer = {
       apply(xform, { x: 100, y: 50 })
     ]);
   },
-  toSvg: (t) => {
+  toSvg: (t, _cutSettings) => {
     const xform = t.xform ? arrayToMatrix(t.xform) : identity();
     const transform = matToSvg(xform);
     const stroke = colorForCutIndex(t.cutIndex);
@@ -1620,22 +1839,23 @@ function findRenderer(shape) {
 function bboxOfShape(shape) {
   return findRenderer(shape).bbox(shape);
 }
-function svgForShape(shape) {
-  return findRenderer(shape).toSvg(shape);
+function svgForShape(shape, cutSettings) {
+  return findRenderer(shape).toSvg(shape, cutSettings);
 }
 function measure(shapes) {
   return shapes.reduce((acc, s) => boxUnion(acc, bboxOfShape(s)), emptyBox());
 }
-function renderAll(shapes) {
-  return shapes.map(svgForShape);
+function renderAll(shapes, cutSettings) {
+  return shapes.map((s) => svgForShape(s, cutSettings));
 }
 
 // lib/svg-gen/index.ts
 function generateLightBurnSvg(root, options) {
   const shapes = collectShapes(root);
+  const cutSettings = collectCutSettings(root);
   const bbox = measure(shapes);
   const layout = computeLayout(bbox, options);
-  const nodes = renderAll(shapes);
+  const nodes = renderAll(shapes, cutSettings);
   const svgTree = assembleSvg(nodes, layout);
   return stringify(svgTree);
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "lbrnts",
   "main": "dist/index.js",
   "type": "module",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "files": [
     "dist"
   ],