@matboks/utilities 0.0.1

package/dist/tilings/mediterranean.d.ts

@@ -0,0 +1,3 @@
+import { Hollowgon } from "../geometry/hollowgon.js";
+import { Polygon } from "../geometry/polygon.js";
+export declare function mediterraneanTiling(shape: Polygon | Hollowgon, rotation: number, ratio: number, resolution: number): Polygon[];

package/dist/tilings/mediterranean.js

@@ -0,0 +1,49 @@
+import { clip } from "../geometry/polygon-operations.js";
+import { Polygon } from "../geometry/polygon.js";
+import { vec2 } from "../geometry/vec2.js";
+export function mediterraneanTiling(shape, rotation, ratio, resolution) {
+    const centroid = shape.centroid();
+    const { xMin, yMin, width, height, aspectRatio } = shape
+        .clone()
+        .rotate(-rotation, centroid)
+        .aabb();
+    let [columns, rows, size] = aspectRatio > 1 ?
+        [Math.round(aspectRatio * resolution), resolution, height / resolution] :
+        [resolution, Math.round(resolution / aspectRatio), width / resolution];
+    columns += 1;
+    rows += 1;
+    const radius = 0.5 * ratio * size;
+    const tiles = [];
+    for (let row = 0; row < rows; row++) {
+        const isFirstRow = row === 0;
+        const y0 = yMin + row * size;
+        for (let column = 0; column < columns; column++) {
+            const isFirstColumn = column === 0;
+            const x0 = xMin + column * size;
+            const squareCenters = [
+                [size, size],
+                ...(isFirstRow ? [[size, 0]] : []),
+                ...(isFirstColumn ? [[0, size]] : []),
+                ...(isFirstRow && isFirstColumn ? [[0, 0]] : []),
+            ];
+            // Squares
+            for (const [ox, oy] of squareCenters) {
+                tiles.push(new Polygon([vec2(ox + x0 - radius, oy + y0), vec2(ox + x0, oy + y0 - radius), vec2(ox + x0 + radius, oy + y0), vec2(ox + x0, oy + y0 + radius)]));
+            }
+            // Octagon
+            tiles.push(new Polygon([
+                vec2(x0 + radius, y0),
+                vec2(x0 + size - radius, y0),
+                vec2(x0 + size, y0 + radius),
+                vec2(x0 + size, y0 + size - radius),
+                vec2(x0 + size - radius, y0 + size),
+                vec2(x0 + radius, y0 + size),
+                vec2(x0, y0 + size - radius),
+                vec2(x0, y0 + radius),
+            ]));
+        }
+    }
+    for (const tile of tiles)
+        tile.rotate(rotation, shape.centroid());
+    return clip(tiles, shape);
+}

package/dist/tilings/pythagorean.d.ts

@@ -0,0 +1,3 @@
+import { Hollowgon } from "../geometry/hollowgon.js";
+import { Polygon } from "../geometry/polygon.js";
+export declare function pythagoreanTiling(shape: Polygon | Hollowgon, rotation: number, ratio: number, resolution: number): Polygon[];

package/dist/tilings/pythagorean.js

@@ -0,0 +1,40 @@
+import { clip } from "../geometry/polygon-operations.js";
+import { Polygon } from "../geometry/polygon.js";
+import { vec2, Vec2 } from "../geometry/vec2.js";
+export function pythagoreanTiling(shape, rotation, ratio, resolution) {
+    const centroid = shape.centroid();
+    const angle = Math.atan(ratio);
+    const { xMin, yMin, width, height, aspectRatio } = shape
+        .clone()
+        .rotate(-(angle + rotation), centroid)
+        .aabb();
+    let [columns, rows, size] = aspectRatio > 1 ?
+        [Math.round(aspectRatio * resolution), resolution, height / resolution] :
+        [resolution, Math.round(resolution / aspectRatio), width / resolution];
+    const bigSquare = [
+        vec2(0, 0),
+        vec2(size, 0),
+        vec2(size, size),
+        vec2(0, size)
+    ].map((v) => v.rotate(-angle));
+    const smallSquare = [
+        vec2((1 - ratio) * size, size),
+        vec2(size, size),
+        vec2(size, (1 + ratio) * size),
+        vec2((1 - ratio) * size, (1 + ratio) * size)
+    ].map((v) => v.rotate(-angle));
+    const step = size * Math.hypot(1, ratio);
+    const polygons = [];
+    for (let row = -0.5; row < rows; row++) {
+        const y0 = yMin + row * step;
+        for (let column = -0.5; column < columns; column++) {
+            const x0 = xMin + column * step;
+            const o = vec2(x0, y0);
+            polygons.push(new Polygon(bigSquare.map((v) => Vec2.add(v, o))));
+            polygons.push(new Polygon(smallSquare.map((v) => Vec2.add(v, o))));
+        }
+    }
+    for (const polygon of polygons)
+        polygon.rotate(angle + rotation, centroid);
+    return clip(polygons, shape);
+}

