@thi.ng/imago 0.1.0 → 0.3.0

package/proc.js

@@ -1,362 +1,91 @@
-import { typedArray } from "@thi.ng/api";
-import { isArrayBufferView, isNumber, isString } from "@thi.ng/checks";
+import { isArrayBufferView, isString } from "@thi.ng/checks";
 import { defmulti } from "@thi.ng/defmulti";
-import { illegalArgs } from "@thi.ng/errors";
-import { readText, writeFile, writeJSON } from "@thi.ng/file-io";
 import { ROOT } from "@thi.ng/logger";
-import { ABGR8888, GRAY8, Lane, intBuffer } from "@thi.ng/pixel";
-import {
-  ATKINSON,
-  BURKES,
-  DIFFUSION_2D,
-  DIFFUSION_COLUMN,
-  DIFFUSION_ROW,
-  FLOYD_STEINBERG,
-  JARVIS_JUDICE_NINKE,
-  SIERRA2,
-  STUCKI,
-  defBayer,
-  ditherWith,
-  orderedDither
-} from "@thi.ng/pixel-dither";
-import { join, resolve } from "node:path";
 import sharp, {} from "sharp";
-import {
-  GRAVITY_POSITION
-} from "./api.js";
-import { formatPath } from "./path.js";
-import {
-  coerceColor,
-  computeMargins,
-  computeSize,
-  ensureSize,
-  gravityPosition,
-  positionOrGravity
-} from "./units.js";
+import { blurProc } from "./ops/blur.js";
+import { compositeProc } from "./ops/composite.js";
+import { cropProc } from "./ops/crop.js";
+import { ditherProc } from "./ops/dither.js";
+import { exifProc } from "./ops/exif.js";
+import { extendProc } from "./ops/extend.js";
+import { gammaProc } from "./ops/gamma.js";
+import { grayscaleProc } from "./ops/grayscale.js";
+import { hsblProc } from "./ops/hsbl.js";
+import { nestProc } from "./ops/nest.js";
+import { outputProc } from "./ops/output.js";
+import { resizeProc } from "./ops/resize.js";
+import { rotateProc } from "./ops/rotate.js";
+import { ensureSize } from "./units.js";
+import { createTempFile, deleteFile } from "@thi.ng/file-io";
 const LOGGER = ROOT.childLogger("imgproc");
