@freshcoat-js/for-print 0.1.0

package/src/balance.js

@@ -0,0 +1,104 @@
+// Turning a gray-ramp reading into a cast correction.
+//
+// The gray chart sends neutral and the printer returns something that is not,
+// measured against the bare card so the camera and the light are already divided
+// out (see ./measure). What is left is the printer's own cast, and this is where
+// it becomes a correction the render can apply.
+//
+// The method is an inversion, not a fit to a formula. Each step's measured curve
+// says what the printer did with a level; asking that curve what level it WOULD
+// have printed as neutral gives the level to send instead. Doing that at every
+// step and reading off the exponent that connects them is the whole of it.
+import { assessCalibration } from "./calibration.js";
+const median = (xs) => {
+    const s = [...xs].sort((a, b) => a - b);
+    const mid = s.length >> 1;
+    return s.length % 2 ? s[mid] : (s[mid - 1] + s[mid]) / 2;
+};
+// The neutral steps of a reading, one entry per level sent, repeats averaged and
+// in order. Averaging the repeats is what the three passes across the card were
+// for: the cast is what they agree on, the disagreement is the sheet.
+function neutralSteps(reading) {
+    const byLevel = new Map();
+    for (const p of reading.patches) {
+        if (p.role !== "measure")
+            continue;
+        if (p.sent[0] !== p.sent[1] || p.sent[1] !== p.sent[2])
+            continue;
+        const at = byLevel.get(p.sent[0]) ?? { sum: [0, 0, 0], n: 0 };
+        at.sum[0] += p.measured[0];
+        at.sum[1] += p.measured[1];
+        at.sum[2] += p.measured[2];
+        at.n += 1;
+        byLevel.set(p.sent[0], at);
+    }
+    return [...byLevel.entries()]
+        .map(([level, at]) => ({
+        level,
+        measured: [at.sum[0] / at.n, at.sum[1] / at.n, at.sum[2] / at.n],
+    }))
+        .sort((a, b) => a.level - b.level);
+}
+// The level that would have printed `value` on this channel, by interpolating
+// between the two measured steps that bracket it. Null when the channel never
+// printed anything that dark or that light — the correction cannot be derived
+// past the ends of what was measured, and guessing there is how a profile starts
+// inventing density the ribbon does not have.
+function inputFor(steps, channel, value) {
+    for (let i = 1; i < steps.length; i++) {
+        const lo = steps[i - 1];
+        const hi = steps[i];
+        const a = lo.measured[channel];
+        const b = hi.measured[channel];
+        if (value < Math.min(a, b) || value > Math.max(a, b))
+            continue;
+        if (a === b)
+            return lo.level;
+        return lo.level + ((value - a) / (b - a)) * (hi.level - lo.level);
+    }
+    return null;
+}
+// Levels this close to the ends are left out of the fit. The exponent comes from
+// a ratio of logarithms, and ln(level/255) goes to zero at white and to negative
+// infinity at black — a level or two of camera noise there swings the answer
+// wildly, while the midtones carry the same information cleanly.
+const FIT_MIN = 24;
+const FIT_MAX = 232;
+export function fitChannelBalance(reading, options = {}) {
+    if (!options.allowUnsafe && !assessCalibration(reading).usable)
+        return null;
+    const steps = neutralSteps(reading);
+    if (steps.length < 4)
+        return null;
+    const exponents = [0, 1, 2].map((channel) => {
+        const ks = [];
+        for (const step of steps) {
+            if (step.level < FIT_MIN || step.level > FIT_MAX)
+                continue;
+            // The neutral this printer can actually make at this level: the average of
+            // what its three channels did. Correcting toward that costs no density,
+            // where correcting toward the level that was SENT would ask the ribbon for
+            // ink it does not have and clip instead.
+            const target = (step.measured[0] + step.measured[1] + step.measured[2]) / 3;
+            const input = inputFor(steps, channel, target);
+            if (input === null || input <= 0 || input >= 255)
+                continue;
+            ks.push(Math.log(input / 255) / Math.log(step.level / 255));
+        }
+        // Median, not mean: one patch spoiled by a speck or a highlight should not
+        // move the correction the other fifteen agree on.
+        return ks.length ? median(ks) : 1;
+    });
+    return {
+        r: round(exponents[0]),
+        g: round(exponents[1]),
+        b: round(exponents[2]),
+    };
+}
+const round = (v) => Math.round(v * 1000) / 1000;
+// Whether a balance is worth applying at all. A reading always produces some
+// number; below this the correction is smaller than the noise it was measured
+// through, and storing it would dress up a rounding error as a measurement.
+export function isBalanceMeaningful(balance) {
+    return [balance.r, balance.g, balance.b].some((k) => Math.abs(k - 1) >= 0.01);
+}