package/dist/tilings/random-cuts.d.ts

@@ -0,0 +1,6 @@
+import { Hollowgon } from "../geometry/hollowgon.js";
+import { OperationShape } from "../geometry/polygon-operations.js";
+import { Polygon } from "../geometry/polygon.js";
+import { RNG } from "../utilities/rng.js";
+export declare function randomCuts(shape: Polygon, rotation: number, cutCount: number, rng: RNG): Array<Polygon>;
+export declare function randomCuts(shape: Hollowgon, rotation: number, cutCount: number, rng: RNG): Array<OperationShape>;

package/dist/tilings/random-cuts.js

@@ -0,0 +1,16 @@
+import { Line } from "../geometry/line.js";
+import { subdivide } from "../geometry/polygon-operations.js";
+import { Vec2 } from "../geometry/vec2.js";
+export function randomCuts(shape, rotation, cutCount, rng) {
+    let polygons = [shape];
+    // const centroid = polygon.centroid();
+    // const spreadRadius = spread * Math.sqrt(polygon.vertices.reduce((distanceSqr, v) => Math.max(distanceSqr, v.distanceSquared(centroid)), 0));
+    for (let i = 0; i < cutCount; i++) {
+        // const point = Vec2.add(centroid, Vec2.fromPolar(0.2, Math.PI * rng()));
+        // const point = rng.samplePointInDisk(centroid, spreadRadius);
+        const point = rng.pointInPolygon(shape);
+        const cutLine = new Line(point, Vec2.fromPolar(1, rotation + Math.PI * rng()));
+        polygons = subdivide(polygons, cutLine);
+    }
+    return polygons;
+}

package/dist/tilings/recursive-cuts.d.ts

@@ -0,0 +1,5 @@
+import { Hollowgon } from "../geometry/hollowgon.js";
+import { OperationShape } from "../geometry/polygon-operations.js";
+import { Polygon } from "../geometry/polygon.js";
+export declare function recursiveCuts(shape: Polygon, rotation: number, iterations: number): Array<Polygon>;
+export declare function recursiveCuts(shape: Hollowgon, rotation: number, iterations: number): Array<OperationShape>;

package/dist/tilings/recursive-cuts.js

@@ -0,0 +1,11 @@
+import { Line } from "../geometry/line.js";
+import { subdivide } from "../geometry/polygon-operations.js";
+import { Vec2 } from "../geometry/vec2.js";
+export function recursiveCuts(shape, rotation, iterations) {
+    let polygons = [shape];
+    for (let i = 0; i < iterations; i++) {
+        const direction = Vec2.fromPolar(1, rotation + (i % 2 === 0 ? 0 : Math.PI / 2));
+        polygons = subdivide(polygons, (p) => new Line(p.centroid(), direction));
+    }
+    return polygons;
+}

package/dist/tilings/rhombille.d.ts

@@ -0,0 +1,3 @@
+import { Hollowgon } from "../geometry/hollowgon.js";
+import { Polygon } from "../geometry/polygon.js";
+export declare function rhombilleTiling(shape: Polygon | Hollowgon, rotation: number, resolution: number): Polygon[];

package/dist/tilings/rhombille.js