-const DITHER_KERNELS = {
-  atkinson: ATKINSON,
-  burkes: BURKES,
-  column: DIFFUSION_COLUMN,
-  diffusion: DIFFUSION_2D,
-  floyd: FLOYD_STEINBERG,
-  jarvis: JARVIS_JUDICE_NINKE,
-  row: DIFFUSION_ROW,
-  sierra: SIERRA2,
-  stucki: STUCKI
-};
-const processImage = async (src, procs, opts = {}, parentCtx) => {
+const processImage = async (src, specs, opts = {}, parentCtx) => {
   let img = isString(src) || isArrayBufferView(src.buffer) ? sharp(src) : src;
   const meta = await img.metadata();
   ensureSize(meta);
   const ctx = {
     path: isString(src) ? src : parentCtx?.path,
-    logger: opts?.logger || LOGGER,
+    outputs: parentCtx ? parentCtx.outputs : {},
+    logger: opts.logger || LOGGER,
     size: [meta.width, meta.height],
-    channels: meta.channels,
+    exif: parentCtx ? structuredClone(parentCtx.exif) : {},
     meta,
     opts
   };
-  let bake;
-  for (let proc of procs) {
-    ctx.logger.debug("processing spec:", proc);
-    [img, bake] = await process(proc, img, ctx);
-    if (!bake) {
-      ctx.logger.debug("skip baking processor's results...");
-      continue;
+  if (!parentCtx) {
+    if (meta.exif && opts.keepEXIF) {
+      ctx.logger.warn("TODO keeping input EXIF still unsupported");
+    }
+    if (meta.icc && opts.keepICC) {
+      ctx.logger.debug("storing input ICC profile...");
+      ctx.iccFile = createTempFile(meta.icc, ctx.logger);
     }
-    const { data, info } = await img.raw().toBuffer({ resolveWithObject: true });
-    ctx.size = [info.width, info.height];
-    ctx.channels = info.channels;
-    img = sharp(data, {
-      raw: {
-        width: info.width,
-        height: info.height,
-        channels: info.channels
-      }
-    });
   }
-  return img;
-};
-const process = defmulti(
-  (spec) => spec.type,
-  {},
-  {
-    blur: async (spec, input) => {
-      const { radius } = spec;
-      return [input.blur(1 + radius / 2), false];
-    },
-    composite: async (spec, input, ctx) => {
-      const { layers } = spec;
-      const layerSpecs = await Promise.all(
-        layers.map((l) => defLayer(l, input, ctx))
-      );
-      return [input.composite(layerSpecs), false];
-    },
-    crop: async (spec, input, ctx) => {
-      const { border, gravity, pos, size, ref, unit } = spec;
-      if (border == null && size == null)
-        illegalArgs("require `border` or `size` option");
-      if (border != null) {
-        const sides = computeMargins(border, ctx.size, ref, unit);
-        const [left2, right, top2, bottom] = sides;
-        return [
-          input.extract({
-            left: left2,
-            top: top2,
-            width: ctx.size[0] - left2 - right,
-            height: ctx.size[1] - top2 - bottom
-          }),
-          true
-        ];
-      }
-      const $size = computeSize(size, ctx.size, unit);
-      let left = 0, top = 0;
-      if (pos) {
-        ({ left = 0, top = 0 } = positionOrGravity(pos, gravity, $size, ctx.size, unit) || {});
-      } else {
-        [left, top] = gravityPosition(gravity || "c", $size, ctx.size);
-      }
-      return [
-        input.extract({
-          left,
-          top,
-          width: $size[0],
-          height: $size[1]
-        }),
-        true
-      ];
-    },
-    dither: async (spec, input, ctx) => {
-      let { mode, num = 2, rgb = false, size = 8 } = spec;
-      const [w, h] = ctx.size;
-      let raw;
-      if (rgb) {
-        const tmp = await input.clone().ensureAlpha(1).toColorspace("srgb").raw().toBuffer({ resolveWithObject: true });
-        raw = tmp.data.buffer;
-        rgb = tmp.info.channels === 4;
-      } else {
-        raw = (await input.clone().grayscale().raw().toBuffer()).buffer;
+  try {
+    let bake;
+    for (let spec of specs) {
+      ctx.logger.debug("processing spec:", spec);
+      [img, bake] = await processor(spec, img, ctx);
+      if (!bake) {
+        ctx.logger.debug("skip baking processor's results...");
+        continue;
       }
-      let img = intBuffer(
-        w,
-        h,
-        rgb ? ABGR8888 : GRAY8,
-        typedArray(rgb ? "u32" : "u8", raw)
-      );
-      if (mode === "bayer") {
-        orderedDither(
-          img,
-          defBayer(size),
-          rgb ? [num, num, num] : [num]
-        );
-      } else {
-        ditherWith(DITHER_KERNELS[mode], img, {
-          channels: rgb ? [Lane.RED, Lane.GREEN, Lane.BLUE] : void 0
-        });
-      }
-      if (!rgb)
-        img = img.as(ABGR8888);
-      return [
-        sharp(new Uint8Array(img.data.buffer), {
-          raw: {
-            width: img.width,
-            height: img.height,
-            channels: 4
-          }
-        }),
-        true
-      ];
-    },
-    exif: async (spec, input) => {
-      const { tags } = spec;
-      return [input.withExif(tags), false];
-    },
-    extend: async (spec, input, ctx) => {
-      const { bg, border, mode, ref, unit } = spec;
-      const sides = computeMargins(border, ctx.size, ref, unit);
-      const [left, right, top, bottom] = sides;
-      return [
-        input.extend({
-          left,
-          right,
-          top,
-          bottom,
-          background: coerceColor(bg || "#000"),
-          extendWith: mode
-        }),
-        true
-      ];
-    },
-    gamma: async (spec, input) => {
-      const { gamma } = spec;
-      return [input.gamma(gamma, 1), false];
-    },
-    gray: async (spec, input) => {
-      const { gamma } = spec;
-      if (gamma !== false) {
-        input = input.gamma(isNumber(gamma) ? gamma : void 0);
-      }
-      return [input.grayscale(), true];
-    },
-    hsbl: async (spec, input) => {
-      const { h = 0, s = 1, b = 1, l = 0 } = spec;
-      return [
-        input.modulate({
-          hue: h,
-          brightness: b,
-          saturation: s,
-          lightness: l * 255
-        }),
-        true
-      ];
-    },
-    nest: async (spec, input, ctx) => {
-      const { procs } = spec;
-      ctx.logger.debug("--- nest start ---");
-      await processImage(input.clone(), procs, ctx.opts, ctx);
-      ctx.logger.debug("--- nest end ---");
-      return [input, false];
-    },
-    output: async (spec, input, ctx) => {
-      const opts = spec;
-      const outDir = resolve(ctx.opts.outDir || ".");
-      let output = input.clone();
-      if (opts.raw) {
-        const { alpha = false, meta = false } = opts.raw !== true ? opts.raw : {};
-        if (alpha)
-          output = output.ensureAlpha();
-        const { data, info } = await output.raw().toBuffer({ resolveWithObject: true });
-        const path = join(outDir, formatPath(opts.path, data, ctx));
-        writeFile(path, data, null, ctx.logger);
-        if (meta) {
-          writeJSON(
-            path + ".meta.json",
-            info,
-            void 0,
-            void 0,
-            ctx.logger
-          );
+      const { data, info } = await img.raw().toBuffer({ resolveWithObject: true });
+      ctx.size = [info.width, info.height];
+      img = sharp(data, {
+        raw: {
+          width: info.width,
+          height: info.height,
+          channels: info.channels
         }
-        return [input, false];
-      }
-      let format = /\.(\w+)$/.exec(opts.path)?.[1];
-      switch (format) {
-        case "avif":
-          if (opts.avif)
-            output = output.avif(opts.avif);
-          break;
-        case "gif":
-          if (opts.gif)
-            output = output.gif(opts.gif);
-          break;
-        case "jpg":
-        case "jpeg":
-          if (opts.jpeg)
-            output = output.jpeg(opts.jpeg);
-          break;
-        case "jp2":
-          if (opts.jp2)
-            output = output.jp2(opts.jp2);
-          break;
-        case "jxl":
-          if (opts.jxl)
-            output = output.jxl(opts.jxl);
-          break;
-        case "png":
-          if (opts.png)
-            output = output.png(opts.png);
-          break;
-        case "tiff":
-          if (opts.tiff)
-            output = output.tiff(opts.tiff);
-          break;
-        case "webp":
-          if (opts.webp)
-            output = output.webp(opts.webp);
-          break;
-      }
-      if (opts.tile)
-        output = output.tile(opts.tile);
-      if (format)
-        output = output.toFormat(format);
-      const result = await output.toBuffer();
-      writeFile(
-        join(outDir, formatPath(opts.path, result, ctx)),
-        result,
-        null,
-        ctx.logger
-      );
-      return [input, false];
-    },
-    resize: async (spec, input, ctx) => {
-      const { bg, filter, fit, gravity, size, unit } = spec;
-      const [width, height] = computeSize(size, ctx.size, unit);
-      return [
-        input.resize({
-          width,
-          height,
-          fit,
-          kernel: filter,
-          position: gravity ? GRAVITY_POSITION[gravity] : void 0,
-          background: bg ? coerceColor(bg) : void 0
-        }),
-        true
-      ];
-    },
-    rotate: async (spec, input, _) => {
-      const { angle, bg, flipX, flipY } = spec;
-      if (flipX)
-        input = input.flop();
-      if (flipY)
-        input = input.flip();
-      return [input.rotate(angle, { background: coerceColor(bg) }), true];
+      });
     }
+    return { img, meta, outputs: ctx.outputs };
+  } finally {
+    if (ctx.iccFile)
+      deleteFile(ctx.iccFile, ctx.logger);
   }
-);
-const defLayer = defmulti(
-  (x) => x.type,
+};
+const processor = defmulti(
+  (spec) => spec.op,
   {},
   {
-    img: async (layer, _, ctx) => {
-      const { gravity, path, pos, size, unit, ...opts } = layer;
-      const input = sharp(path);
-      const meta = await input.metadata();
-      let imgSize = [meta.width, meta.height];
-      const $pos = positionOrGravity(
-        pos,
-        gravity,
-        imgSize,
-        ctx.size,
-        unit
-      );
-      if (!size)
-        return { input: path, ...$pos, ...opts };
-      ensureSize(meta);
-      imgSize = computeSize(size, imgSize, unit);
-      return {
-        input: await input.resize(imgSize[0], imgSize[1]).png({ compressionLevel: 0 }).toBuffer(),
-        ...$pos,
-        ...opts
-      };
-    },
-    svg: async (layer, _, ctx) => {
-      let { body, gravity, path, pos, unit, ...opts } = layer;
-      if (path)
-        body = readText(path, ctx.logger);
-      const w = +(/width="(\d+)"/.exec(body)?.[1] || 0);
-      const h = +(/height="(\d+)"/.exec(body)?.[1] || 0);
-      return {
-        input: Buffer.from(body),
-        ...positionOrGravity(pos, gravity, [w, h], ctx.size, unit),
-        ...opts
-      };
-    }
+    blur: blurProc,
+    composite: compositeProc,
+    crop: cropProc,
+    dither: ditherProc,
+    exif: exifProc,
+    extend: extendProc,
+    gamma: gammaProc,
+    gray: grayscaleProc,
+    hsbl: hsblProc,
+    nest: nestProc,
+    output: outputProc,
+    resize: resizeProc,
+    rotate: rotateProc
   }
 );
 export {
   LOGGER,
-  defLayer,
-  process,
-  processImage
+  processImage,
+  processor
 };