package/src/calibration.d.ts

@@ -0,0 +1,13 @@
+import { type ChartReading } from "./measure.js";
+export type CalibrationBlocker = "stock-clipped" | "patches-missed" | "uneven-lighting" | "uneven-print" | "not-enough-gray-steps";
+export type CalibrationAssessment = {
+    usable: boolean;
+    blockers: CalibrationBlocker[];
+    metrics: {
+        graySteps: number;
+        missedPatches: number;
+        lightSpread: number;
+        repeatSpread: number;
+    };
+};
+export declare function assessCalibration(reading: ChartReading): CalibrationAssessment;

package/src/calibration.js

@@ -0,0 +1,42 @@
+// Whether a chart reading is evidence good enough to turn into a printer
+// correction. This is deliberately library policy rather than a UI convention:
+// callers other than the chart tool must not be able to save a confident-looking
+// profile from a blown-out or uneven photograph.
+import { repeatSpread } from "./measure.js";
+const MIN_GRAY_STEPS = 4;
+const MAX_REPEAT_SPREAD = 4;
+// Assess a chart independently of any particular UI. A little stock variation
+// is normal camera noise; when it is both material and comparable to the
+// repeated-patch variation, it means the light—not the printer—accounts for the
+// measurement. A steady light with wide repeated-patch variation is instead a
+// printer consistency problem. Neither should become a profile.
+export function assessCalibration(reading) {
+    const graySteps = new Set(reading.patches
+        .filter((p) => p.role === "measure" &&
+        p.sent[0] === p.sent[1] &&
+        p.sent[1] === p.sent[2])
+        .map((p) => p.sent[0])).size;
+    const spread = repeatSpread(reading);
+    const lightBound = reading.lightSpread >= Math.max(2, spread * 0.6);
+    const blockers = [];
+    if (reading.stockClipped)
+        blockers.push("stock-clipped");
+    if (reading.missed.length > 0)
+        blockers.push("patches-missed");
+    if (graySteps < MIN_GRAY_STEPS)
+        blockers.push("not-enough-gray-steps");
+    if (lightBound)
+        blockers.push("uneven-lighting");
+    else if (spread >= MAX_REPEAT_SPREAD)
+        blockers.push("uneven-print");
+    return {
+        usable: blockers.length === 0,
+        blockers,
+        metrics: {
+            graySteps,
+            missedPatches: reading.missed.length,
+            lightSpread: reading.lightSpread,
+            repeatSpread: spread,
+        },
+    };
+}

package/src/chart.d.ts

@@ -0,0 +1,37 @@
+import { type GroupNode } from "@freshcoat-js/engine";
+export type RGB = [number, number, number];
+export type Box = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export type PatchRole = "measure" | "stock" | "fiducial";
+export type ChartPatch = Box & {
+    id: string;
+    rgb: RGB;
+    role: PatchRole;
+    repeatOf?: string;
+};
+export type ChartSpec = {
+    id: string;
+    name: string;
+    purpose: string;
+    width: number;
+    height: number;
+    patches: ChartPatch[];
+    registration: [Point, Point, Point, Point];
+};
+export type Point = {
+    x: number;
+    y: number;
+};
+export declare function layoutGrid(count: number, area: Box, gutter?: number): Box[];
+export declare function hslToRgb(h: number, s: number, l: number): RGB;
+export declare function grayBalanceChart(stepCount?: number): ChartSpec;
+export declare function toneWedgeChart(stepCount?: number): ChartSpec;
+export declare function hueSweepChart(hueCount?: number, lightnesses?: number[]): ChartSpec;
+export declare function chromaRampChart(hues?: number[], stepCount?: number): ChartSpec;
+export declare function latticeCharts(size?: number, perCard?: number): ChartSpec[];
+export declare const DIAGNOSTIC_CHARTS: () => ChartSpec[];
+export declare function chartScene(spec: ChartSpec): GroupNode;