@@ -0,0 +1,16 @@
+import { clip } from "../geometry/polygon-operations.js";
+import { Polygon } from "../geometry/polygon.js";
+import { hexagonalTileHelper } from "./hexagononal.js";
+export function rhombilleTiling(shape, rotation, resolution) {
+    const hexagons = hexagonalTileHelper(shape, rotation, Math.floor(resolution / 2.0));
+    const triangles = [];
+    for (const hexagon of hexagons) {
+        const center = hexagon.centroid();
+        const { vertices } = hexagon;
+        triangles.push(new Polygon([vertices[0].clone(), vertices[1].clone(), vertices[2].clone(), center.clone()]), new Polygon([vertices[2].clone(), vertices[3].clone(), vertices[4].clone(), center.clone()]), new Polygon([vertices[4].clone(), vertices[5].clone(), vertices[0].clone(), center.clone()]));
+    }
+    for (const triangle of triangles)
+        triangle.rotate(rotation, shape.centroid());
+    // return triangles;
+    return clip(triangles, shape);
+}

package/dist/tilings/rightangled-triangle.d.ts

@@ -0,0 +1,3 @@
+import { Hollowgon } from "../geometry/hollowgon.js";
+import { Polygon } from "../geometry/polygon.js";
+export declare function rightangledTriangleTiling(shape: Polygon | Hollowgon, rotation: number, resolution: number): Polygon[];

package/dist/tilings/rightangled-triangle.js

@@ -0,0 +1,29 @@
+import { clip } from "../geometry/polygon-operations.js";
+import { Polygon } from "../geometry/polygon.js";
+import { vec2 } from "../geometry/vec2.js";
+// TODO is equivalent to isometric tiling down to a transformation
+export function rightangledTriangleTiling(shape, rotation, resolution) {
+    const centroid = shape.centroid();
+    const { xMin, yMin, width, height, aspectRatio } = shape
+        .clone()
+        .rotate(-rotation, centroid)
+        .aabb();
+    let [columns, rows, size] = aspectRatio > 1 ?
+        [Math.round(aspectRatio * resolution), resolution, height / resolution] :
+        [resolution, Math.round(resolution / aspectRatio), width / resolution];
+    let polygons = [];
+    for (let row = 0; row < rows; row++) {
+        let y0 = yMin + row * size;
+        for (let column = 0; column < columns; column++) {
+            let x0 = xMin + column * size;
+            polygons.push(new Polygon([
+                vec2(x0, y0), vec2(x0 + size, y0), vec2(x0, y0 + size),
+            ]), new Polygon([
+                vec2(x0 + size, y0), vec2(x0 + size, y0 + size), vec2(x0, y0 + size),
+            ]));
+        }
+    }
+    for (const polygon of polygons)
+        polygon.rotate(rotation, centroid);
+    return clip(polygons, shape);
+}

package/dist/tilings/triangle.d.ts

@@ -0,0 +1,3 @@
+import { Hollowgon } from "../geometry/hollowgon.js";
+import { Polygon } from "../geometry/polygon.js";
+export declare function triangleTiling(shape: Polygon | Hollowgon, rotation: number, resolution: number): Polygon[];

package/dist/tilings/triangle.js

@@ -0,0 +1,17 @@
+import { clip } from "../geometry/polygon-operations.js";
+import { Polygon } from "../geometry/polygon.js";
+import { hexagonalTileHelper } from "./hexagononal.js";
+export function triangleTiling(shape, rotation, resolution) {
+    const hexagons = hexagonalTileHelper(shape, rotation, Math.floor(resolution / 2.0));
+    const triangles = [];
+    for (const hexagon of hexagons) {
+        const center = hexagon.centroid();
+        const { vertices } = hexagon;
+        for (let i = 0, j = 5; i < 6; j = i++) {
+            triangles.push(new Polygon([vertices[j].clone(), vertices[i].clone(), center.clone()]));
+        }
+    }
+    for (const triangle of triangles)
+        triangle.rotate(rotation, shape.centroid());
+    return clip(triangles, shape);
+}

package/dist/tilings/voronoi.d.ts

@@ -0,0 +1,11 @@
+import { Polygon } from "../geometry/polygon.js";
+import { RNG } from "../utilities/rng.js";
+import { PointSamplerStrategy } from "../utilities/point-sampler.js";
+import { Hollowgon } from "../geometry/hollowgon.js";
+export type VoronoiSubdivisionOptions = {
+    shape: Polygon | Hollowgon;
+    numPoints: number;
+    rng: RNG;
+    strategy?: PointSamplerStrategy;
+};
+export declare function voronoiSubdivision(options: VoronoiSubdivisionOptions): Polygon[];

