@thi.ng/rasterize 0.1.1 → 0.3.2

package/CHANGELOG.md

@@ -1,19 +1,50 @@
 # Change Log
 
+- **Last updated**: 2021-11-21T17:09:28Z
+- **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
+
 All notable changes to this project will be documented in this file.
-See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
+See [Conventional Commits](https://conventionalcommits.org/) for commit guidelines.
+
+**Note:** Unlisted _patch_ versions only involve non-code or otherwise excluded changes
+and/or version bumps of transitive dependencies.
+
+## [0.3.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/rasterize@0.3.0) (2021-11-17)
 
-## [0.1.1](https://github.com/thi-ng/umbrella/compare/@thi.ng/rasterize@0.1.0...@thi.ng/rasterize@0.1.1) (2021-11-04)
+#### 🚀 Features
 
-**Note:** Version bump only for package @thi.ng/rasterize
+- Using workspaces for local tools ([bf7a404](https://github.com/thi-ng/umbrella/commit/bf7a404))
+  Improving the overall build ergonomics
+  - introduced a tools workspaces
+  - imported it in all needed packages/examples
+  - inclusive project root
 
+#### ♻️ Refactoring
 
+- testrunner to binary ([4ebbbb2](https://github.com/thi-ng/umbrella/commit/4ebbbb2))
+  this commit reverts (partly) changes made in:
+  ef346d7a8753590dc9094108a3d861a8dbd5dd2c
+  overall purpose is better testament ergonomics:
+  instead of having to pass NODE_OPTIONS with every invocation
+  having a binary to handle this for us.
 
+## [0.2.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/rasterize@0.2.0) (2021-11-10)
 
+#### 🚀 Features
 
-# 0.1.0 (2021-11-03)
+- major update/additions ([e6f7fb0](https://github.com/thi-ng/umbrella/commit/e6f7fb0))
+  - add new shapes (polyline, polygon)
+  - add "shader" function support for all draw fns
+  - add shader functions
+  - rename drawLineWith() => traceLine()
+- update to new IGrid2D impls ([71ac0ca](https://github.com/thi-ng/umbrella/commit/71ac0ca))
+  - add floodFillWith() for custom fill content/procedures
+  - update/fix rect()
+  - optimize __draw2D() for primitive values
+  - add/update deps
 
+## [0.1.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/rasterize@0.1.0) (2021-11-03)
 
-### Features
+#### 🚀 Features
 
-* **rasterize:** import as new pkg ([585eb8d](https://github.com/thi-ng/umbrella/commit/585eb8d360f0c8603c5890dedf221af3afb5584f))
+- import as new pkg ([585eb8d](https://github.com/thi-ng/umbrella/commit/585eb8d))

package/README.md

@@ -12,8 +12,10 @@ This project is part of the
 - [About](#about)
   - [Circle](#circle)
   - [Line](#line)
+  - [Polygon / polyline](#polygon--polyline)
   - [Rect](#rect)
   - [Flood fill](#flood-fill)
+- [Custom shaders](#custom-shaders)
   - [Status](#status)
   - [Related packages](#related-packages)
 - [Installation](#installation)
@@ -27,40 +29,94 @@ This project is part of the
 2D shape drawing & rasterization.
 
 The functions in this package can be used with any
-[`IGrid2D`](https://docs.thi.ng/umbrella/api/interfaces/igrid2d.html) compatible
+[`IGrid2D`](https://docs.thi.ng/umbrella/api/interfaces/IGrid2D.html) compatible
 grid/image type (e.g. those provided by
 [@thi.ng/pixel](https://github.com/thi-ng/umbrella/tree/develop/packages/pixel)
 or
 [@thi.ng/text-canvas](https://github.com/thi-ng/umbrella/tree/develop/packages/text-canvas)).
 
-Currently the following functions are available:
+Currently the following functions are available. All of them support [custom
+shader-like](#custom-shaders) functions to produce "pixel" values.
 
 ### Circle
 
-Filled or outline implementation of [Bresenham's circle
-algorithm](https://en.wikipedia.org/wiki/Midpoint_circle_algorithm). A clipping
-check is pre-applied to see if the circle lies entirely outside the target grid.
+- [`drawCircle()`](https://docs.thi.ng/umbrella/rasterize/modules.html#drawCircle):
+  Filled or outline implementation of [Bresenham's circle
+  algorithm](https://en.wikipedia.org/wiki/Midpoint_circle_algorithm), with
+  clipping.
 
 ### Line
 
-Implementation of [Bresenham's line
-algorithm](https://en.wikipedia.org/wiki/Bresenham%27s_line_algorithm) with
-pre-applied [Liang-Barsky
-clipping](https://en.wikipedia.org/wiki/Liang%E2%80%93Barsky_algorithm). The
-higher-order function
-[`drawLineWith()`](https://docs.thi.ng/umbrella/rasterize/modules.html#drawLineWith)
-can be used to apply custom brushes to trace the line.
+- [`drawLine()`](https://docs.thi.ng/umbrella/rasterize/modules.html#drawLine):
+  Implementation of [Bresenham's line
+  algorithm](https://en.wikipedia.org/wiki/Bresenham%27s_line_algorithm) with
+  pre-applied [Liang-Barsky
+  clipping](https://en.wikipedia.org/wiki/Liang%E2%80%93Barsky_algorithm)
+- [`traceLine()`](https://docs.thi.ng/umbrella/rasterize/modules.html#traceLine):
+  Apply custom functions to trace the line
+
+### Polygon / polyline
+
+Filled or outline drawing of polygons (without holes):
+
+- [`drawPolyline()`](https://docs.thi.ng/umbrella/rasterize/modules.html#drawPolyline)
+- [`fillPoly()`](https://docs.thi.ng/umbrella/rasterize/modules.html#fillPoly)
 
 ### Rect
 
-Filled or outline implementation with pre-applied clipping against the target grid.
+- [`drawRect()`](https://docs.thi.ng/umbrella/rasterize/modules.html#drawRect):
+  Filled or outline implementation with pre-applied clipping against the target
+  grid.
 
 ### Flood fill
 
-Fills grid in the connected region around `x,y` with given value or pattern. See
-[`floodFill()` in the @thi.ng/grid-iterators
-package](https://docs.thi.ng/umbrella/grid-iterators/modules.html#floodFill) for
-further details.
+- [`floodFill()`](https://docs.thi.ng/umbrella/rasterize/modules.html#floodFill):
+  Fills grid in the connected region around `x,y` with given value or shader
+
+Also see corresponding function in
+[@thi.ng/grid-iterators](https://docs.thi.ng/umbrella/grid-iterators/modules.html#floodFill).
+
+## Custom shaders
+
+Conceptually similar, but **not** to be equaled with actual WebGL fragement
+shaders, many functions in this package support shader-like functions to produce
+per-pixel fill/color values for each individual pixel processed. These simple
+functions take an `x` and `y` arg (in grid-space, **not** normalized!) and
+produce a fill value for that location. A pixel is processed at most once per
+draw call.
+
+The following shader functions are provided:
+
+- [`defPattern()`](https://docs.thi.ng/umbrella/rasterize/modules.html#defPattern):
+  pattern fill (must be same format as target grid)
+- [`defStripes()`](https://docs.thi.ng/umbrella/rasterize/modules.html#defStripes):
+  procedural stripes (configurable)
+- [`defNoise()`](https://docs.thi.ng/umbrella/rasterize/modules.html#defNoise):
+  random noise pattern (configurable)
+
+As an example, here's a simple custom UV gradient shader for drawing into a
+[float RGBA](https://docs.thi.ng/umbrella/pixel/modules.html#floatBuffer)
+buffer:
+
+```ts
+import type { Shader2D } from "@thi.ng/rasterize";
+import { floatBuffer } from "@thi.ng/pixel";
+import { drawCircle } from "@thi.ng/rasterize";
+
+// custom gradient shader
+const defUVGradient = (width: number, height: number): Shader2D<number[]> =>
+  (x, y) => [x/width, y/height, 0.5, 1];
+
+const W = 256;
+
+// create float RGBA pixel buffer
+const img = floatBuffer(W, W);
+
+// draw filled circle using gradient shader
+drawCircle(img, W/2, W/2, W/2 - 4, defUVGradient(W, W), true);
+```
+
+![result image: circle with gradient fill](https://raw.githubusercontent.com/thi-ng/umbrella/develop/assets/rasterize/uv-circle.png)
 
 ### Status
 
@@ -97,12 +153,15 @@ node --experimental-repl-await
 > const rasterize = await import("@thi.ng/rasterize");
 ```
 
-Package sizes (gzipped, pre-treeshake): ESM: 669 bytes
+Package sizes (gzipped, pre-treeshake): ESM: 1.45 KB
 
 ## Dependencies
 
 - [@thi.ng/api](https://github.com/thi-ng/umbrella/tree/develop/packages/api)
+- [@thi.ng/checks](https://github.com/thi-ng/umbrella/tree/develop/packages/checks)
+- [@thi.ng/equiv](https://github.com/thi-ng/umbrella/tree/develop/packages/equiv)
 - [@thi.ng/grid-iterators](https://github.com/thi-ng/umbrella/tree/develop/packages/grid-iterators)
+- [@thi.ng/random](https://github.com/thi-ng/umbrella/tree/develop/packages/random)
 - [@thi.ng/transducers](https://github.com/thi-ng/umbrella/tree/develop/packages/transducers)
 
 ## API

package/api.d.ts

@@ -0,0 +1,3 @@
+import type { Fn2 } from "@thi.ng/api";
+export declare type Shader2D<T> = Fn2<number, number, T>;
+//# sourceMappingURL=api.d.ts.map

package/api.js

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

package/checks.d.ts

@@ -1,3 +1,5 @@
 import type { IGrid2D } from "@thi.ng/api";
-export declare const isInBounds2D: ({ width, height }: IGrid2D<any, any>, x: number, y: number) => boolean;
+import type { Shader2D } from "./api.js";
+export declare const isInBounds2D: ({ size }: IGrid2D<any, any>, x: number, y: number) => boolean;
+export declare const ensureShader2D: <T>(val: T | Shader2D<T>) => Shader2D<T>;
 //# sourceMappingURL=checks.d.ts.map

package/checks.js

@@ -1 +1,3 @@
-export const isInBounds2D = ({ width, height }, x, y) => x >= 0 && x < width && y >= 0 && y < height;
+import { isFunction } from "@thi.ng/checks/is-function";
+export const isInBounds2D = ({ size }, x, y) => x >= 0 && x < size[0] && y >= 0 && y < size[1];
+export const ensureShader2D = (val) => isFunction(val) ? val : () => val;

package/circle.d.ts

@@ -1,3 +1,4 @@
 import type { IGrid2D, TypedArray } from "@thi.ng/api";
-export declare const drawCircle: <T extends any[] | TypedArray, P>(grid: IGrid2D<T, P>, x: number, y: number, r: number, val: P, fill?: boolean) => IGrid2D<T, P>;
+import type { Shader2D } from "./api.js";
+export declare const drawCircle: <T extends any[] | TypedArray, P>(grid: IGrid2D<T, P>, x: number, y: number, r: number, val: P | Shader2D<P>, fill?: boolean) => IGrid2D<T, P>;
 //# sourceMappingURL=circle.d.ts.map

package/circle.js

@@ -1,3 +1,3 @@
 import { circleClipped } from "@thi.ng/grid-iterators/circle";
-import { draw2D } from "./draw.js";
-export const drawCircle = (grid, x, y, r, val, fill = false) => draw2D(grid, val, circleClipped(x, y, r, 0, 0, grid.width, grid.height, fill));
+import { __draw2D } from "./draw.js";
+export const drawCircle = (grid, x, y, r, val, fill = false) => __draw2D(circleClipped(x, y, r, 0, 0, grid.size[0], grid.size[1], fill), grid, val);

package/draw.d.ts

@@ -1,4 +1,9 @@
 import type { IGrid2D, Nullable, TypedArray } from "@thi.ng/api";
+import type { Shader2D } from "./api.js";
 /** @internal */
-export declare const draw2D: <T extends any[] | TypedArray, P>(grid: IGrid2D<T, P>, val: P, pts: Nullable<Iterable<number[]>>) => IGrid2D<T, P>;
+export declare const __draw2D: <T extends any[] | TypedArray, P>(pts: Nullable<Iterable<number[]>>, grid: IGrid2D<T, P>, val: P | Shader2D<P>) => IGrid2D<T, P>;
+/** @internal */
+export declare const __drawSolid2D: <T extends any[] | TypedArray, P>(pts: Nullable<Iterable<number[]>>, grid: IGrid2D<T, P>, val: P) => IGrid2D<T, P>;
+/** @internal */
+export declare const __drawShader2D: <T extends any[] | TypedArray, P>(pts: Nullable<Iterable<number[]>>, grid: IGrid2D<T, P>, shader: Shader2D<P>) => IGrid2D<T, P>;
 //# sourceMappingURL=draw.d.ts.map

package/draw.js

@@ -1,9 +1,40 @@
+import { isFunction } from "@thi.ng/checks/is-function";
+import { isPrimitive } from "@thi.ng/checks/is-primitive";
 /** @internal */
-export const draw2D = (grid, val, pts) => {
-    if (pts) {
-        const { data, stride, rowStride } = grid;
-        for (let p of pts)
-            data[p[0] * stride + p[1] * rowStride] = val;
+export const __draw2D = (pts, grid, val) => isFunction(val)
+    ? __drawShader2D(pts, grid, val)
+    : __drawSolid2D(pts, grid, val);
+/** @internal */
+export const __drawSolid2D = (pts, grid, val) => {
+    if (!pts)
+        return grid;
+    if (isPrimitive(val)) {
+        const { data, offset, stride: [sx, sy], } = grid;
+        for (let p of pts) {
+            data[offset + p[0] * sx + p[1] * sy] = val;
+        }
+    }
+    else {
+        for (let p of pts) {
+            grid.setAtUnsafe(p[0], p[1], val);
+        }
+    }
+    return grid;
+};
+/** @internal */
+export const __drawShader2D = (pts, grid, shader) => {
+    if (!pts)
+        return grid;
+    if (isPrimitive(grid.getAtUnsafe(0, 0))) {
+        const { data, offset, stride: [sx, sy], } = grid;
+        for (let { 0: x, 1: y } of pts) {
+            data[offset + x * sx + y * sy] = shader(x, y);
+        }
+    }
+    else {
+        for (let { 0: x, 1: y } of pts) {
+            grid.setAtUnsafe(x, y, shader(x, y));
+        }
     }
     return grid;
 };

package/flood-fill.d.ts

@@ -1,23 +1,14 @@
 import type { IGrid2D, TypedArray } from "@thi.ng/api";
+import type { Shader2D } from "./api.js";
 /**
- * Fills pixel in the connected region around `x,y` with given color. Returns
- * pixel buffer.
- *
- * @param img
- * @param x
- * @param y
- * @param val
- */
-export declare const floodFillSolid: <T extends any[] | TypedArray, P>(img: IGrid2D<T, P>, x: number, y: number, val: P) => IGrid2D<T, P>;
-/**
- * Fills pixel in the connected region around `x,y` with the pattern defined by
- * given `pattern` image (must be in same format as `img`). Returns updated
- * pixel buffer.
+ * Fills cells in the connected region around `x,y` with given value or shader
+ * function. If the latter, the shader is called for each grid coordinate and
+ * returns a fill value. Returns updated grid.
  *
  * @param grid
  * @param x
  * @param y
- * @param pattern
+ * @param val
  */
-export declare const floodFillPattern: <T extends any[] | TypedArray, P>(grid: IGrid2D<T, P>, x: number, y: number, pattern: IGrid2D<T, P>) => IGrid2D<T, P>;
+export declare const floodFill: <T extends any[] | TypedArray, P>(grid: IGrid2D<T, P>, x: number, y: number, val: P | Shader2D<P>) => IGrid2D<T, P>;
 //# sourceMappingURL=flood-fill.d.ts.map

package/flood-fill.js

@@ -1,40 +1,30 @@
-import { floodFill } from "@thi.ng/grid-iterators/flood-fill";
+import { isIterable } from "@thi.ng/checks/is-iterable";
+import { isPrimitive } from "@thi.ng/checks/is-primitive";
+import { equiv } from "@thi.ng/equiv";
+import { floodFill as $fill } from "@thi.ng/grid-iterators/flood-fill";
 import { isInBounds2D } from "./checks.js";
-import { draw2D } from "./draw.js";
+import { __draw2D } from "./draw.js";
 /**
- * Fills pixel in the connected region around `x,y` with given color. Returns
- * pixel buffer.
- *
- * @param img
- * @param x
- * @param y
- * @param val
- */
-export const floodFillSolid = (img, x, y, val) => {
-    if (!isInBounds2D(img, x, y))
-        return img;
-    const { data, width, height, stride, rowStride } = img;
-    const srcVal = img.getAtUnsafe(x, y);
-    return draw2D(img, val, floodFill((x, y) => data[x * stride + y * rowStride] === srcVal, x, y, width, height));
-};
-/**
- * Fills pixel in the connected region around `x,y` with the pattern defined by
- * given `pattern` image (must be in same format as `img`). Returns updated
- * pixel buffer.
+ * Fills cells in the connected region around `x,y` with given value or shader
+ * function. If the latter, the shader is called for each grid coordinate and
+ * returns a fill value. Returns updated grid.
  *
  * @param grid
  * @param x
  * @param y
- * @param pattern
+ * @param val
  */
-export const floodFillPattern = (grid, x, y, pattern) => {
-    if (!isInBounds2D(grid, x, y))
-        return grid;
-    const { data: dest, stride: ds, rowStride: drs } = grid;
-    const { data: src, width: sw, height: sh, stride: ss, rowStride: srs, } = pattern;
-    const srcVal = grid.getAtUnsafe(x, y);
-    for (let [xx, yy] of floodFill((x, y) => dest[x * ds + y * drs] === srcVal, x, y, grid.width, grid.height)) {
-        dest[xx * ds + yy * drs] = src[(xx % sw) * ss + (yy % sh) * srs];
+export const floodFill = (grid, x, y, val) => isInBounds2D(grid, x, y)
+    ? __draw2D($fill(__pred(grid, x, y), x, y, grid.size[0], grid.size[1]), grid, val)
+    : grid;
+const __pred = (img, x, y) => {
+    const { data, offset, stride: [stride, rowStride], } = img;
+    let srcVal = img.getAtUnsafe(x, y);
+    if (isPrimitive(srcVal)) {
+        return (x, y) => data[offset + x * stride + y * rowStride] === srcVal;
+    }
+    if (isIterable(srcVal)) {
+        srcVal = [...srcVal];
     }
-    return grid;
+    return (x, y) => equiv(img.getAtUnsafe(x, y), srcVal);
 };

package/index.d.ts

@@ -1,6 +1,10 @@
+export * from "./api.js";
 export * from "./checks.js";
 export * from "./circle.js";
 export * from "./flood-fill.js";
 export * from "./line.js";
+export * from "./poly.js";
+export * from "./polyline.js";
 export * from "./rect.js";
+export * from "./shader.js";
 //# sourceMappingURL=index.d.ts.map

package/index.js

@@ -1,5 +1,9 @@
+export * from "./api.js";
 export * from "./checks.js";
 export * from "./circle.js";
 export * from "./flood-fill.js";
 export * from "./line.js";
+export * from "./poly.js";
+export * from "./polyline.js";
 export * from "./rect.js";
+export * from "./shader.js";

package/line.d.ts

@@ -1,4 +1,5 @@
 import type { Fn, IGrid2D, TypedArray } from "@thi.ng/api";
-export declare const drawLine: <T extends any[] | TypedArray, P>(grid: IGrid2D<T, P>, x1: number, y1: number, x2: number, y2: number, val: P) => IGrid2D<T, P>;
-export declare const drawLineWith: (fn: Fn<number[], void>, grid: IGrid2D<any, any>, x1: number, y1: number, x2: number, y2: number) => IGrid2D<any, any>;
+import type { Shader2D } from "./api.js";
+export declare const drawLine: <T extends any[] | TypedArray, P>(grid: IGrid2D<T, P>, x1: number, y1: number, x2: number, y2: number, val: P | Shader2D<P>) => IGrid2D<T, P>;
+export declare const traceLine: (grid: IGrid2D<any, any>, x1: number, y1: number, x2: number, y2: number, fn: Fn<number[], void>) => IGrid2D<any, any>;
 //# sourceMappingURL=line.d.ts.map

package/line.js

@@ -1,8 +1,8 @@
 import { lineClipped } from "@thi.ng/grid-iterators/line";
-import { draw2D } from "./draw.js";
-export const drawLine = (grid, x1, y1, x2, y2, val) => draw2D(grid, val, lineClipped(x1, y1, x2, y2, 0, 0, grid.width, grid.height));
-export const drawLineWith = (fn, grid, x1, y1, x2, y2) => {
-    const pts = lineClipped(x1, y1, x2, y2, 0, 0, grid.width, grid.height);
+import { __draw2D } from "./draw.js";
+export const drawLine = (grid, x1, y1, x2, y2, val) => __draw2D(lineClipped(x1, y1, x2, y2, 0, 0, grid.size[0], grid.size[1]), grid, val);
+export const traceLine = (grid, x1, y1, x2, y2, fn) => {
+    const pts = lineClipped(x1, y1, x2, y2, 0, 0, grid.size[0], grid.size[1]);
     if (pts) {
         for (let p of pts)
             fn(p);

package/package.json

@@ -1,102 +1,122 @@
 {
-    "name": "@thi.ng/rasterize",
-    "version": "0.1.1",
-    "description": "2D shape drawing & rasterization",
-    "type": "module",
-    "module": "./index.js",
-    "typings": "./index.d.ts",
-    "sideEffects": false,
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/thi-ng/umbrella.git"
+  "name": "@thi.ng/rasterize",
+  "version": "0.3.2",
+  "description": "2D shape drawing & rasterization",
+  "type": "module",
+  "module": "./index.js",
+  "typings": "./index.d.ts",
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/thi-ng/umbrella.git"
+  },
+  "homepage": "https://github.com/thi-ng/umbrella/tree/master/packages/rasterize#readme",
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/postspectacular"
     },
-    "homepage": "https://github.com/thi-ng/umbrella/tree/master/packages/rasterize#readme",
-    "funding": [
-        {
-            "type": "github",
-            "url": "https://github.com/sponsors/postspectacular"
-        },
-        {
-            "type": "patreon",
-            "url": "https://patreon.com/thing_umbrella"
-        }
-    ],
-    "author": "Karsten Schmidt <k+npm@thi.ng>",
-    "license": "Apache-2.0",
-    "scripts": {
-        "build": "yarn clean && tsc --declaration",
-        "clean": "rimraf *.js *.d.ts *.map doc",
-        "doc": "typedoc --excludePrivate --excludeInternal --out doc src/index.ts",
-        "doc:ae": "mkdir -p .ae/doc .ae/temp && node_modules/.bin/api-extractor run --local --verbose",
-        "doc:readme": "yarn doc:stats && ../../scripts/node-esm ../../tools/src/readme.ts",
-        "doc:stats": "../../scripts/node-esm ../../tools/src/module-stats.ts",
-        "pub": "yarn build && yarn publish --access public",
-        "test": "testament test"
+    {
+      "type": "patreon",
+      "url": "https://patreon.com/thing_umbrella"
+    }
+  ],
+  "author": "Karsten Schmidt <k+npm@thi.ng>",
+  "license": "Apache-2.0",
+  "scripts": {
+    "build": "yarn clean && tsc --declaration",
+    "clean": "rimraf '*.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",
+    "doc:readme": "yarn doc:stats && tools:readme",
+    "doc:stats": "tools:module-stats",
+    "pub": "yarn npm publish --access public",
+    "test": "testament test"
+  },
+  "dependencies": {
+    "@thi.ng/api": "^8.3.2",
+    "@thi.ng/checks": "^3.1.2",
+    "@thi.ng/equiv": "^2.1.2",
+    "@thi.ng/grid-iterators": "^2.2.2",
+    "@thi.ng/random": "^3.2.2",
+    "@thi.ng/transducers": "^8.1.2"
+  },
+  "devDependencies": {
+    "@microsoft/api-extractor": "^7.18.19",
+    "@thi.ng/testament": "^0.2.2",
+    "rimraf": "^3.0.2",
+    "tools": "^0.0.1",
+    "typedoc": "^0.22.9",
+    "typescript": "^4.5.2"
+  },
+  "keywords": [
+    "2d",
+    "bitmap",
+    "circle",
+    "clipping",
+    "draw",
+    "floodfill",
+    "grid",
+    "line",
+    "pattern",
+    "shape",
+    "rect",
+    "typescript"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "browser": {
+    "process": false,
+    "setTimeout": false
+  },
+  "engines": {
+    "node": ">=14"
+  },
+  "files": [
+    "*.js",
+    "*.d.ts"
+  ],
+  "exports": {
+    ".": {
+      "import": "./index.js"
     },
-    "dependencies": {
-        "@thi.ng/api": "^8.1.0",
-        "@thi.ng/grid-iterators": "^2.1.1",
-        "@thi.ng/transducers": "^8.0.7"
+    "./api": {
+      "import": "./api.js"
     },
-    "devDependencies": {
-        "@thi.ng/testament": "^0.1.6"
+    "./checks": {
+      "import": "./checks.js"
     },
-    "keywords": [
-        "2d",
-        "bitmap",
-        "circle",
-        "clipping",
-        "draw",
-        "floodfill",
-        "grid",
-        "line",
-        "pattern",
-        "shape",
-        "rect",
-        "typescript"
-    ],
-    "publishConfig": {
-        "access": "public"
+    "./circle": {
+      "import": "./circle.js"
     },
-    "browser": {
-        "process": false,
-        "setTimeout": false
+    "./flood-fill": {
+      "import": "./flood-fill.js"
     },
-    "engines": {
-        "node": ">=14"
+    "./line": {
+      "import": "./line.js"
     },
-    "files": [
-        "*.js",
-        "*.d.ts"
-    ],
-    "exports": {
-        ".": {
-            "import": "./index.js"
-        },
-        "./checks": {
-            "import": "./checks.js"
-        },
-        "./circle": {
-            "import": "./circle.js"
-        },
-        "./flood-fill": {
-            "import": "./flood-fill.js"
-        },
-        "./line": {
-            "import": "./line.js"
-        },
-        "./rect": {
-            "import": "./rect.js"
-        }
+    "./poly": {
+      "import": "./poly.js"
     },
-    "thi.ng": {
-        "related": [
-            "grid-iterators",
-            "pixel",
-            "text-canvas"
-        ],
-        "status": "alpha",
-        "year": 2021
+    "./polyline": {
+      "import": "./polyline.js"
     },
-    "gitHead": "d6aca4b4edb697613ed6635b1c0b12f0bf27b1f0"
-}
+    "./rect": {
+      "import": "./rect.js"
+    },
+    "./shader": {
+      "import": "./shader.js"
+    }
+  },
+  "thi.ng": {
+    "related": [
+      "grid-iterators",
+      "pixel",
+      "text-canvas"
+    ],
+    "status": "alpha",
+    "year": 2021
+  },
+  "gitHead": "e8a7c2a40191b391cef182c2978e5a6c85987a87\n"
+}

package/poly.d.ts

@@ -0,0 +1,18 @@
+import type { IGrid2D, TypedArray } from "@thi.ng/api";
+import type { Shader2D } from "./api.js";
+/**
+ * Draws a filled polygon (simple, no holes) into given grid. Each grid cell's
+ * value is obtained from user supplied shader function which will be called
+ * with the pixel's `x,y` coords.
+ *
+ * Based on Efficient Polygon Fill Algorithm by Darel Rex Finley
+ * http://alienryderflex.com/polygon_fill/
+ *
+ * Bounds calculation and clipping added by Karsten Schmidt
+ *
+ * @param grid
+ * @param pts
+ * @param val
+ */
+export declare const fillPoly: <T extends any[] | TypedArray, P>(grid: IGrid2D<T, P>, pts: number[][], val: P | Shader2D<P>) => void;
+//# sourceMappingURL=poly.d.ts.map

package/poly.js

@@ -0,0 +1,67 @@
+import { ensureShader2D } from "./checks.js";
+/**
+ * Draws a filled polygon (simple, no holes) into given grid. Each grid cell's
+ * value is obtained from user supplied shader function which will be called
+ * with the pixel's `x,y` coords.
+ *
+ * Based on Efficient Polygon Fill Algorithm by Darel Rex Finley
+ * http://alienryderflex.com/polygon_fill/
+ *
+ * Bounds calculation and clipping added by Karsten Schmidt
+ *
+ * @param grid
+ * @param pts
+ * @param val
+ */
+export const fillPoly = (grid, pts, val) => {
+    const numP = pts.length;
+    const [width, height] = grid.size;
+    const shader = ensureShader2D(val);
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    for (let i = numP; i-- > 0;) {
+        const { 0: x, 1: y } = pts[i];
+        minX = Math.min(minX, x);
+        maxX = Math.max(maxX, x);
+        minY = Math.min(minY, y);
+        maxY = Math.max(maxY, y);
+    }
+    minX = Math.max(minX | 0, 0);
+    maxX = Math.min(maxX | 0, width - 1);
+    minY = Math.max(minY | 0, 0);
+    maxY = Math.min(maxY | 0, height - 1);
+    if (minX >= width || maxX < 0 || minY >= height || maxY < 0)
+        return;
+    let i = 0;
+    let k = 0;
+    let j;
+    const isec = [];
+    for (let y = Math.max(0, minY); y <= maxY; y++) {
+        i = k = 0;
+        j = numP - 1;
+        isec.length = 0;
+        for (; i < numP; j = i, i++) {
+            const { 0: pix, 1: piy } = pts[i];
+            const { 0: pjx, 1: pjy } = pts[j];
+            if ((piy < y && pjy >= y) || (pjy < y && piy >= y)) {
+                isec[k++] = (pix + ((y - piy) / (pjy - piy)) * (pjx - pix)) | 0;
+            }
+        }
+        isec.sort((a, b) => a - b);
+        for (i = 0; i < k; i += 2) {
+            let x1 = isec[i];
+            if (x1 > maxX)
+                break;
+            let x2 = isec[i + 1];
+            if (x2 > minX) {
+                x1 < minX && (x1 = minX);
+                x2 > maxX && (x2 = maxX);
+                for (let x = x1; x <= x2; x++) {
+                    grid.setAtUnsafe(x, y, shader(x, y));
+                }
+            }
+        }
+    }
+};

package/polyline.d.ts

@@ -0,0 +1,4 @@
+import type { IGrid2D, TypedArray } from "@thi.ng/api";
+import type { Shader2D } from "./api.js";
+export declare const drawPolyLine: <T extends any[] | TypedArray, P>(grid: IGrid2D<T, P>, pts: number[][], val: P | Shader2D<P>, closed?: boolean) => void;
+//# sourceMappingURL=polyline.d.ts.map

package/polyline.js

@@ -0,0 +1,12 @@
+import { ensureShader2D } from "./checks.js";
+import { drawLine } from "./line.js";
+export const drawPolyLine = (grid, pts, val, closed = false) => {
+    val = ensureShader2D(val);
+    const n = pts.length;
+    let [i, j] = closed ? [0, n - 1] : [1, 0];
+    for (; i < n; j = i, i++) {
+        const a = pts[j];
+        const b = pts[i];
+        drawLine(grid, a[0], a[1], b[0], b[1], val);
+    }
+};

package/rect.d.ts

@@ -1,3 +1,4 @@
 import type { IGrid2D, TypedArray } from "@thi.ng/api";
-export declare const drawRect: <T extends any[] | TypedArray, P>(grid: IGrid2D<T, P>, x: number, y: number, w: number, h: number, val: P, fill?: boolean) => IGrid2D<T, P> | undefined;
+import type { Shader2D } from "./api.js";
+export declare const drawRect: <T extends any[] | TypedArray, P>(grid: IGrid2D<T, P>, x: number, y: number, w: number, h: number, val: P | Shader2D<P>, fill?: boolean) => IGrid2D<T, P>;
 //# sourceMappingURL=rect.d.ts.map

package/rect.js

@@ -1,9 +1,15 @@
+import { isPrimitive } from "@thi.ng/checks";
 import { hlineClipped, vlineClipped } from "@thi.ng/grid-iterators/hvline";
 import { rows2d } from "@thi.ng/grid-iterators/rows";
 import { concat } from "@thi.ng/transducers/concat";
-import { draw2D } from "./draw.js";
+import { ensureShader2D } from "./checks.js";
+import { __draw2D } from "./draw.js";
 export const drawRect = (grid, x, y, w, h, val, fill = false) => {
-    const { data, width: iw, height: ih, stride, rowStride } = grid;
+    x |= 0;
+    y |= 0;
+    w |= 0;
+    h |= 0;
+    const { data, offset, size: [width, height], stride: [sx, sy], } = grid;
     if (fill) {
         if (x < 0) {
             w += x;
@@ -13,10 +19,23 @@ export const drawRect = (grid, x, y, w, h, val, fill = false) => {
             h += y;
             y = 0;
         }
-        for (let [xx, yy] of rows2d(Math.min(w, iw - x), Math.min(h, ih - y))) {
-            data[(x + xx) * stride + (y + yy) * rowStride] = val;
+        const pts = rows2d(Math.min(w, width - x), Math.min(h, height - y));
+        const shader = ensureShader2D(val);
+        if (isPrimitive(val)) {
+            for (let { 0: xx, 1: yy } of pts) {
+                xx += x;
+                yy += y;
+                data[offset + xx * sx + yy * sy] = shader(xx, yy);
+            }
         }
-        return;
+        else {
+            for (let { 0: xx, 1: yy } of pts) {
+                xx += x;
+                yy += y;
+                grid.setAtUnsafe(xx, yy, shader(xx, yy));
+            }
+        }
+        return grid;
     }
-    return draw2D(grid, val, concat(hlineClipped(x, y, w, 0, 0, iw, ih), vlineClipped(x, y + 1, h - 2, 0, 0, iw, ih), hlineClipped(x, y + h - 1, w, 0, 0, iw, ih), vlineClipped(x + w - 1, y + 1, h - 2, 0, 0, iw, ih)));
+    return __draw2D(concat(hlineClipped(x, y, w, 0, 0, width, height), vlineClipped(x, y + 1, h - 2, 0, 0, width, height), hlineClipped(x, y + h - 1, w, 0, 0, width, height), vlineClipped(x + w - 1, y + 1, h - 2, 0, 0, width, height)), grid, val);
 };

package/shader.d.ts

@@ -0,0 +1,20 @@
+import type { IGrid2D, TypedArray } from "@thi.ng/api";
+import type { IRandom } from "@thi.ng/random";
+import type { Shader2D } from "./api.js";
+export declare const defPattern: <T extends any[] | TypedArray, P>(pattern: IGrid2D<T, P>) => Shader2D<P>;
+export interface StripeShaderOpts<T> {
+    dir: "h" | "v" | "d";
+    size: number;
+    sizeA: number;
+    a: T;
+    b: T;
+}
+export declare const defStripes: <T = number>({ dir, size, sizeA, a, b, }: StripeShaderOpts<T>) => Shader2D<T>;
+export interface RandomShaderOpts<T> {
+    probability?: number;
+    rnd?: IRandom;
+    a: T;
+    b: T;
+}
+export declare const defNoise: <T = number>(opts: RandomShaderOpts<T>) => Shader2D<T>;
+//# sourceMappingURL=shader.d.ts.map

package/shader.js

@@ -0,0 +1,18 @@
+import { SYSTEM } from "@thi.ng/random/system";
+export const defPattern = (pattern) => {
+    const [w, h] = pattern.size;
+    return (x, y) => pattern.getAtUnsafe(x % w, y % h);
+};
+export const defStripes = ({ dir, size, sizeA, a, b, }) => dir === "h"
+    ? (x) => (x % size < sizeA ? a : b)
+    : dir === "v"
+        ? (_, y) => (y % size < sizeA ? a : b)
+        : (x, y) => ((x + y) % size < sizeA ? a : b);
+export const defNoise = (opts) => {
+    const { probability, rnd, a, b } = {
+        probability: 0.5,
+        rnd: SYSTEM,
+        ...opts,
+    };
+    return () => (rnd.float() < probability ? a : b);
+};