@thi.ng/geom-trace-bitmap 0.3.40 → 0.3.42

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2023-12-09T19:12:03Z
+- **Last updated**: 2023-12-11T10:07:09Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.

package/README.md

@@ -67,7 +67,7 @@ For Node.js REPL:
 const geomTraceBitmap = await import("@thi.ng/geom-trace-bitmap");
 ```
 
-Package sizes (brotli'd, pre-treeshake): ESM: 988 bytes
+Package sizes (brotli'd, pre-treeshake): ESM: 991 bytes
 
 ## Dependencies
 

package/api.js

@@ -1 +0,0 @@
-export {};

package/border.js

@@ -1,31 +1,18 @@
-/**
- * Border function which only checks X coordinates.
- *
- * @param w - image width
- * @param h - image width
- */
-export const borderX = (w) => {
-    w--;
-    return (p) => p[0] === 0 || p[0] === w;
+const borderX = (w) => {
+  w--;
+  return (p) => p[0] === 0 || p[0] === w;
 };
-/**
- * Border function which only checks Y coordinates.
- *
- * @param w - image width
- * @param h - image width
- */
-export const borderY = (_, h) => {
-    h--;
-    return (p) => p[1] === 0 || p[1] === h;
+const borderY = (_, h) => {
+  h--;
+  return (p) => p[1] === 0 || p[1] === h;
 };
-/**
- * Border function which checks both X & Y coordinates.
- *
- * @param w - image width
- * @param h - image width
- */
-export const borderXY = (w, h) => {
-    w--;
-    h--;
-    return (p) => p[0] === 0 || p[0] === w || p[1] === 0 || p[1] === h;
+const borderXY = (w, h) => {
+  w--;
+  h--;
+  return (p) => p[0] === 0 || p[0] === w || p[1] === 0 || p[1] === h;
+};
+export {
+  borderX,
+  borderXY,
+  borderY
 };

package/extract.js

@@ -1,72 +1,40 @@
 import { comparator2 } from "@thi.ng/vectors/compare";
-/**
- * Extracts horizontal line segments (along X-axis) from given point cloud
- * (assuming all points are aligned to a grid, e.g. pixel coords). Returns
- * object of `{segments, points}`, where `segments` contains all extracted
- * segments and `points` all remaining/unmatched points.
- *
- * @remarks
- * The given point array will be sorted (in-place!). Line segments will be as
- * long as possible, depending on chosen `maxDist`, which defines max distance
- * between consecutive points. If a point is further away than `maxDist` units
- * from the previous point (or at a new X coord), the current line segment (if
- * any) will be terminated and the new point is potentially becoming the start
- * of the next segment.
- *
- * @param pts
- * @param maxDist
- */
-export const extractSegmentsX = (pts, maxD = 5) => __extract(pts, maxD, 1);
-/**
- * Similar to {@link extractSegmentsX}, but for extracting vertical line
- * segments (along Y-axis).
- *
- * @param pts
- * @param maxDist
- */
-export const extractSegmentsY = (pts, maxDist = 5) => __extract(pts, maxDist, 0);
-/**
- * Common implementation for both axis orders.
- *
- * @param pts
- * @param maxD
- * @param order
- *
- * @internal
- */
+const extractSegmentsX = (pts, maxD = 5) => __extract(pts, maxD, 1);
+const extractSegmentsY = (pts, maxDist = 5) => __extract(pts, maxDist, 0);
 const __extract = (pts, maxD, order) => {
-    if (pts.length < 2)
-        return { segments: [], points: pts };
-    const $ = order ? (p) => [p[1], p[0]] : (p) => p;
-    pts = pts.sort(comparator2(order, order ^ 1));
-    const segments = [];
-    const points = [];
-    let [outer, inner] = $(pts[0]);
-    let last = 0;
-    for (let i = 1, n = pts.length - 1; i <= n; i++) {
-        const p = $(pts[i]);
-        if (p[0] === outer) {
-            if (i === n || p[1] - inner > maxD) {
-                if (i - last > 1) {
-                    segments.push([pts[last], pts[i - 1]]);
-                }
-                else {
-                    points.push(pts[last]);
-                }
-                last = i;
-            }
-            inner = p[1];
-        }
-        else {
-            if (i - last > 1) {
-                segments.push([pts[last], pts[i - 1]]);
-            }
-            else {
-                points.push(pts[last]);
-            }
-            last = i;
-            [outer, inner] = p;
+  if (pts.length < 2)
+    return { segments: [], points: pts };
+  const $ = order ? (p) => [p[1], p[0]] : (p) => p;
+  pts = pts.sort(comparator2(order, order ^ 1));
+  const segments = [];
+  const points = [];
+  let [outer, inner] = $(pts[0]);
+  let last = 0;
+  for (let i = 1, n = pts.length - 1; i <= n; i++) {
+    const p = $(pts[i]);
+    if (p[0] === outer) {
+      if (i === n || p[1] - inner > maxD) {
+        if (i - last > 1) {
+          segments.push([pts[last], pts[i - 1]]);
+        } else {
+          points.push(pts[last]);
         }
+        last = i;
+      }
+      inner = p[1];
+    } else {
+      if (i - last > 1) {
+        segments.push([pts[last], pts[i - 1]]);
+      } else {
+        points.push(pts[last]);
+      }
+      last = i;
+      [outer, inner] = p;
     }
-    return { segments, points };
+  }
+  return { segments, points };
+};
+export {
+  extractSegmentsX,
+  extractSegmentsY
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/geom-trace-bitmap",
-  "version": "0.3.40",
+  "version": "0.3.42",
   "description": "Bitmap image to hairline vector and point cloud conversions",
   "type": "module",
   "module": "./index.js",
@@ -24,7 +24,9 @@
   "author": "Karsten Schmidt (https://thi.ng)",
   "license": "Apache-2.0",
   "scripts": {
-    "build": "yarn clean && tsc --declaration",
+    "build": "yarn build:esbuild && yarn build:decl",
+    "build:decl": "tsc --declaration --emitDeclarationOnly",
+    "build:esbuild": "esbuild --format=esm --platform=neutral --target=es2022 --tsconfig=tsconfig.json --outdir=. src/**/*.ts",
     "clean": "rimraf --glob '*.js' '*.d.ts' '*.map' doc",
     "doc": "typedoc --excludePrivate --excludeInternal --out doc src/index.ts",
     "doc:ae": "mkdir -p .ae/doc .ae/temp && api-extractor run --local --verbose",
@@ -33,15 +35,16 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.9.11",
-    "@thi.ng/errors": "^2.4.5",
-    "@thi.ng/grid-iterators": "^4.0.35",
-    "@thi.ng/matrices": "^2.2.12",
-    "@thi.ng/pixel": "^5.0.3",
-    "@thi.ng/vectors": "^7.8.8"
+    "@thi.ng/api": "^8.9.12",
+    "@thi.ng/errors": "^2.4.6",
+    "@thi.ng/grid-iterators": "^4.0.36",
+    "@thi.ng/matrices": "^2.2.14",
+    "@thi.ng/pixel": "^5.0.5",
+    "@thi.ng/vectors": "^7.8.10"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.38.3",
+    "esbuild": "^0.19.8",
     "rimraf": "^5.0.5",
     "tools": "^0.0.1",
     "typedoc": "^0.25.4",
@@ -98,5 +101,5 @@
     "status": "alpha",
     "year": 2022
   },
-  "gitHead": "25f2ac8ff795a432a930119661b364d4d93b59a0\n"
+  "gitHead": "22e36fa838e5431d40165384918b395603bbd92f\n"
 }

package/trace.js

@@ -5,139 +5,134 @@ import { rows2d } from "@thi.ng/grid-iterators/rows";
 import { flipX, ident } from "@thi.ng/grid-iterators/transforms";
 import { mulV23 } from "@thi.ng/matrices/mulv";
 import { borderX, borderXY, borderY } from "./border.js";
-/**
- * Main conversion/extraction function. According to given
- * {@link TraceBitmapOpts.flags}, extracts line segments and/or points from
- * given pixel buffer and returns object of results. By default _all_ line
- * directions and points are processed. If {@link TraceBitmapOpts.mat} is given,
- * all coordinates are transformed with that matrix.
- *
- * ```ts
- * traceBitmap({ img: ..., flags: Trace.DIAGONAL })
- * // { lines: [...], points: [] }
- * ```
- *
- * @param opts
- */
-export const traceBitmap = (opts) => {
-    const mat = opts.mat;
-    const { width, height } = opts.img;
-    const lines = [];
-    const points = [];
-    for (let d of opts.dir || ["h", "v", "d1", "d2", "p"]) {
-        if (typeof d !== "string") {
-            traceLines(opts, d.order, (d.border || borderXY)(width, height), d.tx || ident, lines);
-            continue;
-        }
-        switch (d) {
-            case "h":
-                traceLines(opts, rows2d, borderX(width, height), ident, lines);
-                break;
-            case "v":
-                traceLines(opts, columns2d, borderY(width, height), ident, lines);
-                break;
-            case "d1":
-                traceLines(opts, diagonal2d, borderXY(width, height), ident, lines);
-                break;
-            case "d2":
-                traceLines(opts, diagonal2d, borderXY(width, height), flipX, lines);
-                break;
-            case "p":
-                tracePoints(opts, points);
-                break;
-            default:
-                illegalArgs(`invalid trace direction: ${d}`);
-        }
+const traceBitmap = (opts) => {
+  const mat = opts.mat;
+  const { width, height } = opts.img;
+  const lines = [];
+  const points = [];
+  for (let d of opts.dir || ["h", "v", "d1", "d2", "p"]) {
+    if (typeof d !== "string") {
+      traceLines(
+        opts,
+        d.order,
+        (d.border || borderXY)(width, height),
+        d.tx || ident,
+        lines
+      );
+      continue;
     }
-    if (mat) {
-        lines.forEach((p) => {
-            mulV23(null, mat, p[0]);
-            mulV23(null, mat, p[1]);
-        });
-        points.forEach((p) => mulV23(null, mat, p));
+    switch (d) {
+      case "h":
+        traceLines(opts, rows2d, borderX(width, height), ident, lines);
+        break;
+      case "v":
+        traceLines(
+          opts,
+          columns2d,
+          borderY(width, height),
+          ident,
+          lines
+        );
+        break;
+      case "d1":
+        traceLines(
+          opts,
+          diagonal2d,
+          borderXY(width, height),
+          ident,
+          lines
+        );
+        break;
+      case "d2":
+        traceLines(
+          opts,
+          diagonal2d,
+          borderXY(width, height),
+          flipX,
+          lines
+        );
+        break;
+      case "p":
+        tracePoints(opts, points);
+        break;
+      default:
+        illegalArgs(`invalid trace direction: ${d}`);
     }
-    return { lines, points };
+  }
+  if (mat) {
+    lines.forEach((p) => {
+      mulV23(null, mat, p[0]);
+      mulV23(null, mat, p[1]);
+    });
+    points.forEach((p) => mulV23(null, mat, p));
+  }
+  return { lines, points };
 };
-/**
- * Extracts line segments in the orientation/order of given grid iterator and
- * stores results in `acc`.
- *
- * @param opts
- * @param order
- * @param border
- * @param tx
- * @param acc
- */
-export const traceLines = (opts, order, border, tx, acc = []) => {
-    let { img, select, clear, last, min, max } = {
-        clear: 0,
-        last: true,
-        min: 2,
-        max: Infinity,
-        ...opts,
-    };
-    min--;
-    let curr = [];
-    let prevBorder = false;
-    const $record = () => {
-        acc.push([curr[0], curr[curr.length - 1]]);
-        for (let q of curr)
-            img.setAtUnsafe(q[0], q[1], clear);
-    };
-    for (let p of order({ cols: img.width, rows: img.height, tx })) {
-        const c = select(img.getAtUnsafe(p[0], p[1]), p);
-        const isBorder = border(p);
-        const n = curr.length;
-        if (c) {
-            if (isBorder || n >= max) {
-                if (n > 0) {
-                    if (prevBorder) {
-                        if (n > min)
-                            $record();
-                        curr = [p];
-                    }
-                    else {
-                        if (n >= min) {
-                            curr.push(p);
-                            $record();
-                        }
-                        curr = [];
-                    }
-                }
-                else {
-                    curr.push(p);
-                }
-            }
-            else {
-                curr.push(p);
-            }
-        }
-        else if (n > 0) {
-            if (n > min) {
-                if (last)
-                    curr.push(p);
-                $record();
+const traceLines = (opts, order, border, tx, acc = []) => {
+  let { img, select, clear, last, min, max } = {
+    clear: 0,
+    last: true,
+    min: 2,
+    max: Infinity,
+    ...opts
+  };
+  min--;
+  let curr = [];
+  let prevBorder = false;
+  const $record = () => {
+    acc.push([curr[0], curr[curr.length - 1]]);
+    for (let q of curr)
+      img.setAtUnsafe(q[0], q[1], clear);
+  };
+  for (let p of order({ cols: img.width, rows: img.height, tx })) {
+    const c = select(img.getAtUnsafe(p[0], p[1]), p);
+    const isBorder = border(p);
+    const n = curr.length;
+    if (c) {
+      if (isBorder || n >= max) {
+        if (n > 0) {
+          if (prevBorder) {
+            if (n > min)
+              $record();
+            curr = [p];
+          } else {
+            if (n >= min) {
+              curr.push(p);
+              $record();
             }
             curr = [];
+          }
+        } else {
+          curr.push(p);
         }
-        prevBorder = isBorder;
+      } else {
+        curr.push(p);
+      }
+    } else if (n > 0) {
+      if (n > min) {
+        if (last)
+          curr.push(p);
+        $record();
+      }
+      curr = [];
     }
-    return acc;
+    prevBorder = isBorder;
+  }
+  return acc;
 };
-/**
- * Extracts single pixels and stores their coordinates in `acc`.
- *
- * @param opts
- * @param acc
- */
-export const tracePoints = ({ img, select, clear }, acc = []) => {
-    if (clear === undefined)
-        clear = 0;
-    for (let i = 0, n = img.data.length, w = img.width; i < n; i++) {
-        if (select(img.data[i], [i % w, (i / w) | 0])) {
-            acc.push([i % w, (i / w) | 0]);
-            img.data[i] = clear;
-        }
+const tracePoints = ({ img, select, clear }, acc = []) => {
+  if (clear === void 0)
+    clear = 0;
+  for (let i = 0, n = img.data.length, w = img.width; i < n; i++) {
+    if (select(img.data[i], [i % w, i / w | 0])) {
+      acc.push([i % w, i / w | 0]);
+      img.data[i] = clear;
     }
-    return acc;
+  }
+  return acc;
+};
+export {
+  traceBitmap,
+  traceLines,
+  tracePoints
 };