package/dist/tilings/voronoi.js

@@ -0,0 +1,29 @@
+import { Delaunay } from "d3-delaunay";
+import { Polygon } from "../geometry/polygon.js";
+import { vec2 } from "../geometry/vec2.js";
+import { pointSampler } from "../utilities/point-sampler.js";
+import { Hollowgon } from "../geometry/hollowgon.js";
+import { clip } from "../geometry/polygon-operations.js";
+export function voronoiSubdivision(options) {
+    const { shape, numPoints, rng, strategy = "poisson" } = options;
+    const { xMin, xMax, yMin, yMax } = shape.aabb();
+    const pointBuffer = [];
+    for (const { x, y } of pointSampler({ shape, size: numPoints, strategy, rng })) {
+        pointBuffer.push(x, y);
+    }
+    const vertices = shape instanceof Hollowgon ? shape.boundary.vertices : shape.vertices;
+    for (const { x, y } of vertices)
+        pointBuffer.push(x, y);
+    const delaunay = new Delaunay(pointBuffer);
+    const voronoi = delaunay.voronoi([xMin, yMin, xMax, yMax]);
+    const cells = voronoi.cellPolygons();
+    const polygons = [];
+    for (const triangle of cells) {
+        const vertices = [];
+        for (const vertex of triangle) {
+            vertices.push(vec2(vertex[0], vertex[1]));
+        }
+        polygons.push(new Polygon(vertices));
+    }
+    return clip(polygons, shape);
+}

package/dist/tilings/weaving.d.ts

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

package/dist/tilings/weaving.js

@@ -0,0 +1,8 @@
+export {};
+// function weavingTiling(polygon: Polygon, rotation: number, size: number) {
+//   // const centroid = polygon.centroid();
+//   // const { xMin, xMax, yMin, yMax, width, height } = polygon
+//   //   .clone()
+//   //   .rotate(-rotation, centroid)
+//   //   .aabb();
+// }

package/dist/transforms/camera/camera.d.ts

@@ -0,0 +1,32 @@
+import { AABB } from "../../geometry/aabb.js";
+import { Ray3 } from "../../geometry/ray3.js";
+import { Vec2 } from "../../geometry/vec2.js";
+import { Vec3 } from "../../geometry/vec3.js";
+import { Resolution } from "../../utilities/resolution.js";
+export type CameraOptions = {
+    position: Vec3;
+    lookAt?: Vec3;
+    direction?: Vec3;
+    rotation?: number;
+    resolution: Resolution;
+};
+export declare abstract class Camera {
+    position: Vec3;
+    lookAt: Vec3;
+    rotation: number;
+    resolution: Resolution;
+    viewbox: AABB;
+    matrix: DOMMatrix;
+    direction: Vec3;
+    viewBasis: [Vec3, Vec3, Vec3];
+    constructor(options: CameraOptions);
+    computeMatrix(): DOMMatrix;
+    worldVectorToView(worldVector: Vec3): Vec3;
+    worldPositionToView(worldPosition: Vec3): Vec3;
+    worldVectorToScreen(worldVector: Vec3): Vec3;
+    worldPositionToScreen(worldPosition: Vec3): Vec3;
+    mapScreenToXYPlane(screenPosition: Vec2, z?: number): Vec3;
+    abstract projectViewToScreen(viewPosition: Vec3): Vec3;
+    abstract unprojectScreenToView(screenPosition: Vec3): Vec3;
+    abstract getRayAtScreenPosition(screenPosition: Vec2): Ray3;
+}

package/dist/transforms/camera/camera.js