package/src/chart.js

@@ -0,0 +1,255 @@
+// Measurement charts — the printed half of characterizing a card printer.
+//
+// A chart is a SPEC first: patch geometry plus the RGB that was sent to the
+// printer for each one. The spec is what makes a captured photo readable, so it
+// is shared by both ends — `chartScene` renders it to a card, `readChart`
+// (./measure) samples the same patches back out of a photograph. Nothing about
+// the chart's layout is written down twice.
+//
+// Building a freshcoat node tree is data, not rasterizing: for-print still owns
+// no canvas. The caller paints the tree.
+import { createFrame, createRect, } from "@freshcoat-js/engine";
+import { CR80_LONG, CR80_SHORT } from "./geometry.js";
+// 3mm margin, a 2.5mm fiducial and a hairline gutter, all at 300dpi. The patch
+// field starts inside the fiducial band so a corner mark is never half a patch.
+const MARGIN = 36;
+const FIDUCIAL = 30;
+const GUTTER = 6;
+function innerArea(width, height) {
+    const inset = MARGIN + FIDUCIAL + GUTTER;
+    return {
+        x: inset,
+        y: inset,
+        width: width - inset * 2,
+        height: height - inset * 2,
+    };
+}
+// Lay `count` cells into `area`, choosing the column count whose cell aspect sits
+// closest to square. Cells fill the area, so patches are as large as the card
+// allows — a bigger patch survives a phone camera's noise and a slight misclick.
+export function layoutGrid(count, area, gutter = GUTTER) {
+    if (count <= 0)
+        return [];
+    let best = { cols: 1, score: Number.POSITIVE_INFINITY };
+    for (let cols = 1; cols <= count; cols++) {
+        const rows = Math.ceil(count / cols);
+        const w = (area.width - gutter * (cols - 1)) / cols;
+        const h = (area.height - gutter * (rows - 1)) / rows;
+        if (w <= 0 || h <= 0)
+            continue;
+        // Distance from square, plus a nudge against layouts that leave a ragged
+        // final row — a half-empty row wastes patch size for nothing.
+        const score = Math.abs(Math.log(w / h)) + (cols * rows - count) / count;
+        if (score < best.score)
+            best = { cols, score };
+    }
+    const cols = best.cols;
+    const rows = Math.ceil(count / cols);
+    const w = (area.width - gutter * (cols - 1)) / cols;
+    const h = (area.height - gutter * (rows - 1)) / rows;
+    return Array.from({ length: count }, (_, i) => ({
+        x: area.x + (i % cols) * (w + gutter),
+        y: area.y + Math.floor(i / cols) * (h + gutter),
+        width: w,
+        height: h,
+    }));
+}
+const hex = ([r, g, b]) => `#${[r, g, b]
+    .map((v) => Math.max(0, Math.min(255, Math.round(v)))
+    .toString(16)
+    .padStart(2, "0"))
+    .join("")}`;
+// HSL → RGB, the generator for the hue and chroma sweeps. Chart colors are
+// authored in HSL because the sweeps vary one axis at a time by definition.
+export function hslToRgb(h, s, l) {
+    const c = (1 - Math.abs(2 * l - 1)) * s;
+    const hp = (((h % 360) + 360) % 360) / 60;
+    const x = c * (1 - Math.abs((hp % 2) - 1));
+    const [r, g, b] = hp < 1
+        ? [c, x, 0]
+        : hp < 2
+            ? [x, c, 0]
+            : hp < 3
+                ? [0, c, x]
+                : hp < 4
+                    ? [0, x, c]
+                    : hp < 5
+                        ? [x, 0, c]
+                        : [c, 0, x];
+    const m = l - c / 2;
+    return [
+        Math.round((r + m) * 255),
+        Math.round((g + m) * 255),
+        Math.round((b + m) * 255),
+    ];
+}
+function fiducials(width, height) {
+    const corners = [
+        ["tl", MARGIN, MARGIN],
+        ["tr", width - MARGIN - FIDUCIAL, MARGIN],
+        ["br", width - MARGIN - FIDUCIAL, height - MARGIN - FIDUCIAL],
+        ["bl", MARGIN, height - MARGIN - FIDUCIAL],
+    ];
+    const patches = corners.map(([id, x, y]) => ({
+        id: `fid-${id}`,
+        rgb: [0, 0, 0],
+        role: "fiducial",
+        x,
+        y,
+        width: FIDUCIAL,
+        height: FIDUCIAL,
+    }));
+    const center = (p) => ({
+        x: p.x + p.width / 2,
+        y: p.y + p.height / 2,
+    });
+    return {
+        patches,
+        registration: [
+            center(patches[0]),
+            center(patches[1]),
+            center(patches[2]),
+            center(patches[3]),
+        ],
+    };
+}
+// Assemble a chart from a list of colors. Stock patches are spliced in at both
+// ends and the middle rather than parked in one corner: the white reference has
+// to sample the same lighting the measured patches do, and a single corner patch
+// under a gradient of window light would bias every reading against it.
+function build(id, name, purpose, colors, stockCount = 4, width = CR80_LONG, height = CR80_SHORT) {
+    const withStock = [];
+    const every = Math.max(1, Math.floor(colors.length / Math.max(1, stockCount - 1)));
+    let stock = 0;
+    colors.forEach((c, i) => {
+        if (stock < stockCount && i % every === 0) {
+            withStock.push({
+                id: `stock-${stock}`,
+                rgb: [255, 255, 255],
+                role: "stock",
+            });
+            stock++;
+        }
+        withStock.push({ ...c, role: "measure" });
+    });
+    while (stock < stockCount) {
+        withStock.push({
+            id: `stock-${stock}`,
+            rgb: [255, 255, 255],
+            role: "stock",
+        });
+        stock++;
+    }
+    const boxes = layoutGrid(withStock.length, innerArea(width, height));
+    const marks = fiducials(width, height);
+    return {
+        id,
+        name,
+        purpose,
+        width,
+        height,
+        patches: [
+            ...withStock.map((c, i) => ({ ...c, ...boxes[i] })),
+            ...marks.patches,
+        ],
+        registration: marks.registration,
+    };
+}
+const steps = (n, f) => Array.from({ length: n }, (_, i) => f(n === 1 ? 0 : i / (n - 1)));
+// ── The four diagnostics ───────────────────────────────────────────────────
+//
+// None of these needs a reference target. Each is read against the bare stock in
+// the same photograph, or against the other patches on the same card, so an
+// uncalibrated phone answers all four.
+// Neutral in, neutral out — the chart that finds a color cast. Every step is
+// printed three times across the card, so an uneven sheet is visible as
+// disagreement between the repeats rather than being read as a cast.
+export function grayBalanceChart(stepCount = 16) {
+    const base = steps(stepCount, (t) => {
+        const v = Math.round(t * 255);
+        return [v, v, v];
+    });
+    const colors = [0, 1, 2].flatMap((pass) => base.map((rgb, i) => ({
+        id: `gray-${i}-p${pass}`,
+        rgb,
+        ...(pass > 0 ? { repeatOf: `gray-${i}-p0` } : {}),
+    })));
+    return build("gray-balance", "Gray balance", "Neutral steps printed three times across the card. Any color in these is the printer's cast; disagreement between the three passes is the sheet being uneven.", colors);
+}
+// Per-channel ramps — the printer's transfer curve, one primary at a time.
+export function toneWedgeChart(stepCount = 9) {
+    const axes = [
+        ["r", (t) => [Math.round(t * 255), 0, 0]],
+        ["g", (t) => [0, Math.round(t * 255), 0]],
+        ["b", (t) => [0, 0, Math.round(t * 255)]],
+        ["c", (t) => [0, Math.round(t * 255), Math.round(t * 255)]],
+        ["m", (t) => [Math.round(t * 255), 0, Math.round(t * 255)]],
+        ["y", (t) => [Math.round(t * 255), Math.round(t * 255), 0]],
+    ];
+    const colors = axes.flatMap(([name, f]) => steps(stepCount, f).map((rgb, i) => ({ id: `${name}-${i}`, rgb })));
+    return build("tone-wedge", "Tone wedges", "Each primary and secondary ramped on its own. Read where a ramp stops getting darker — that is the channel's real transfer curve, not the one the file assumes.", colors);
+}
+// Constant saturation and lightness, hue swept the whole way round. Whichever
+// hues come back rotated are the ones a correction has to hold.
+export function hueSweepChart(hueCount = 24, lightnesses = [0.4, 0.55, 0.7]) {
+    const colors = lightnesses.flatMap((l, li) => Array.from({ length: hueCount }, (_, i) => ({
+        id: `hue-${Math.round((i * 360) / hueCount)}-l${li}`,
+        rgb: hslToRgb((i * 360) / hueCount, 0.75, l),
+    })));
+    return build("hue-sweep", "Hue sweep", "One saturation, one lightness, every hue. Hues that come back turned are where the ribbon bends color — this is the chart that shows an indigo drifting toward magenta.", colors);
+}
+// Saturation ramps per hue. The step where a ramp stops getting more saturated is
+// the ribbon's gamut edge for that hue — the number a correction cannot guess.
+export function chromaRampChart(hues = [250, 270, 210, 0, 120, 40], stepCount = 10) {
+    const colors = hues.flatMap((h) => steps(stepCount, (t) => hslToRgb(h, t, 0.5)).map((rgb, i) => ({
+        id: `chroma-${h}-${i}`,
+        rgb,
+    })));
+    return build("chroma-ramp", "Chroma ramps", "Saturation ramped per hue. Where a ramp stops changing is that hue's gamut edge — how much saturation the ribbon can actually hold.", colors);
+}
+// ── The lattice ────────────────────────────────────────────────────────────
+// An N×N×N sample of the RGB cube, split across as many cards as it takes. This
+// is the input to a 3D LUT; the diagnostics above are for deciding whether you
+// need one. `perCard` caps patch count so patches stay big enough to photograph.
+export function latticeCharts(size = 5, perCard = 100) {
+    const colors = [];
+    const at = (i) => Math.round((i / (size - 1)) * 255);
+    for (let r = 0; r < size; r++) {
+        for (let g = 0; g < size; g++) {
+            for (let b = 0; b < size; b++) {
+                colors.push({
+                    id: `lat-${r}-${g}-${b}`,
+                    rgb: [at(r), at(g), at(b)],
+                });
+            }
+        }
+    }
+    const pages = Math.ceil(colors.length / perCard);
+    return Array.from({ length: pages }, (_, p) => build(`lattice-${size}-${p + 1}`, `Lattice ${size}³ — card ${p + 1} of ${pages}`, `Part ${p + 1} of an even ${size}×${size}×${size} sample of the RGB cube. Print and read every card; together they are the measurement a 3D LUT is built from.`, colors.slice(p * perCard, (p + 1) * perCard)));
+}
+export const DIAGNOSTIC_CHARTS = () => [
+    grayBalanceChart(),
+    toneWedgeChart(),
+    hueSweepChart(),
+    chromaRampChart(),
+];
+// ── Rendering ──────────────────────────────────────────────────────────────
+// The spec as a freshcoat scene. Deliberately flat: solid rects, no gradients,
+// no antialiased edges to average into a patch, and a white ground so unprinted
+// card reads as unprinted card.
+export function chartScene(spec) {
+    return createFrame({
+        pos: { x: 0, y: 0 },
+        size: { width: spec.width, height: spec.height },
+        background: createRect({
+            pos: { x: 0, y: 0 },
+            size: { width: spec.width, height: spec.height },
+            fills: [{ kind: "solid", color: "#ffffff" }],
+        }),
+        children: spec.patches.map((p) => createRect({
+            pos: { x: p.x, y: p.y },
+            size: { width: p.width, height: p.height },
+            fills: [{ kind: "solid", color: hex(p.rgb) }],
+        })),
+    });
+}