@@ -0,0 +1,60 @@
+import { AABB } from "../../geometry/aabb.js";
+import { create2DBasis } from "../../geometry/transformations.js";
+import { Vec3, vec3 } from "../../geometry/vec3.js";
+import { toDegrees } from "../../math/units.js";
+export class Camera {
+    constructor(options) {
+        let { position, lookAt, direction, rotation = 0, resolution } = options;
+        if (!lookAt && !direction)
+            throw new Error("At least one of lookAt and direction must be specified");
+        if (lookAt && direction)
+            throw new Error("Only one of lookAt and direction can be specified");
+        direction ?? (direction = Vec3.subtract(lookAt, position).normalize());
+        this.position = position;
+        this.lookAt = lookAt ?? Vec3.add(position, direction);
+        this.rotation = rotation;
+        this.resolution = resolution;
+        const aspectRatio = resolution.width / resolution.height;
+        this.viewbox = aspectRatio > 1 ? new AABB(-aspectRatio, aspectRatio, -1, 1) : new AABB(-1, 1, -1 / aspectRatio, 1 / aspectRatio);
+        const [i, j] = create2DBasis(direction);
+        this.viewBasis = [i, j, direction];
+        this.direction = direction;
+        this.matrix = this.computeMatrix();
+    }
+    computeMatrix() {
+        const { resolution: { width, height }, rotation } = this;
+        const minDimension = Math.min(width, height);
+        // Read backwards, starting on last comment and moving updwards
+        return new DOMMatrix()
+            // Finally, translate position to give [0, width] x [0, height]
+            .translateSelf(width / 2, height / 2)
+            // Since the position comes from a normalized coordinate system with correct aspect ratio,
+            // multiplying by the smaller dimension will give [-width/2, width/2] x [-height/2, height/2]
+            .scaleSelf(minDimension / 2)
+            // Rotates clockwise (when camera rotates, rendered content rotates the opposite direction)
+            // Important: rotateSelf expects degrees, not radians
+            .rotateSelf(-toDegrees(rotation));
+        // Here position is in aspect ratio-corrected screen space
+        // [-1, 1] x [-1/asp, 1/asp] if asp < 1
+        // [-asp, asp] x [-1, 1] if asp > 1
+    }
+    worldVectorToView(worldVector) {
+        const [i, j, k] = this.viewBasis;
+        return vec3(i.dot(worldVector), j.dot(worldVector), k.dot(worldVector));
+    }
+    worldPositionToView(worldPosition) {
+        return this.worldVectorToView(Vec3.subtract(worldPosition, this.position));
+    }
+    worldVectorToScreen(worldVector) {
+        return this.projectViewToScreen(this.worldVectorToView(worldVector));
+    }
+    worldPositionToScreen(worldPosition) {
+        return this.projectViewToScreen(this.worldPositionToView(worldPosition));
+    }
+    // Idea: determine ray that corresponds to screenPosition and compute its intersection with plane at z
+    mapScreenToXYPlane(screenPosition, z = 0) {
+        const ray = this.getRayAtScreenPosition(screenPosition);
+        const timeOfIntersection = (z - ray.point.z) / ray.direction.z;
+        return ray.interpolate(timeOfIntersection);
+    }
+}

package/dist/transforms/camera/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./camera.js";
+export * from "./perspective.js";
+export * from "./orthographic.js";

package/dist/transforms/camera/index.js

@@ -0,0 +1,3 @@
+export * from "./camera.js";
+export * from "./perspective.js";
+export * from "./orthographic.js";

package/dist/transforms/camera/orthographic.d.ts

@@ -0,0 +1,15 @@
+import { Ray3 } from "../../geometry/ray3.js";
+import { Vec2 } from "../../geometry/vec2.js";
+import { Vec3 } from "../../geometry/vec3.js";
+import { CameraOptions, Camera } from "./camera.js";
+export type OrthographicCameraOptions = CameraOptions & {
+    viewport: number;
+};
+export declare class OrthographicCamera extends Camera {
+    viewport: number;
+    planarBasis: [Vec2, Vec2];
+    constructor(options: OrthographicCameraOptions);
+    projectViewToScreen(viewPosition: Vec3): Vec3;
+    unprojectScreenToView(screenPosition: Vec3): Vec3;
+    getRayAtScreenPosition(screenPosition: Vec2): Ray3;
+}

package/dist/transforms/camera/orthographic.js

@@ -0,0 +1,31 @@
+import { Ray3 } from "../../geometry/ray3.js";
+import { vec2 } from "../../geometry/vec2.js";
+import { Vec3, vec3 } from "../../geometry/vec3.js";
+import { Camera } from "./camera.js";
+export class OrthographicCamera extends Camera {
+    constructor(options) {
+        super(options);
+        this.viewport = options.viewport;
+        const [i, j, k] = this.viewBasis;
+        const xInv = vec2(i.x - k.x / k.z * i.z, j.x - k.x / k.z * j.z);
+        const yInv = vec2(i.y - k.y / k.z * i.z, j.y - k.y / k.z * j.z);
+        this.planarBasis = [xInv, yInv];
+    }
+    projectViewToScreen(viewPosition) {
+        const { viewport } = this;
+        const { x, y, z } = viewPosition;
+        const coeff = 2 / viewport;
+        return vec3(coeff * x, coeff * y, z);
+    }
+    unprojectScreenToView(screenPosition) {
+        const { position, viewport } = this;
+        const [i, j, k] = this.viewBasis;
+        const coeff = viewport / 2;
+        return Vec3.add(position, Vec3.multiply(i, coeff * screenPosition.x), Vec3.multiply(j, coeff * screenPosition.y), Vec3.multiply(k, screenPosition.z));
+    }
+    getRayAtScreenPosition(screenPosition) {
+        const position = this.unprojectScreenToView(screenPosition.toVec3(0));
+        const direction = this.viewBasis[2];
+        return new Ray3(position, direction);
+    }
+}

package/dist/transforms/camera/perspective.d.ts

@@ -0,0 +1,16 @@
+import { Ray3 } from "../../geometry/ray3.js";
+import { Vec2 } from "../../geometry/vec2.js";
+import { Vec3 } from "../../geometry/vec3.js";
+import { CameraOptions, Camera } from "./camera.js";
+export type PerspectiveCameraOptions = CameraOptions & {
+    viewport?: number;
+    fov?: number;
+};
+export declare class PerspectiveCamera extends Camera {
+    private coefficient;
+    fov: number;
+    constructor(options: PerspectiveCameraOptions);
+    projectViewToScreen(viewPosition: Vec3): Vec3;
+    unprojectScreenToView(screenPosition: Vec3): Vec3;
+    getRayAtScreenPosition(screenPosition: Vec2): Ray3;
+}

package/dist/transforms/camera/perspective.js

@@ -0,0 +1,40 @@
+import { Ray3 } from "../../geometry/ray3.js";
+import { Vec3, vec3 } from "../../geometry/vec3.js";
+import { Camera } from "./camera.js";
+export class PerspectiveCamera extends Camera {
+    constructor(options) {
+        super(options);
+        const { viewport, fov } = options;
+        if (viewport !== undefined && fov !== undefined) {
+            throw new Error("Only one of fov and viewport must be specified");
+        }
+        else if (viewport !== undefined) {
+            const distanceToLookAt = Vec3.distance(this.position, this.lookAt);
+            this.coefficient = 2 * distanceToLookAt / viewport;
+            this.fov = 2 * Math.atan(1 / this.coefficient);
+        }
+        else if (fov !== undefined) {
+            this.fov = fov;
+            this.coefficient = 1 / Math.tan(fov / 2);
+        }
+        else {
+            throw new Error("Either fov or viewport must be specified");
+        }
+    }
+    projectViewToScreen(viewPosition) {
+        const { coefficient } = this;
+        const { x, y, z } = viewPosition;
+        return vec3(coefficient * x / z, coefficient * y / z, z);
+    }
+    unprojectScreenToView(screenPosition) {
+        const { position, coefficient } = this;
+        const [i, j, k] = this.viewBasis;
+        return Vec3.add(position, Vec3.multiply(i, screenPosition.x / coefficient), Vec3.multiply(j, screenPosition.y / coefficient), Vec3.multiply(k, screenPosition.z));
+    }
+    getRayAtScreenPosition(screenPosition) {
+        const { position } = this;
+        const offsetPosition = this.unprojectScreenToView(screenPosition.toVec3(1));
+        const direction = Vec3.subtract(offsetPosition, position).normalize();
+        return new Ray3(position, direction);
+    }
+}

package/dist/transforms/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./camera/index.js";
+export * from "./normalize-transform.js";

package/dist/transforms/index.js

@@ -0,0 +1,2 @@
+export * from "./camera/index.js";
+export * from "./normalize-transform.js";

package/dist/transforms/normalize-transform.d.ts