package/src/geometry.d.ts

@@ -0,0 +1,12 @@
+import type { CardOrientation, CropRegion } from "./types.js";
+export declare const CR80_LONG = 1012;
+export declare const CR80_SHORT = 638;
+export declare const CR80_ASPECT: number;
+export declare function defaultCropRegion(): CropRegion;
+export declare function cr80Dimensions(orientation: CardOrientation): {
+    width: number;
+    height: number;
+};
+export declare function cr80CropAspect(orientation: CardOrientation): number;
+export declare function detectOrientation(imgWidth: number, imgHeight: number): CardOrientation;
+export declare function fitCr80CropToImage(imgWidth: number, imgHeight: number, orientation?: CardOrientation): CropRegion;

package/src/geometry.js

@@ -0,0 +1,45 @@
+// CR80 card dimensions at 300dpi
+export const CR80_LONG = 1012; // 3.375"
+export const CR80_SHORT = 638; // 2.125"
+export const CR80_ASPECT = CR80_LONG / CR80_SHORT; // ~1.586
+export function defaultCropRegion() {
+    return { x: 0, y: 0, width: 1, height: 1, orientation: "landscape" };
+}
+// Get CR80 output dimensions for a given orientation
+export function cr80Dimensions(orientation) {
+    return orientation === "landscape"
+        ? { width: CR80_LONG, height: CR80_SHORT }
+        : { width: CR80_SHORT, height: CR80_LONG };
+}
+// Get the crop aspect ratio for a given orientation
+export function cr80CropAspect(orientation) {
+    return orientation === "landscape" ? CR80_ASPECT : 1 / CR80_ASPECT;
+}
+// Auto-detect orientation from image aspect ratio
+export function detectOrientation(imgWidth, imgHeight) {
+    return imgWidth >= imgHeight ? "landscape" : "portrait";
+}
+// Fit a CR80 rectangle centered within the image
+export function fitCr80CropToImage(imgWidth, imgHeight, orientation) {
+    const orient = orientation ?? detectOrientation(imgWidth, imgHeight);
+    const targetAspect = cr80CropAspect(orient);
+    const imgAspect = imgWidth / imgHeight;
+    if (imgAspect > targetAspect) {
+        const cropWidth = targetAspect / imgAspect;
+        return {
+            x: (1 - cropWidth) / 2,
+            y: 0,
+            width: cropWidth,
+            height: 1,
+            orientation: orient,
+        };
+    }
+    const cropHeight = imgAspect / targetAspect;
+    return {
+        x: 0,
+        y: (1 - cropHeight) / 2,
+        width: 1,
+        height: cropHeight,
+        orientation: orient,
+    };
+}

package/src/index.d.ts

@@ -0,0 +1,10 @@
+export { analyzePixels, analyzeStats, buildRecommendation, correctionMatrix, type ImageStats, measureGamut, } from "./analyze.js";
+export { type FitChannelBalanceOptions, fitChannelBalance, isBalanceMeaningful, } from "./balance.js";
+export { assessCalibration, type CalibrationAssessment, type CalibrationBlocker, } from "./calibration.js";
+export { type Box, type ChartPatch, type ChartSpec, chartScene, chromaRampChart, DIAGNOSTIC_CHARTS, grayBalanceChart, hslToRgb, hueSweepChart, latticeCharts, layoutGrid, type PatchRole, type Point, type RGB, toneWedgeChart, } from "./chart.js";
+export { CR80_ASPECT, CR80_LONG, CR80_SHORT, cr80CropAspect, cr80Dimensions, defaultCropRegion, detectOrientation, fitCr80CropToImage, } from "./geometry.js";
+export { applyHomography, type ChartReading, grayCast, type Homography, homographyFrom, type PatchReading, readChart, readingToCsv, repeatSpread, } from "./measure.js";
+export { analyzeScene, classifyIntent, type ImageSampler, type LayerIntent, type LayerIntentResolver, type PlanPolicy, planScene, printAdjust, } from "./plan.js";
+export { NO_PROCESSING, YMCKO_FINISH, YMCKO_PRESET } from "./presets.js";
+export { createPrintProfile, type PrintProfile, type PrintProfileConditions, type PrintProfileCreation, type PrintProfileDetails, parsePrintProfile, profileCacheKey, UNMEASURED_PROFILE, withProfile, } from "./profile.js";
+export type { CardOrientation, ChannelBalance, CropRegion, GamutReport, ImageAnalysis, PixelData, PrintOptimizeOptions, } from "./types.js";