@@ -0,0 +1,12 @@
+import { Vec2 } from "../geometry/vec2.js";
+import { Resolution } from "../utilities/resolution.js";
+export type NormalizeTransformOptions = {
+    center?: Vec2;
+    viewport?: number;
+    resolution: Resolution;
+};
+export declare function normalizeTransform(options: NormalizeTransformOptions): {
+    matrix: DOMMatrix;
+    toPixel: (worldUnits: number) => number;
+    fromPixel: (pixelUnits: number) => number;
+};

package/dist/transforms/normalize-transform.js

@@ -0,0 +1,20 @@
+import { vec2 } from "../geometry/vec2.js";
+export function normalizeTransform(options) {
+    const { center = vec2(0), viewport = 2, resolution } = options;
+    const { width, height } = resolution;
+    const aspectRatio = width / height;
+    const [scaleX, scaleY] = (aspectRatio > 1 ? [aspectRatio * viewport, viewport] : [viewport, viewport / aspectRatio]);
+    const matrix = new DOMMatrix();
+    matrix
+        .translateSelf(width / 2, height / 2)
+        .scaleSelf(width / scaleX, height / scaleY)
+        .translateSelf(-center.x, -center.y);
+    const scale = width / scaleX;
+    const scaleToPixel = (worldUnits) => scale * worldUnits;
+    const scaleFromPixel = (pixelUnits) => pixelUnits / scale;
+    return {
+        matrix,
+        toPixel: scaleToPixel,
+        fromPixel: scaleFromPixel
+    };
+}

package/dist/types.d.ts

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

package/dist/types.js

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

package/dist/utilities/create-frame.d.ts

@@ -0,0 +1,2 @@
+import { AABB } from "../geometry/aabb.js";
+export declare function createFrame(extent: AABB, margin: number): AABB;

package/dist/utilities/create-frame.js

@@ -0,0 +1,6 @@
+export function createFrame(extent, margin) {
+    const { width, height } = extent;
+    const minDimension = Math.min(width, height);
+    const marginSize = 0.5 * margin * minDimension;
+    return extent.clone().grow(-marginSize);
+}

package/dist/utilities/ensure-array.d.ts

@@ -0,0 +1 @@
+export declare function ensureArray<T>(value: T | Array<T>): T[];

package/dist/utilities/ensure-array.js

@@ -0,0 +1,3 @@
+export function ensureArray(value) {
+    return Array.isArray(value) ? value : [value];
+}

package/dist/utilities/idw-interpolator.d.ts

@@ -0,0 +1,9 @@
+import { Vec2 } from "../geometry/vec2.js";
+export type CreateIDWInterpolatorOptions = {
+    data: Array<{
+        position: Vec2;
+        value: number;
+    }>;
+    power?: number;
+};
+export declare function createIDWInterpolator(options: CreateIDWInterpolatorOptions): (v: Vec2, power?: number) => number;

package/dist/utilities/idw-interpolator.js

@@ -0,0 +1,18 @@
+const { pow } = Math;
+export function createIDWInterpolator(options) {
+    const { data, power: globalPower = 2 } = options;
+    return (v, power = globalPower) => {
+        let sum = 0;
+        let weightSum = 0;
+        const effectivePower = -0.5 * power;
+        for (const { position, value } of data) {
+            const distanceSquared = v.distanceSquared(position);
+            const weight = pow(distanceSquared, effectivePower);
+            if (!isFinite(weight))
+                return value;
+            sum += weight * value;
+            weightSum += weight;
+        }
+        return sum / weightSum;
+    };
+}

package/dist/utilities/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./marching-squares.js";
+export { type RNG, createRNG } from "./rng.js";
+export { Poissonnier, type PoissonnierOptions, type PointData, type GenerateFixedSizeSampleOptions } from "./poisson/poissonnier.js";
+export * from "./resolution.js";
+export * from "./idw-interpolator.js";
+export * from "./create-frame.js";
+export * from "./point-sampler.js";
+export * from "./ensure-array.js";

package/dist/utilities/index.js

@@ -0,0 +1,8 @@
+export * from "./marching-squares.js";
+export { createRNG } from "./rng.js";
+export { Poissonnier } from "./poisson/poissonnier.js";
+export * from "./resolution.js";
+export * from "./idw-interpolator.js";
+export * from "./create-frame.js";
+export * from "./point-sampler.js";
+export * from "./ensure-array.js";