package/src/index.js

@@ -0,0 +1,13 @@
+// @freshcoat-js/for-print — an ANALYSIS module. Image statistics + print intent in,
+// freshcoat adjustments out. It holds no canvas, no rasterizer, and no pixel
+// output: freshcoat applies the per-layer `Adjust`s and the whole-frame
+// `FrameFinish` this module recommends. Pure and engine-agnostic throughout.
+export { analyzePixels, analyzeStats, buildRecommendation, correctionMatrix, measureGamut, } from "./analyze.js";
+export { fitChannelBalance, isBalanceMeaningful, } from "./balance.js";
+export { assessCalibration, } from "./calibration.js";
+export { chartScene, chromaRampChart, DIAGNOSTIC_CHARTS, grayBalanceChart, hslToRgb, hueSweepChart, latticeCharts, layoutGrid, toneWedgeChart, } from "./chart.js";
+export { CR80_ASPECT, CR80_LONG, CR80_SHORT, cr80CropAspect, cr80Dimensions, defaultCropRegion, detectOrientation, fitCr80CropToImage, } from "./geometry.js";
+export { applyHomography, grayCast, homographyFrom, readChart, readingToCsv, repeatSpread, } from "./measure.js";
+export { analyzeScene, classifyIntent, planScene, printAdjust, } from "./plan.js";
+export { NO_PROCESSING, YMCKO_FINISH, YMCKO_PRESET } from "./presets.js";
+export { createPrintProfile, parsePrintProfile, profileCacheKey, UNMEASURED_PROFILE, withProfile, } from "./profile.js";

package/src/measure.d.ts

@@ -0,0 +1,25 @@
+import type { ChartPatch, ChartSpec, Point, RGB } from "./chart.js";
+import type { PixelData } from "./types.js";
+export type Homography = number[];
+export declare function homographyFrom(from: [Point, Point, Point, Point], to: [Point, Point, Point, Point]): Homography | null;
+export declare function applyHomography(h: Homography, p: Point): Point;
+export type PatchReading = {
+    id: string;
+    role: ChartPatch["role"];
+    sent: RGB;
+    raw: RGB;
+    measured: RGB;
+    repeatOf?: string;
+};
+export type ChartReading = {
+    chartId: string;
+    patches: PatchReading[];
+    stock: RGB;
+    stockClipped: boolean;
+    lightSpread: number;
+    missed: string[];
+};
+export declare function readChart(image: PixelData, spec: ChartSpec, corners: [Point, Point, Point, Point]): ChartReading | null;
+export declare function grayCast(reading: ChartReading): RGB;
+export declare function repeatSpread(reading: ChartReading): number;
+export declare function readingToCsv(reading: ChartReading): string;